File: C:/Users/fred/.vscode/extensions/ms-vscode.powershell-2025.4.0/dist/extension.js
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/@microsoft/1ds-core-js/dist/es5/ms.core.js
var require_ms_core = __commonJS({
"node_modules/@microsoft/1ds-core-js/dist/es5/ms.core.js"(exports2, module2) {
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.oneDS = global2.oneDS || {}));
})(exports2, (function(exports3) {
"use strict";
var strShimFunction = "function";
var strShimObject = "object";
var strShimUndefined = "undefined";
var strShimPrototype = "prototype";
var ObjClass$1 = Object;
var ObjProto$1 = ObjClass$1[strShimPrototype];
// @__NO_SIDE_EFFECTS__
function _pureAssign(func1, func2) {
return func1 || func2;
}
// @__NO_SIDE_EFFECTS__
function _pureRef(value, name) {
return value[name];
}
var UNDEF_VALUE = void 0;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
var ObjClass = /* @__PURE__ */ _pureAssign(Object);
var ObjProto = /* @__PURE__ */ _pureRef(ObjClass, PROTOTYPE);
var StrCls = /* @__PURE__ */ _pureAssign(String);
var StrProto = /* @__PURE__ */ _pureRef(StrCls, PROTOTYPE);
var MathCls = /* @__PURE__ */ _pureAssign(Math);
var ArrCls = /* @__PURE__ */ _pureAssign(Array);
var ArrProto = /* @__PURE__ */ _pureRef(ArrCls, PROTOTYPE);
var ArrSlice = /* @__PURE__ */ _pureRef(ArrProto, "slice");
var POLYFILL_TAG = "_polyfill";
var POLYFILL_TYPE_NAME = "__nw21$polytype__";
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
} catch (e) {
return { e };
}
}
// @__NO_SIDE_EFFECTS__
function safeGet(cb, defValue, argArray) {
var result = safe(cb, argArray);
return result.e ? defValue : result.v;
}
var _primitiveTypes;
// @__NO_SIDE_EFFECTS__
function _createIs(theType) {
return function(value) {
return typeof value === theType;
};
}
// @__NO_SIDE_EFFECTS__
function _createObjIs(theName) {
var theType = "[object " + theName + "]";
return function(value) {
return !!(value && /* @__PURE__ */ objToString(value) === theType);
};
}
// @__NO_SIDE_EFFECTS__
function objToString(value) {
return ObjProto[TO_STRING].call(value);
}
// @__NO_SIDE_EFFECTS__
function isTypeof(value, theType) {
return typeof value === theType;
}
// @__NO_SIDE_EFFECTS__
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
// @__NO_SIDE_EFFECTS__
function isStrictUndefined(arg) {
return arg === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isNullOrUndefined(value) {
return value === NULL_VALUE || /* @__PURE__ */ isUndefined(value);
}
// @__NO_SIDE_EFFECTS__
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isPrimitiveType(theType) {
!_primitiveTypes && (_primitiveTypes = ["string", "number", "boolean", UNDEFINED, "symbol", "bigint"]);
return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);
}
var isString = /* @__PURE__ */ _createIs("string");
var isFunction = /* @__PURE__ */ _createIs(FUNCTION);
// @__NO_SIDE_EFFECTS__
function isObject(value) {
if (!value && /* @__PURE__ */ isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = /* @__PURE__ */ _pureRef(ArrCls, "isArray");
var isDate = /* @__PURE__ */ _createObjIs("Date");
var isNumber = /* @__PURE__ */ _createIs("number");
var isBoolean = /* @__PURE__ */ _createIs("boolean");
var isError = /* @__PURE__ */ _createObjIs("Error");
// @__NO_SIDE_EFFECTS__
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
// @__NO_SIDE_EFFECTS__
function isNotTruthy(value) {
return !value || !/* @__PURE__ */ isTruthy(value);
}
// @__NO_SIDE_EFFECTS__
function isTruthy(value) {
return !(!value || /* @__PURE__ */ safeGet(function() {
return !(value && 0 + value);
}, !value));
}
function _returnNothing() {
return;
}
function _returnFalse() {
return false;
}
var asString = /* @__PURE__ */ _pureAssign(StrCls);
var ERROR_TYPE = "[object Error]";
// @__NO_SIDE_EFFECTS__
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? typeof format === "number" ? format : 4 : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
} catch (e) {
propertyValueDump = " - " + /* @__PURE__ */ dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwError(message) {
throw new Error(message);
}
function throwTypeError(message) {
throw new TypeError(message);
}
function _throwIfNullOrUndefined(obj) {
if (/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + /* @__PURE__ */ dumpObj(value) + "' is not a string");
}
}
// @__NO_SIDE_EFFECTS__
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
}
var _objGetOwnPropertyDescriptor$2 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var objHasOwn = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "hasOwn"), polyObjHasOwn);
// @__NO_SIDE_EFFECTS__
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return /* @__PURE__ */ objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (/* @__PURE__ */ isObject(theObject) || isFunction(theObject))) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var _unwrapFunction = _unwrapFunctionWithPoly;
// @__NO_SIDE_EFFECTS__
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function(thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError('"' + asString(funcName) + '" not defined for ' + /* @__PURE__ */ dumpObj(thisArg));
};
}
// @__NO_SIDE_EFFECTS__
function _unwrapProp(propName) {
return function(thisArg) {
return thisArg[propName];
};
}
var _objGetOwnPropertyDescriptor$1 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
// @__NO_SIDE_EFFECTS__
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function() {
return value.l.v;
};
var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = function(newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function(key, value2) {
prop[propMap[key]] = /* @__PURE__ */ isStrictUndefined(value2) ? prop[propMap[key]] : value2;
});
return prop;
}
var objDefineProp = /* @__PURE__ */ _pureRef(ObjClass, "defineProperty");
var objDefineProperties = /* @__PURE__ */ _pureRef(ObjClass, "defineProperties");
function objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {
var desc = {
e: enumerable,
c: configurable
};
if (getProp) {
desc.g = getProp;
}
if (setProp) {
desc.s = setProp;
}
return objDefineProp(target, prop, /* @__PURE__ */ _createProp(desc));
}
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, /* @__PURE__ */ _createProp(propDesc));
}
// @__NO_SIDE_EFFECTS__
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function(key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value,
enumerable: true,
writable: false
});
}
var objIsFrozen = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "isFrozen"), _returnFalse);
var _objFreeze = /* @__PURE__ */ _pureRef(ObjClass, "freeze");
function _doNothing(value) {
return value;
}
// @__NO_SIDE_EFFECTS__
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = /* @__PURE__ */ _pureRef(ObjClass, "assign");
var objKeys = /* @__PURE__ */ _pureRef(ObjClass, "keys");
function _deepFreeze(val, visited) {
if ((isArray(val) || /* @__PURE__ */ isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
for (var lp = 0; lp < visited.length; lp++) {
if (visited[lp] === val) {
return val;
}
}
visited.push(val);
objForEachKey(val, function(_key, propValue) {
_deepFreeze(propValue, visited);
});
objFreeze(val);
}
return val;
}
function objDeepFreeze(value) {
return _objFreeze ? _deepFreeze(value, []) : value;
}
var objFreeze = /* @__PURE__ */ _pureAssign(_objFreeze, _doNothing);
var objSeal = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "seal"), _doNothing);
var objGetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "getPrototypeOf"), _getProto);
// @__NO_SIDE_EFFECTS__
function createEnum(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 1, 0, objFreeze);
}
// @__NO_SIDE_EFFECTS__
function createEnumKeyMap(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 0, 0, objFreeze);
}
var _wellKnownSymbolMap = /* @__PURE__ */ createEnumKeyMap({
asyncIterator: 0,
hasInstance: 1,
isConcatSpreadable: 2,
iterator: 3,
match: 4,
matchAll: 5,
replace: 6,
search: 7,
species: 8,
split: 9,
toPrimitive: 10,
toStringTag: 11,
unscopables: 12
});
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
// @__NO_SIDE_EFFECTS__
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var mathMax = /* @__PURE__ */ _pureRef(MathCls, "max");
var strSlice = /* @__PURE__ */ _unwrapFunction("slice", StrProto);
var strSubstring = /* @__PURE__ */ _unwrapFunction("substring", StrProto);
var strSubstr = /* @__PURE__ */ _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
// @__NO_SIDE_EFFECTS__
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(value);
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (/* @__PURE__ */ isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
// @__NO_SIDE_EFFECTS__
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(function() {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
var objCreate = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "create"), polyObjCreate);
// @__NO_SIDE_EFFECTS__
function polyObjCreate(obj, properties) {
var newObj = null;
function tempFunc() {
}
if (!/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + /* @__PURE__ */ dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(function() {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
} else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
// @__NO_SIDE_EFFECTS__
function utcNow() {
return (Date.now || polyUtcNow)();
}
// @__NO_SIDE_EFFECTS__
function polyUtcNow() {
return (/* @__PURE__ */ new Date()).getTime();
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = /* @__PURE__ */ _getGlobalConfig();
}
// @__NO_SIDE_EFFECTS__
function getLazy(cb, argArray) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function() {
var result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
var mathRandom = /* @__PURE__ */ _pureRef(MathCls, "random");
var _uniqueInstanceId = /* @__PURE__ */ getLazy(function() {
var value = (/* @__PURE__ */ utcNow()).toString(36).slice(2);
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
});
var UNIQUE_REGISTRY_ID = "_urid";
var POLY_SYM = "$nw21sym";
var _polySymbols;
var _polyId = 0;
// @__NO_SIDE_EFFECTS__
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = /* @__PURE__ */ _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
var _wellKnownSymbolCache;
// @__NO_SIDE_EFFECTS__
function polyNewSymbol(description) {
var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
var symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
var theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, function() {
return symString + POLY_SYM + uniqueId;
});
_setProp("valueOf", function() {
return theSymbol;
});
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
// @__NO_SIDE_EFFECTS__
function polySymbolFor(key) {
var registry = /* @__PURE__ */ _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = /* @__PURE__ */ polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function() {
return regId_1 + "_" + newSymbol_1[TO_STRING]();
};
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
// @__NO_SIDE_EFFECTS__
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
var result;
var knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || /* @__PURE__ */ polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
// @__NO_SIDE_EFFECTS__
function createCachedValue(value) {
return objDefineProp({
toJSON: function() {
return value;
}
}, "v", { value });
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function() {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = /* @__PURE__ */ createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = /* @__PURE__ */ createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
// @__NO_SIDE_EFFECTS__
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
} else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
} catch (e) {
}
}
return NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function hasDocument() {
return !!/* @__PURE__ */ getDocument();
}
var getDocument = /* @__PURE__ */ _getGlobalInstFn(getInst, ["document"]);
// @__NO_SIDE_EFFECTS__
function hasWindow() {
return !!/* @__PURE__ */ getWindow();
}
var getWindow = /* @__PURE__ */ _getGlobalInstFn(getInst, [WINDOW]);
// @__NO_SIDE_EFFECTS__
function hasNavigator() {
return !!/* @__PURE__ */ getNavigator();
}
var getNavigator = /* @__PURE__ */ _getGlobalInstFn(getInst, ["navigator"]);
// @__NO_SIDE_EFFECTS__
function hasHistory() {
return !!/* @__PURE__ */ getHistory();
}
var getHistory = /* @__PURE__ */ _getGlobalInstFn(getInst, ["history"]);
var isNode = /* @__PURE__ */ _getGlobalInstFn(function() {
return !!safe(function() {
return process && (process.versions || {}).node;
}).v;
});
var _symbol;
var _symbolFor;
// @__NO_SIDE_EFFECTS__
function _initSymbol() {
_symbol = /* @__PURE__ */ createCachedValue(safe(getInst, [SYMBOL]).v);
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return gblSym.v ? gblSym.v[key] : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function hasSymbol() {
return !!/* @__PURE__ */ getSymbol();
}
// @__NO_SIDE_EFFECTS__
function getSymbol() {
!_globalLazyTestHooks && _initTestHooks();
return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol()).v;
}
// @__NO_SIDE_EFFECTS__
function getKnownSymbol(name, noPoly) {
var knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v[knownName || name] : !noPoly ? /* @__PURE__ */ polyGetKnownSymbol(name) : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v(description) : !noPoly ? /* @__PURE__ */ polyNewSymbol(description) : NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = (!_globalLazyTestHooks.lzy ? _symbolFor : 0) || /* @__PURE__ */ createCachedValue(safe(_getSymbolKey, ["for"]).v);
return (_symbolFor.v || polySymbolFor)(key);
}
// @__NO_SIDE_EFFECTS__
function isIterator(value) {
return !!value && isFunction(value.next);
}
// @__NO_SIDE_EFFECTS__
function isIterable(value) {
return !/* @__PURE__ */ isStrictNullOrUndefined(value) && isFunction(value[/* @__PURE__ */ getKnownSymbol(3)]);
}
var _iterSymbol$1;
function iterForOf(iter, callbackfn, thisArg) {
if (iter) {
if (!/* @__PURE__ */ isIterator(iter)) {
!_iterSymbol$1 && (_iterSymbol$1 = /* @__PURE__ */ createCachedValue(/* @__PURE__ */ getKnownSymbol(3)));
iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
}
if (/* @__PURE__ */ isIterator(iter)) {
var err = UNDEF_VALUE;
var iterResult = UNDEF_VALUE;
try {
var count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
break;
}
count++;
}
} catch (failed) {
err = { e: failed };
if (iter.throw) {
iterResult = NULL_VALUE;
iter.throw(err);
}
} finally {
try {
if (iterResult && !iterResult.done) {
iter.return && iter.return(iterResult);
}
} finally {
if (err) {
throw err.e;
}
}
}
}
}
}
function arrAppend(target, elms) {
if (!/* @__PURE__ */ isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
} else if (/* @__PURE__ */ isIterator(elms) || /* @__PURE__ */ isIterable(elms)) {
iterForOf(elms, function(elm) {
target.push(elm);
});
} else {
target.push(elms);
}
}
return target;
}
var arrIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", ArrProto);
var arrMap = /* @__PURE__ */ _unwrapFunction("map", ArrProto);
function arrSlice(theArray, start, end) {
return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
}
// @__NO_SIDE_EFFECTS__
function polyArrIncludes(theArray, searchElement, fromIndex) {
return arrIndexOf(theArray, searchElement, fromIndex) !== -1;
}
var arrIncludes = /* @__PURE__ */ _unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes);
var arrReduce = /* @__PURE__ */ _unwrapFunction("reduce", ArrProto);
var _isProtoArray;
var objSetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "setPrototypeOf"), _polyObjSetPrototypeOf);
function _polyObjSetPrototypeOf(obj, proto) {
var _a2;
!_isProtoArray && (_isProtoArray = /* @__PURE__ */ createCachedValue((_a2 = {}, _a2[__PROTO__] = [], _a2) instanceof Array));
_isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function(key, value) {
return obj[key] = value;
});
return obj;
}
// @__NO_SIDE_EFFECTS__
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
// @__NO_SIDE_EFFECTS__
function createCustomError(name, constructCb, errorBase) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return /* @__PURE__ */ _createCustomError(name, function() {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
} finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
// @__NO_SIDE_EFFECTS__
function _createTrimFn(exp) {
return function _doTrim(value) {
_throwIfNullOrUndefined(value);
if (value && value.replace) {
value = value.replace(exp, EMPTY);
}
return value;
};
}
var polyStrTrim = /* @__PURE__ */ _createTrimFn(/^\s+|(?=\s)\s+$/g);
var strTrim = /* @__PURE__ */ _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
var mathFloor = /* @__PURE__ */ _pureRef(MathCls, "floor");
var _fnToString;
var _objCtrFnString;
var _gblWindow;
// @__NO_SIDE_EFFECTS__
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = /* @__PURE__ */ hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (/* @__PURE__ */ objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
} catch (ex) {
}
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _defaultDeepCopyHandler(details) {
details.value && plainObjDeepCopyHandler(details);
return true;
}
var defaultDeepCopyHandlers = [
arrayDeepCopyHandler,
plainObjDeepCopyHandler,
functionDeepCopyHandler,
dateDeepCopyHandler
];
// @__NO_SIDE_EFFECTS__
function _getSetVisited(visitMap, source, newPath, cb) {
var theEntry;
arrForEach(visitMap, function(entry) {
if (entry.k === source) {
theEntry = entry;
return -1;
}
});
if (!theEntry) {
theEntry = { k: source, v: source };
visitMap.push(theEntry);
cb(theEntry);
}
return theEntry.v;
}
function _deepCopy(visitMap, value, ctx, key) {
var userHandler = ctx.handler;
var newPath = ctx.path ? key ? ctx.path.concat(key) : ctx.path : [];
var newCtx = {
handler: ctx.handler,
src: ctx.src,
path: newPath
};
var theType = typeof value;
var isPlain = false;
var isPrim = value === NULL_VALUE;
if (!isPrim) {
if (value && theType === OBJECT) {
isPlain = /* @__PURE__ */ isPlainObject(value);
} else {
isPrim = /* @__PURE__ */ isPrimitiveType(theType);
}
}
var details = {
type: theType,
isPrim,
isPlain,
value,
result: value,
path: newPath,
origin: ctx.src,
copy: function(source, newKey) {
return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
},
copyTo: function(target, source) {
return _copyProps(visitMap, target, source, newCtx);
}
};
if (!details.isPrim) {
return /* @__PURE__ */ _getSetVisited(visitMap, value, newPath, function(newEntry) {
objDefine(details, "result", {
g: function() {
return newEntry.v;
},
s: function(newValue) {
newEntry.v = newValue;
}
});
var idx = 0;
var handler = userHandler;
while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler))[CALL](ctx, details)) {
handler = NULL_VALUE;
}
});
}
if (userHandler && userHandler[CALL](ctx, details)) {
return details.result;
}
return value;
}
function _copyProps(visitMap, target, source, ctx) {
if (!/* @__PURE__ */ isNullOrUndefined(source)) {
for (var key in source) {
target[key] = _deepCopy(visitMap, source[key], ctx, key);
}
}
return target;
}
function objCopyProps(target, source, handler) {
var ctx = {
handler,
src: source,
path: []
};
return _copyProps([], target, source, ctx);
}
// @__NO_SIDE_EFFECTS__
function objDeepCopy(source, handler) {
var ctx = {
handler,
src: source
};
return _deepCopy([], source, ctx);
}
function arrayDeepCopyHandler(details) {
var value = details.value;
if (isArray(value)) {
var target = details.result = [];
target.length = value.length;
details.copyTo(target, value);
return true;
}
return false;
}
function dateDeepCopyHandler(details) {
var value = details.value;
if (isDate(value)) {
details.result = new Date(value.getTime());
return true;
}
return false;
}
function functionDeepCopyHandler(details) {
if (details.type === FUNCTION) {
return true;
}
return false;
}
function plainObjDeepCopyHandler(details) {
var value = details.value;
if (value && details.isPlain) {
var target = details.result = {};
details.copyTo(target, value);
return true;
}
return false;
}
function _doExtend(target, theArgs) {
arrForEach(theArgs, function(theArg) {
objCopyProps(target, theArg);
});
return target;
}
function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
return _doExtend(/* @__PURE__ */ objDeepCopy(target) || {}, ArrSlice[CALL](arguments));
}
var getLength = /* @__PURE__ */ _unwrapProp(LENGTH);
var _perf;
// @__NO_SIDE_EFFECTS__
function getPerformance() {
!_globalLazyTestHooks && _initTestHooks();
if (!_perf || _globalLazyTestHooks.lzy) {
_perf = /* @__PURE__ */ createCachedValue(safe(getInst, ["performance"]).v);
}
return _perf.v;
}
// @__NO_SIDE_EFFECTS__
function perfNow() {
var perf = /* @__PURE__ */ getPerformance();
if (perf && perf.now) {
return perf.now();
}
return /* @__PURE__ */ utcNow();
}
var objGetOwnPropertyDescriptor = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var strEndsWith = /* @__PURE__ */ _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith);
// @__NO_SIDE_EFFECTS__
function polyStrEndsWith(value, searchString, length) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var end = !/* @__PURE__ */ isUndefined(length) && length < value[LENGTH] ? length : value[LENGTH];
return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
}
var strIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", StrProto);
var strStartsWith = /* @__PURE__ */ _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith);
// @__NO_SIDE_EFFECTS__
function polyStrStartsWith(value, searchString, position) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var pos = position > 0 ? position : 0;
return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
}
var REF = "ref";
var UNREF = "unref";
var HAS_REF = "hasRef";
var ENABLED = "enabled";
// @__NO_SIDE_EFFECTS__
function _createTimerHandler(startTimer, refreshFn, cancelFn) {
var ref = true;
var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
var theTimerHandler;
function _unref() {
ref = false;
timerId && timerId[UNREF] && timerId[UNREF]();
return theTimerHandler;
}
function _cancel() {
timerId && cancelFn(timerId);
timerId = NULL_VALUE;
}
function _refresh() {
timerId = refreshFn(timerId);
if (!ref) {
_unref();
}
return theTimerHandler;
}
function _setEnabled(value) {
!value && timerId && _cancel();
value && !timerId && _refresh();
}
theTimerHandler = {
cancel: _cancel,
refresh: _refresh
};
theTimerHandler[HAS_REF] = function() {
if (timerId && timerId[HAS_REF]) {
return timerId[HAS_REF]();
}
return ref;
};
theTimerHandler[REF] = function() {
ref = true;
timerId && timerId[REF] && timerId[REF]();
return theTimerHandler;
};
theTimerHandler[UNREF] = _unref;
theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
get: function() {
return !!timerId;
},
set: _setEnabled
});
return {
h: theTimerHandler,
dn: function() {
timerId = NULL_VALUE;
}
};
}
var _setTimeoutFn;
var _clearTimeoutFn;
function _resolveTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
result = globalOverrides[0];
}
}
return result || setTimeout;
}
function _resolveClearTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
result = globalOverrides[1];
}
}
return result || clearTimeout;
}
function _createTimeoutWith(startTimer, overrideFn, theArgs) {
var isArr = isArray(overrideFn);
var len = isArr ? overrideFn.length : 0;
var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : !isArr ? overrideFn : UNDEF_VALUE);
var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
var timerFn = theArgs[0];
theArgs[0] = function() {
handler.dn();
fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
};
var handler = /* @__PURE__ */ _createTimerHandler(startTimer, function(timerId) {
if (timerId) {
if (timerId.refresh) {
timerId.refresh();
return timerId;
}
fnApply(clearFn, UNDEF_VALUE, [timerId]);
}
return fnApply(setFn, UNDEF_VALUE, theArgs);
}, function(timerId) {
fnApply(clearFn, UNDEF_VALUE, [timerId]);
});
return handler.h;
}
function scheduleTimeout(callback, timeout) {
return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
function createTimeout(callback, timeout) {
return _createTimeoutWith(false, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
(getGlobal() || {})["Symbol"];
(getGlobal() || {})["Reflect"];
var strHasOwnProperty = "hasOwnProperty";
var extendStaticsFn = function(d, b) {
extendStaticsFn = ObjClass$1["setPrototypeOf"] || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) {
if (b2[strHasOwnProperty](p)) {
d2[p] = b2[p];
}
}
};
return extendStaticsFn(d, b);
};
function __extendsFn(d, b) {
if (typeof b !== strShimFunction && b !== null) {
throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
}
extendStaticsFn(d, b);
function __() {
this.constructor = d;
}
d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
}
function __spreadArrayFn(to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {
to[j] = from[i];
}
return to;
}
var _a$5;
var Constructor = "constructor";
var Prototype = "prototype";
var strFunction = "function";
var DynInstFuncTable = "_dynInstFuncs";
var DynProxyTag = "_isDynProxy";
var DynClassName = "_dynClass";
var DynClassNamePrefix = "_dynCls$";
var DynInstChkTag = "_dynInstChk";
var DynAllowInstChkTag = DynInstChkTag;
var DynProtoDefaultOptions = "_dfOpts";
var UnknownValue = "_unknown_";
var str__Proto = "__proto__";
var DynProtoBaseProto = "_dyn" + str__Proto;
var DynProtoGlobalSettings = "__dynProto$Gbl";
var DynProtoCurrent = "_dynInstProto";
var strUseBaseInst = "useBaseInst";
var strSetInstFuncs = "setInstFuncs";
var Obj = Object;
var _objGetPrototypeOf = Obj["getPrototypeOf"];
var _objGetOwnProps = Obj["getOwnPropertyNames"];
var _gbl = getGlobal();
var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
o: (_a$5 = {}, _a$5[strSetInstFuncs] = true, _a$5[strUseBaseInst] = true, _a$5),
n: 1e3
});
function _isObjectOrArrayPrototype(target) {
return target && (target === Obj[Prototype] || target === Array[Prototype]);
}
function _isObjectArrayOrFunctionPrototype(target) {
return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
}
function _getObjProto(target) {
var newProto;
if (target) {
if (_objGetPrototypeOf) {
return _objGetPrototypeOf(target);
}
var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
newProto = target[DynProtoBaseProto] || curProto;
if (!/* @__PURE__ */ objHasOwnProperty(target, DynProtoBaseProto)) {
delete target[DynProtoCurrent];
newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
target[DynProtoCurrent] = curProto;
}
}
return newProto;
}
function _forEachProp(target, func) {
var props = [];
if (_objGetOwnProps) {
props = _objGetOwnProps(target);
} else {
for (var name_1 in target) {
if (typeof name_1 === "string" && /* @__PURE__ */ objHasOwnProperty(target, name_1)) {
props.push(name_1);
}
}
}
if (props && props.length > 0) {
for (var lp = 0; lp < props.length; lp++) {
func(props[lp]);
}
}
}
function _isDynamicCandidate(target, funcName, skipOwn) {
return funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || /* @__PURE__ */ objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype;
}
function _throwTypeError(message) {
throwTypeError("DynamicProto: " + message);
}
function _getInstanceFuncs(thisTarget) {
var instFuncs = objCreate(null);
_forEachProp(thisTarget, function(name) {
if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
instFuncs[name] = thisTarget[name];
}
});
return instFuncs;
}
function _hasVisited(values, value) {
for (var lp = values.length - 1; lp >= 0; lp--) {
if (values[lp] === value) {
return true;
}
}
return false;
}
function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
function _instFuncProxy(target, funcHost, funcName) {
var theFunc = funcHost[funcName];
if (theFunc[DynProxyTag] && useBaseInst) {
var instFuncTable = target[DynInstFuncTable] || {};
if (instFuncTable[DynAllowInstChkTag] !== false) {
theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
}
}
return function() {
return theFunc.apply(target, arguments);
};
}
var baseFuncs = objCreate(null);
_forEachProp(instFuncs, function(name) {
baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
});
var baseProto = _getObjProto(classProto);
var visited = [];
while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
_forEachProp(baseProto, function(name) {
if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
}
});
visited.push(baseProto);
baseProto = _getObjProto(baseProto);
}
return baseFuncs;
}
function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
var instFunc = null;
if (target && /* @__PURE__ */ objHasOwnProperty(proto, DynClassName)) {
var instFuncTable = target[DynInstFuncTable] || objCreate(null);
instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
if (!instFunc) {
_throwTypeError("Missing [" + funcName + "] " + strFunction);
}
if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
var canAddInst = !/* @__PURE__ */ objHasOwnProperty(target, funcName);
var objProto = _getObjProto(target);
var visited = [];
while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
var protoFunc = objProto[funcName];
if (protoFunc) {
canAddInst = protoFunc === currentDynProtoProxy;
break;
}
visited.push(objProto);
objProto = _getObjProto(objProto);
}
try {
if (canAddInst) {
target[funcName] = instFunc;
}
instFunc[DynInstChkTag] = 1;
} catch (e) {
instFuncTable[DynAllowInstChkTag] = false;
}
}
}
return instFunc;
}
function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
var protoFunc = proto[funcName];
if (protoFunc === currentDynProtoProxy) {
protoFunc = _getObjProto(proto)[funcName];
}
if (typeof protoFunc !== strFunction) {
_throwTypeError("[" + funcName + "] is not a " + strFunction);
}
return protoFunc;
}
function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
function _createDynamicPrototype(proto2, funcName) {
var dynProtoProxy = function() {
var instFunc = _getInstFunc(this, funcName, proto2, dynProtoProxy) || _getProtoFunc(funcName, proto2, dynProtoProxy);
return instFunc.apply(this, arguments);
};
dynProtoProxy[DynProxyTag] = 1;
return dynProtoProxy;
}
if (!_isObjectOrArrayPrototype(proto)) {
var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
if (!_isObjectOrArrayPrototype(instFuncTable)) {
var instFuncs_1 = instFuncTable[className] = instFuncTable[className] || objCreate(null);
if (instFuncTable[DynAllowInstChkTag] !== false) {
instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
}
if (!_isObjectOrArrayPrototype(instFuncs_1)) {
_forEachProp(target, function(name) {
if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
instFuncs_1[name] = target[name];
delete target[name];
if (!/* @__PURE__ */ objHasOwnProperty(proto, name) || proto[name] && !proto[name][DynProxyTag]) {
proto[name] = _createDynamicPrototype(proto, name);
}
}
});
}
}
}
}
function _checkPrototype(classProto, thisTarget) {
if (_objGetPrototypeOf) {
var visited = [];
var thisProto = _getObjProto(thisTarget);
while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
if (thisProto === classProto) {
return true;
}
visited.push(thisProto);
thisProto = _getObjProto(thisProto);
}
return false;
}
return true;
}
function _getObjName(target, unknownValue) {
if (/* @__PURE__ */ objHasOwnProperty(target, Prototype)) {
return target.name || unknownValue || UnknownValue;
}
return ((target || {})[Constructor] || {}).name || unknownValue || UnknownValue;
}
function dynamicProto(theClass, target, delegateFunc, options) {
if (!/* @__PURE__ */ objHasOwnProperty(theClass, Prototype)) {
_throwTypeError("theClass is an invalid class definition.");
}
var classProto = theClass[Prototype];
if (!_checkPrototype(classProto, target)) {
_throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
}
var className = null;
if (/* @__PURE__ */ objHasOwnProperty(classProto, DynClassName)) {
className = classProto[DynClassName];
} else {
className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
_gblInst.n++;
classProto[DynClassName] = className;
}
var perfOptions = dynamicProto[DynProtoDefaultOptions];
var useBaseInst = !!perfOptions[strUseBaseInst];
if (useBaseInst && options && options[strUseBaseInst] !== void 0) {
useBaseInst = !!options[strUseBaseInst];
}
var instFuncs = _getInstanceFuncs(target);
var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
delegateFunc(target, baseFuncs);
var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
if (setInstanceFunc && options) {
setInstanceFunc = !!options[strSetInstFuncs];
}
_populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
}
dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
var MinChannelPriorty = 100;
var createEnumStyle = createEnum;
var EventsDiscardedReason = /* @__PURE__ */ createEnumStyle({
Unknown: 0,
NonRetryableStatus: 1,
InvalidEvent: 2,
SizeLimitExceeded: 3,
KillSwitch: 4,
QueueFull: 5
});
var ActiveStatus = /* @__PURE__ */ createEnumStyle({
NONE: 0,
PENDING: 3,
INACTIVE: 1,
ACTIVE: 2
});
var _DYN_TO_LOWER_CASE = "toLowerCase";
var _DYN_LENGTH$1 = "length";
var _DYN_WARN_TO_CONSOLE = "warnToConsole";
var _DYN_THROW_INTERNAL = "throwInternal";
var _DYN_WATCH = "watch";
var _DYN_APPLY = "apply";
var _DYN_PUSH = "push";
var _DYN_SPLICE = "splice";
var _DYN_LOGGER = "logger";
var _DYN_CANCEL = "cancel";
var _DYN_INITIALIZE$1 = "initialize";
var _DYN_IDENTIFIER = "identifier";
var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
var _DYN_IS_INITIALIZED = "isInitialized";
var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
var _DYN_GET_PLUGIN = "getPlugin";
var _DYN_NAME = "name";
var _DYN_PROCESS_NEXT = "processNext";
var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
var _DYN_VALUE$1 = "value";
var _DYN_ENABLED = "enabled";
var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
var _DYN_UNLOAD = "unload";
var _DYN_ON_COMPLETE = "onComplete";
var _DYN_VERSION = "version";
var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
var _DYN_CREATE_NEW = "createNew";
var _DYN_TEARDOWN = "teardown";
var _DYN_MESSAGE_ID = "messageId";
var _DYN_MESSAGE = "message";
var _DYN_DIAG_LOG = "diagLog";
var _DYN__DO_TEARDOWN = "_doTeardown";
var _DYN_UPDATE = "update";
var _DYN_GET_NEXT = "getNext";
var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
var _DYN_USER_AGENT = "userAgent";
var _DYN_SPLIT = "split";
var _DYN_REPLACE = "replace";
var _DYN_SUBSTRING = "substring";
var _DYN_INDEX_OF$1 = "indexOf";
var _DYN_TYPE = "type";
var _DYN_EVT_NAME = "evtName";
var _DYN_STATUS = "status";
var _DYN_GET_ALL_RESPONSE_HEA5 = "getAllResponseHeaders";
var _DYN_IS_CHILD_EVT = "isChildEvt";
var _DYN_DATA = "data";
var _DYN_GET_CTX = "getCtx";
var _DYN_SET_CTX = "setCtx";
var _DYN_ITEMS_RECEIVED = "itemsReceived";
var _DYN_HEADERS = "headers";
var _DYN_URL_STRING = "urlString";
var _DYN_TIMEOUT = "timeout";
var _DYN_TRACE_FLAGS = "traceFlags";
var aggregationErrorType;
function throwAggregationError(message, sourceErrors) {
if (!aggregationErrorType) {
aggregationErrorType = /* @__PURE__ */ createCustomError("AggregationError", function(self2, args) {
if (args[_DYN_LENGTH$1] > 1) {
self2.errors = args[1];
}
});
}
var theMessage = message || "One or more errors occurred.";
arrForEach(sourceErrors, function(srcError, idx) {
theMessage += "\n".concat(idx, " > ").concat(/* @__PURE__ */ dumpObj(srcError));
});
throw new aggregationErrorType(theMessage, sourceErrors || []);
}
var STR_PROMISE = "Promise";
var REJECTED = "rejected";
function doAwaitResponse(value, cb) {
return doAwait(value, function(value2) {
return cb ? cb({
status: "fulfilled",
rejected: false,
value: value2
}) : value2;
}, function(reason) {
return cb ? cb({
status: REJECTED,
rejected: true,
reason
}) : reason;
});
}
function doAwait(value, resolveFn, rejectFn, finallyFn) {
var result = value;
try {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (resolveFn || rejectFn) {
result = value.then(resolveFn, rejectFn);
}
} else {
try {
if (resolveFn) {
result = resolveFn(value);
}
} catch (err) {
if (rejectFn) {
result = rejectFn(err);
} else {
throw err;
}
}
}
} finally {
if (finallyFn) {
doFinally(result, finallyFn);
}
}
return result;
}
function doFinally(value, finallyFn) {
var result = value;
if (finallyFn) {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (value.finally) {
result = value.finally(finallyFn);
} else {
result = value.then(function(value2) {
finallyFn();
return value2;
}, function(reason) {
finallyFn();
throw reason;
});
}
} else {
finallyFn();
}
}
return result;
}
var STRING_STATES = [
"pending",
"resolving",
"resolved",
REJECTED
];
var DISPATCH_EVENT = "dispatchEvent";
var _hasInitEvent;
function _hasInitEventFn(doc) {
var evt;
if (doc && doc.createEvent) {
evt = doc.createEvent("Event");
}
return !!evt && evt.initEvent;
}
function emitEvent(target, evtName, populateEvent, useNewEvent) {
var doc = getDocument();
!_hasInitEvent && (_hasInitEvent = /* @__PURE__ */ createCachedValue(!!safe(_hasInitEventFn, [doc]).v));
var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : useNewEvent ? new Event(evtName) : {};
populateEvent && populateEvent(theEvt);
if (_hasInitEvent.v) {
theEvt.initEvent(evtName, false, true);
}
if (theEvt && target[DISPATCH_EVENT]) {
target[DISPATCH_EVENT](theEvt);
} else {
var handler = target["on" + evtName];
if (handler) {
handler(theEvt);
} else {
var theConsole = /* @__PURE__ */ getInst("console");
theConsole && (theConsole["error"] || theConsole["log"])(evtName, /* @__PURE__ */ dumpObj(theEvt));
}
}
}
var NODE_UNHANDLED_REJECTION = "unhandledRejection";
var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
var _unhandledRejectionTimeout = 10;
var _hasPromiseRejectionEvent;
function dumpFnObj(value) {
if (isFunction(value)) {
return value.toString();
}
return /* @__PURE__ */ dumpObj(value);
}
function _createPromise(newPromise, processor, executor) {
var additionalArgs = arrSlice(arguments, 3);
var _state = 0;
var _hasResolved = false;
var _settledValue;
var _queue = [];
var _handled = false;
var _unHandledRejectionHandler = null;
var _thePromise;
function _then(onResolved, onRejected) {
try {
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
var thenPromise = newPromise(function(resolve3, reject) {
_queue.push(function() {
try {
var handler = _state === 2 ? onResolved : onRejected;
var value = /* @__PURE__ */ isUndefined(handler) ? _settledValue : isFunction(handler) ? handler(_settledValue) : handler;
if (/* @__PURE__ */ isPromiseLike(value)) {
value.then(resolve3, reject);
} else if (handler) {
resolve3(value);
} else if (_state === 3) {
reject(value);
} else {
resolve3(value);
}
} catch (e) {
reject(e);
}
});
if (_hasResolved) {
_processQueue();
}
}, additionalArgs);
return thenPromise;
} finally {
}
}
function _catch(onRejected) {
return _then(void 0, onRejected);
}
function _finally(onFinally) {
var thenFinally = onFinally;
var catchFinally = onFinally;
if (isFunction(onFinally)) {
thenFinally = function(value) {
onFinally && onFinally();
return value;
};
catchFinally = function(reason) {
onFinally && onFinally();
throw reason;
};
}
return _then(thenFinally, catchFinally);
}
function _strState() {
return STRING_STATES[_state];
}
function _processQueue() {
if (_queue.length > 0) {
var pending = _queue.slice();
_queue = [];
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
processor(pending);
}
}
function _createSettleIfFn(newState, allowState) {
return function(theValue) {
if (_state === allowState) {
if (newState === 2 && /* @__PURE__ */ isPromiseLike(theValue)) {
_state = 1;
theValue.then(_createSettleIfFn(2, 1), _createSettleIfFn(3, 1));
return;
}
_state = newState;
_hasResolved = true;
_settledValue = theValue;
_processQueue();
if (!_handled && newState === 3 && !_unHandledRejectionHandler) {
_unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
}
}
};
}
function _notifyUnhandledRejection() {
if (!_handled) {
_handled = true;
if (isNode()) {
process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
} else {
var gbl = getWindow() || getGlobal();
!_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE + "RejectionEvent"]).v));
emitEvent(gbl, UNHANDLED_REJECTION, function(theEvt) {
objDefine(theEvt, "promise", { g: function() {
return _thePromise;
} });
theEvt.reason = _settledValue;
return theEvt;
}, !!_hasPromiseRejectionEvent.v);
}
}
}
_thePromise = {
then: _then,
"catch": _catch,
finally: _finally
};
objDefineProp(_thePromise, "state", {
get: _strState
});
if (/* @__PURE__ */ hasSymbol()) {
_thePromise[/* @__PURE__ */ getKnownSymbol(11)] = "IPromise";
}
function _toString() {
return "IPromise " + _strState() + (_hasResolved ? " - " + dumpFnObj(_settledValue) : "");
}
_thePromise.toString = _toString;
(function _initialize() {
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
}
var _rejectFn = _createSettleIfFn(3, 0);
try {
executor.call(_thePromise, _createSettleIfFn(2, 0), _rejectFn);
} catch (e) {
_rejectFn(e);
}
})();
return _thePromise;
}
// @__NO_SIDE_EFFECTS__
function _createAllPromise(newPromise) {
return function(input) {
var additionalArgs = arrSlice(arguments, 1);
return newPromise(function(resolve3, reject) {
try {
var values_1 = [];
var pending_1 = 1;
iterForOf(input, function(item, idx) {
if (item) {
pending_1++;
doAwait(item, function(value) {
values_1[idx] = value;
if (--pending_1 === 0) {
resolve3(values_1);
}
}, reject);
}
});
pending_1--;
if (pending_1 === 0) {
resolve3(values_1);
}
} catch (e) {
reject(e);
}
}, additionalArgs);
};
}
// @__NO_SIDE_EFFECTS__
function _createAllSettledPromise(newPromise) {
return /* @__PURE__ */ createCachedValue(function(input) {
var additionalArgs = arrSlice(arguments, 1);
return newPromise(function(resolve3, reject) {
var values = [];
var pending = 1;
function processItem(item, idx) {
pending++;
doAwaitResponse(item, function(value) {
if (value.rejected) {
values[idx] = {
status: REJECTED,
reason: value.reason
};
} else {
values[idx] = {
status: "fulfilled",
value: value.value
};
}
if (--pending === 0) {
resolve3(values);
}
});
}
try {
if (isArray(input)) {
arrForEach(input, processItem);
} else if (/* @__PURE__ */ isIterable(input)) {
iterForOf(input, processItem);
} else {
throwTypeError("Input is not an iterable");
}
pending--;
if (pending === 0) {
resolve3(values);
}
} catch (e) {
reject(e);
}
}, additionalArgs);
});
}
function syncItemProcessor(pending) {
arrForEach(pending, function(fn) {
try {
fn();
} catch (e) {
}
});
}
function timeoutItemProcessor(timeout) {
var callbackTimeout = isNumber(timeout) ? timeout : 0;
return function(pending) {
scheduleTimeout(function() {
syncItemProcessor(pending);
}, callbackTimeout);
};
}
function createAsyncPromise(executor, timeout) {
return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
}
var _promiseCls;
function createNativePromise(executor, timeout) {
!_promiseCls && (_promiseCls = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE]).v || null));
var PrmCls = _promiseCls.v;
if (!PrmCls) {
return createAsyncPromise(executor);
}
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + /* @__PURE__ */ dumpObj(executor));
}
var _state = 0;
function _strState() {
return STRING_STATES[_state];
}
var thePromise = new PrmCls(function(resolve3, reject) {
function _resolve(value) {
_state = 2;
resolve3(value);
}
function _reject(reason) {
_state = 3;
reject(reason);
}
executor(_resolve, _reject);
});
objDefineProp(thePromise, "state", {
get: _strState
});
return thePromise;
}
var _allSyncSettledCreator;
function createSyncPromise(executor) {
return _createPromise(createSyncPromise, syncItemProcessor, executor);
}
function createSyncAllSettledPromise(input, timeout) {
!_allSyncSettledCreator && (_allSyncSettledCreator = /* @__PURE__ */ _createAllSettledPromise(createSyncPromise));
return _allSyncSettledCreator.v(input, timeout);
}
var _promiseCreator;
function createPromise(executor, timeout) {
!_promiseCreator && (_promiseCreator = /* @__PURE__ */ createCachedValue(createNativePromise));
return _promiseCreator.v.call(this, executor, timeout);
}
var createAllPromise = /* @__PURE__ */ _createAllPromise(createPromise);
var UNDEFINED_VALUE = void 0;
var STR_EMPTY$2 = "";
var STR_CHANNELS = "channels";
var STR_CORE = "core";
var STR_CREATE_PERF_MGR = "createPerfMgr";
var STR_DISABLED = "disabled";
var STR_EXTENSION_CONFIG = "extensionConfig";
var STR_EXTENSIONS = "extensions";
var STR_PROCESS_TELEMETRY = "processTelemetry";
var STR_PRIORITY = "priority";
var STR_EVENTS_SENT = "eventsSent";
var STR_EVENTS_DISCARDED = "eventsDiscarded";
var STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
var STR_PERF_EVENT = "perfEvent";
var STR_OFFLINE_STORE = "offlineEventsStored";
var STR_OFFLINE_SENT = "offlineBatchSent";
var STR_OFFLINE_DROP = "offlineBatchDrop";
var STR_GET_PERF_MGR = "getPerfMgr";
var STR_DOMAIN = "domain";
var STR_PATH = "path";
var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
var STR_REDACTED = "REDACTED";
var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
var rCamelCase = /-([a-z])/g;
var rNormalizeInvalid = /([^\w\d_$])/g;
var rLeadingNumeric = /^(\d+[\w\d_$])/;
function isNotNullOrUndefined(value) {
return !/* @__PURE__ */ isNullOrUndefined(value);
}
function normalizeJsName(name) {
var value = name;
if (value && isString(value)) {
value = value[_DYN_REPLACE](rCamelCase, function(_all, letter) {
return letter.toUpperCase();
});
value = value[_DYN_REPLACE](rNormalizeInvalid, "_");
value = value[_DYN_REPLACE](rLeadingNumeric, function(_all, match) {
return "_" + match;
});
}
return value;
}
function strContains(value, search) {
if (value && search) {
return strIndexOf(value, search) !== -1;
}
return false;
}
function toISOString(date) {
return date && date.toISOString() || "";
}
function getExceptionName(object) {
if (isError(object)) {
return object[_DYN_NAME];
}
return STR_EMPTY$2;
}
function setValue(target, field, value, valChk, srcChk) {
var theValue = value;
if (target) {
theValue = target[field];
if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
theValue = value;
target[field] = theValue;
}
}
return theValue;
}
function getSetValue(target, field, defValue) {
var theValue;
if (target) {
theValue = target[field];
if (!theValue && /* @__PURE__ */ isNullOrUndefined(theValue)) {
theValue = !/* @__PURE__ */ isUndefined(defValue) ? defValue : {};
target[field] = theValue;
}
} else {
theValue = !/* @__PURE__ */ isUndefined(defValue) ? defValue : {};
}
return theValue;
}
function _createProxyFunction(source, funcName) {
var srcFunc = null;
var src = null;
if (isFunction(source)) {
srcFunc = source;
} else {
src = source;
}
return function() {
var originalArguments = arguments;
if (srcFunc) {
src = srcFunc();
}
if (src) {
return src[funcName][_DYN_APPLY](src, originalArguments);
}
};
}
function proxyAssign(target, source, chkSet) {
if (target && source && /* @__PURE__ */ isObject(target) && /* @__PURE__ */ isObject(source)) {
var _loop_1 = function(field2) {
if (isString(field2)) {
var value = source[field2];
if (isFunction(value)) {
if (!chkSet || chkSet(field2, true, source, target)) {
target[field2] = _createProxyFunction(source, field2);
}
} else if (!chkSet || chkSet(field2, false, source, target)) {
if (objHasOwn(target, field2)) {
delete target[field2];
}
objDefine(target, field2, {
g: function() {
return source[field2];
},
s: function(theValue) {
source[field2] = theValue;
}
});
}
}
};
for (var field in source) {
_loop_1(field);
}
}
return target;
}
function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
if (target && name && source) {
if (overwriteTarget !== false || /* @__PURE__ */ isUndefined(target[name])) {
target[name] = _createProxyFunction(source, theFunc);
}
}
}
function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
if (target && source && /* @__PURE__ */ isObject(target) && isArray(functionsToProxy)) {
arrForEach(functionsToProxy, function(theFuncName) {
if (isString(theFuncName)) {
proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
}
});
}
return target;
}
function optimizeObject(theObject) {
if (theObject && objAssign) {
theObject = ObjClass$1(objAssign({}, theObject));
}
return theObject;
}
function isFeatureEnabled(feature, cfg, sdkDefaultState) {
var ft = cfg && cfg.featureOptIn && cfg.featureOptIn[feature];
if (feature && ft) {
var mode = ft.mode;
if (mode === 3) {
return true;
} else if (mode === 2) {
return false;
}
}
return sdkDefaultState;
}
function getResponseText(xhr) {
try {
return xhr.responseText;
} catch (e) {
}
return null;
}
function formatErrorMessageXdr(xdr, message) {
if (xdr) {
return "XDomainRequest,Response:" + getResponseText(xdr) || "";
}
return message;
}
function formatErrorMessageXhr(xhr, message) {
if (xhr) {
return "XMLHttpRequest,Status:" + xhr[_DYN_STATUS] + ",Response:" + getResponseText(xhr) || xhr.response || "";
}
return message;
}
function prependTransports(theTransports, newTransports) {
if (newTransports) {
if (isNumber(newTransports)) {
theTransports = [newTransports].concat(theTransports);
} else if (isArray(newTransports)) {
theTransports = newTransports.concat(theTransports);
}
}
return theTransports;
}
var strDisabledPropertyName$1 = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var strWithCredentials$1 = "withCredentials";
var strTimeout$1 = "timeout";
function openXhr$1(method, urlString, withCredentials, disabled, isSync, timeout) {
if (disabled === void 0) {
disabled = false;
}
if (isSync === void 0) {
isSync = false;
}
function _wrapSetXhrProp(xhr2, prop, value) {
try {
xhr2[prop] = value;
} catch (e) {
}
}
var xhr = new XMLHttpRequest();
if (disabled) {
_wrapSetXhrProp(xhr, strDisabledPropertyName$1, disabled);
}
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials$1, withCredentials);
}
xhr.open(method, urlString, !isSync);
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials$1, withCredentials);
}
if (!isSync && timeout) {
_wrapSetXhrProp(xhr, strTimeout$1, timeout);
}
return xhr;
}
function convertAllHeadersToMap(headersString) {
var headers = {};
if (isString(headersString)) {
var headersArray = strTrim(headersString)[_DYN_SPLIT](/[\r\n]+/);
arrForEach(headersArray, function(headerEntry) {
if (headerEntry) {
var idx = headerEntry[_DYN_INDEX_OF$1](": ");
if (idx !== -1) {
var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE]();
var value = strTrim(headerEntry[_DYN_SUBSTRING](idx + 1));
headers[header] = value;
} else {
headers[strTrim(headerEntry)] = 1;
}
}
});
}
return headers;
}
function _appendHeader(theHeaders, xhr, name) {
if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
var value = xhr.getResponseHeader(name);
if (value) {
theHeaders[name] = strTrim(value);
}
}
return theHeaders;
}
var STR_KILL_DURATION_HEADER = "kill-duration";
var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
var STR_TIME_DELTA_HEADER = "time-delta-millis";
function _getAllResponseHeaders(xhr, isOneDs) {
var theHeaders = {};
if (!xhr[_DYN_GET_ALL_RESPONSE_HEA5]) {
if (!!isOneDs) {
theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
}
} else {
theHeaders = convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA5]());
}
return theHeaders;
}
var strDocumentMode = "documentMode";
var strLocation = "location";
var strConsole = "console";
var strJSON = "JSON";
var strCrypto = "crypto";
var strMsCrypto = "msCrypto";
var strReactNative = "ReactNative";
var strMsie = "msie";
var strTrident = "trident/";
var strXMLHttpRequest = "XMLHttpRequest";
var _isTrident = null;
var _navUserAgentCheck = null;
var _enableMocks = false;
var _useXDomainRequest = null;
var _beaconsSupported = null;
function _hasProperty(theClass, property) {
var supported = false;
if (theClass) {
try {
supported = property in theClass;
if (!supported) {
var proto = theClass[strShimPrototype];
if (proto) {
supported = property in proto;
}
}
} catch (e) {
}
if (!supported) {
try {
var tmp = new theClass();
supported = !/* @__PURE__ */ isUndefined(tmp[property]);
} catch (e) {
}
}
}
return supported;
}
function setEnableEnvMocks(enabled) {
_enableMocks = enabled;
}
function getLocation(checkForMock) {
if (checkForMock && _enableMocks) {
var mockLocation = /* @__PURE__ */ getInst("__mockLocation");
if (mockLocation) {
return mockLocation;
}
}
if (typeof location === strShimObject && location) {
return location;
}
return /* @__PURE__ */ getInst(strLocation);
}
function getConsole() {
if (typeof console !== strShimUndefined) {
return console;
}
return /* @__PURE__ */ getInst(strConsole);
}
function hasJSON() {
return Boolean(typeof JSON === strShimObject && JSON || /* @__PURE__ */ getInst(strJSON) !== null);
}
function getJSON() {
if (hasJSON()) {
return JSON || /* @__PURE__ */ getInst(strJSON);
}
return null;
}
function getCrypto() {
return /* @__PURE__ */ getInst(strCrypto);
}
function getMsCrypto() {
return /* @__PURE__ */ getInst(strMsCrypto);
}
function isReactNative() {
var nav = getNavigator();
if (nav && nav.product) {
return nav.product === strReactNative;
}
return false;
}
function isIE() {
var nav = getNavigator();
if (nav && (nav[_DYN_USER_AGENT] !== _navUserAgentCheck || _isTrident === null)) {
_navUserAgentCheck = nav[_DYN_USER_AGENT];
var userAgent = (_navUserAgentCheck || STR_EMPTY$2)[_DYN_TO_LOWER_CASE]();
_isTrident = strContains(userAgent, strMsie) || strContains(userAgent, strTrident);
}
return _isTrident;
}
function getIEVersion(userAgentStr) {
if (userAgentStr === void 0) {
userAgentStr = null;
}
if (!userAgentStr) {
var navigator_1 = getNavigator() || {};
userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY$2)[_DYN_TO_LOWER_CASE]() : STR_EMPTY$2;
}
var ua = (userAgentStr || STR_EMPTY$2)[_DYN_TO_LOWER_CASE]();
if (strContains(ua, strMsie)) {
var doc = getDocument() || {};
return mathMax(parseInt(ua[_DYN_SPLIT](strMsie)[1]), doc[strDocumentMode] || 0);
} else if (strContains(ua, strTrident)) {
var tridentVer = parseInt(ua[_DYN_SPLIT](strTrident)[1]);
if (tridentVer) {
return tridentVer + 4;
}
}
return null;
}
function isBeaconsSupported(useCached) {
if (_beaconsSupported === null || useCached === false) {
_beaconsSupported = /* @__PURE__ */ hasNavigator() && Boolean(getNavigator().sendBeacon);
}
return _beaconsSupported;
}
function isFetchSupported(withKeepAlive) {
var isSupported = false;
try {
isSupported = !!/* @__PURE__ */ getInst("fetch");
var request = /* @__PURE__ */ getInst("Request");
if (isSupported && withKeepAlive && request) {
isSupported = _hasProperty(request, "keepalive");
}
} catch (e) {
}
return isSupported;
}
function useXDomainRequest() {
if (_useXDomainRequest === null) {
_useXDomainRequest = typeof XDomainRequest !== strShimUndefined;
if (_useXDomainRequest && isXhrSupported()) {
_useXDomainRequest = _useXDomainRequest && !_hasProperty(/* @__PURE__ */ getInst(strXMLHttpRequest), "withCredentials");
}
}
return _useXDomainRequest;
}
function isXhrSupported() {
var isSupported = false;
try {
var xmlHttpRequest = /* @__PURE__ */ getInst(strXMLHttpRequest);
isSupported = !!xmlHttpRequest;
} catch (e) {
}
return isSupported;
}
function _getNamedValue(values, name) {
if (values) {
for (var i = 0; i < values[_DYN_LENGTH$1]; i++) {
var value = values[i];
if (value[_DYN_NAME]) {
if (value[_DYN_NAME] === name) {
return value;
}
}
}
}
return {};
}
function findMetaTag(name) {
var doc = getDocument();
if (doc && name) {
return _getNamedValue(doc.querySelectorAll("meta"), name).content;
}
return null;
}
function findNamedServerTiming(name) {
var value;
var perf = /* @__PURE__ */ getPerformance();
if (perf) {
var navPerf = perf.getEntriesByType("navigation") || [];
value = _getNamedValue((navPerf[_DYN_LENGTH$1] > 0 ? navPerf[0] : {}).serverTiming, name).description;
}
return value;
}
function redactUserInfo(url) {
return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
}
function redactQueryParameters(url, config) {
var sensitiveParams;
var questionMarkIndex = strIndexOf(url, "?");
if (questionMarkIndex === -1) {
return url;
}
if (config && config.redactQueryParams) {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
} else {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
}
var baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
var queryString = strSubstring(url, questionMarkIndex + 1);
var fragment = STR_EMPTY$2;
var hashIndex = strIndexOf(queryString, "#");
if (hashIndex !== -1) {
fragment = strSubstring(queryString, hashIndex);
queryString = strSubstring(queryString, 0, hashIndex);
}
var hasPotentialSensitiveParam = false;
for (var i = 0; i < sensitiveParams[_DYN_LENGTH$1]; i++) {
var paramCheck = sensitiveParams[i] + "=";
if (strIndexOf(queryString, paramCheck) !== -1) {
hasPotentialSensitiveParam = true;
break;
}
}
if (!hasPotentialSensitiveParam) {
return url;
}
var resultParts = [];
var anyParamRedacted = false;
if (queryString && queryString[_DYN_LENGTH$1]) {
var pairs = queryString[_DYN_SPLIT]("&");
for (var i = 0; i < pairs[_DYN_LENGTH$1]; i++) {
var pair = pairs[i];
if (!pair) {
continue;
}
var equalsIndex = strIndexOf(pair, "=");
if (equalsIndex === -1) {
resultParts[_DYN_PUSH](pair);
} else {
var paramName = pair[_DYN_SUBSTRING](0, equalsIndex);
var paramValue = pair[_DYN_SUBSTRING](equalsIndex + 1);
if (paramValue === STR_EMPTY$2) {
resultParts[_DYN_PUSH](pair);
} else {
var shouldRedact = false;
for (var j = 0; j < sensitiveParams[_DYN_LENGTH$1]; j++) {
if (paramName === sensitiveParams[j]) {
shouldRedact = true;
anyParamRedacted = true;
break;
}
}
if (shouldRedact) {
resultParts[_DYN_PUSH](paramName + "=" + STR_REDACTED);
} else {
resultParts[_DYN_PUSH](pair);
}
}
}
}
}
if (!anyParamRedacted) {
return url;
}
return baseUrl + resultParts.join("&") + fragment;
}
function fieldRedaction(input, config) {
if (!input || input[_DYN_INDEX_OF$1](" ") !== -1) {
return input;
}
var isRedactionDisabled = config && config.redactUrls === false;
if (isRedactionDisabled) {
return input;
}
var hasCredentials = strIndexOf(input, "@") !== -1;
var hasQueryParams = strIndexOf(input, "?") !== -1;
if (!hasCredentials && !hasQueryParams) {
return input;
}
try {
var result = input;
if (hasCredentials) {
result = redactUserInfo(input);
}
if (hasQueryParams) {
result = redactQueryParameters(result, config);
}
return result;
} catch (e) {
return input;
}
}
var UInt32Mask = 4294967296;
var MaxUInt32 = 4294967295;
var SEED1 = 123456789;
var SEED2 = 987654321;
var _mwcSeeded = false;
var _mwcW = SEED1;
var _mwcZ = SEED2;
function _mwcSeed(seedValue) {
if (seedValue < 0) {
seedValue >>>= 0;
}
_mwcW = SEED1 + seedValue & MaxUInt32;
_mwcZ = SEED2 - seedValue & MaxUInt32;
_mwcSeeded = true;
}
function _autoSeedMwc() {
try {
var now = /* @__PURE__ */ utcNow() & 2147483647;
_mwcSeed((Math.random() * UInt32Mask ^ now) + now);
} catch (e) {
}
}
function randomValue(maxValue) {
if (maxValue > 0) {
return mathFloor(random32() / MaxUInt32 * (maxValue + 1)) >>> 0;
}
return 0;
}
function random32(signed) {
var value = 0;
var c = getCrypto() || getMsCrypto();
if (c && c.getRandomValues) {
value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
}
if (value === 0 && isIE()) {
if (!_mwcSeeded) {
_autoSeedMwc();
}
value = mwcRandom32() & MaxUInt32;
}
if (value === 0) {
value = mathFloor(UInt32Mask * Math.random() | 0);
}
if (!signed) {
value >>>= 0;
}
return value;
}
function mwcRandom32(signed) {
_mwcZ = 36969 * (_mwcZ & 65535) + (_mwcZ >> 16) & MaxUInt32;
_mwcW = 18e3 * (_mwcW & 65535) + (_mwcW >> 16) & MaxUInt32;
var value = (_mwcZ << 16) + (_mwcW & 65535) >>> 0 & MaxUInt32 | 0;
if (!signed) {
value >>>= 0;
}
return value;
}
function newId(maxLength) {
if (maxLength === void 0) {
maxLength = 22;
}
var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var number = random32() >>> 0;
var chars = 0;
var result = STR_EMPTY$2;
while (result[_DYN_LENGTH$1] < maxLength) {
chars++;
result += base64chars.charAt(number & 63);
number >>>= 6;
if (chars === 5) {
number = (random32() << 2 & 4294967295 | number & 3) >>> 0;
chars = 0;
}
}
return result;
}
var version = "3.3.10";
var instanceName = "." + newId(6);
var _dataUid = 0;
function _canAcceptData(target) {
return target.nodeType === 1 || target.nodeType === 9 || !+target.nodeType;
}
function _getCache(data, target) {
var theCache = target[data.id];
if (!theCache) {
theCache = {};
try {
if (_canAcceptData(target)) {
objDefine(target, data.id, {
e: false,
v: theCache
});
}
} catch (e) {
}
}
return theCache;
}
function createUniqueNamespace(name, includeVersion) {
if (includeVersion === void 0) {
includeVersion = false;
}
return normalizeJsName(name + _dataUid++ + (includeVersion ? "." + version : STR_EMPTY$2) + instanceName);
}
function createElmNodeData(name) {
var data = {
id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$2) + "." + version),
accept: function(target) {
return _canAcceptData(target);
},
get: function(target, name2, defValue, addDefault) {
var theCache = target[data.id];
if (!theCache) {
if (addDefault) {
theCache = _getCache(data, target);
theCache[normalizeJsName(name2)] = defValue;
}
return defValue;
}
return theCache[normalizeJsName(name2)];
},
kill: function(target, name2) {
if (target && target[name2]) {
try {
delete target[name2];
} catch (e) {
}
}
}
};
return data;
}
function _isConfigDefaults(value) {
return value && /* @__PURE__ */ isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set);
}
function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
var defValue;
var isDefaultValid = cfgDefaults.dfVal || isDefined;
if (theConfig && cfgDefaults.fb) {
var fallbacks = cfgDefaults.fb;
if (!isArray(fallbacks)) {
fallbacks = [fallbacks];
}
for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1]; lp++) {
var fallback = fallbacks[lp];
var fbValue = theConfig[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
} else if (dynamicHandler) {
fbValue = dynamicHandler.cfg[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
}
dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
}
if (isDefaultValid(defValue)) {
break;
}
}
}
if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
defValue = cfgDefaults.v;
}
return defValue;
}
function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
var theValue = cfgDefaults;
if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
}
if (theValue) {
if (_isConfigDefaults(theValue)) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
}
var newValue_1;
if (isArray(theValue)) {
newValue_1 = [];
newValue_1[_DYN_LENGTH$1] = theValue[_DYN_LENGTH$1];
} else if (/* @__PURE__ */ isPlainObject(theValue)) {
newValue_1 = {};
}
if (newValue_1) {
objForEachKey(theValue, function(key, value) {
if (value && _isConfigDefaults(value)) {
value = _resolveDefaultValue(dynamicHandler, theConfig, value);
}
newValue_1[key] = value;
});
theValue = newValue_1;
}
}
return theValue;
}
function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
var isValid;
var setFn;
var defValue;
var cfgDefaults = defaultValue;
var mergeDf;
var reference;
var readOnly;
var blkDynamicValue;
if (_isConfigDefaults(cfgDefaults)) {
isValid = cfgDefaults.isVal;
setFn = cfgDefaults.set;
readOnly = cfgDefaults.rdOnly;
blkDynamicValue = cfgDefaults.blkVal;
mergeDf = cfgDefaults.mrg;
reference = cfgDefaults.ref;
if (!reference && /* @__PURE__ */ isUndefined(reference)) {
reference = !!mergeDf;
}
defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
} else {
defValue = defaultValue;
}
if (blkDynamicValue) {
dynamicHandler.blkVal(theConfig, name);
}
var theValue;
var usingDefault = true;
var cfgValue = theConfig[name];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
theValue = cfgValue;
usingDefault = false;
if (isValid && theValue !== defValue && !isValid(theValue)) {
theValue = defValue;
usingDefault = true;
}
if (setFn) {
theValue = setFn(theValue, defValue, theConfig);
usingDefault = theValue === defValue;
}
}
if (!usingDefault) {
if (/* @__PURE__ */ isPlainObject(theValue) || isArray(defValue)) {
if (mergeDf && defValue && (/* @__PURE__ */ isPlainObject(defValue) || isArray(defValue))) {
objForEachKey(defValue, function(dfName, dfValue) {
_applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
});
}
}
} else if (defValue) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
} else {
theValue = defValue;
}
dynamicHandler.set(theConfig, name, theValue);
if (reference) {
dynamicHandler.ref(theConfig, name);
}
if (readOnly) {
dynamicHandler.rdOnly(theConfig, name);
}
}
var CFG_HANDLER_LINK = /* @__PURE__ */ symbolFor("[[ai_dynCfg_1]]");
var BLOCK_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_blkDynCfg_1]]");
var FORCE_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_frcDynCfg_1]]");
function _cfgDeepCopy(source) {
if (source) {
var target_1;
if (isArray(source)) {
target_1 = [];
target_1[_DYN_LENGTH$1] = source[_DYN_LENGTH$1];
} else if (/* @__PURE__ */ isPlainObject(source)) {
target_1 = {};
}
if (target_1) {
objForEachKey(source, function(key, value) {
target_1[key] = _cfgDeepCopy(value);
});
return target_1;
}
}
return source;
}
function getDynamicConfigHandler(value) {
if (value) {
var handler = value[CFG_HANDLER_LINK] || value;
if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler;
}
}
return null;
}
function blockDynamicConversion(value) {
if (value && (/* @__PURE__ */ isPlainObject(value) || isArray(value))) {
try {
value[BLOCK_DYNAMIC] = true;
} catch (e) {
}
}
return value;
}
function forceDynamicConversion(value) {
if (value) {
try {
value[FORCE_DYNAMIC] = true;
} catch (e) {
}
}
return value;
}
function _canMakeDynamic(getFunc, state, value) {
var result = false;
if (value && !getFunc[state.blkVal]) {
result = value[FORCE_DYNAMIC];
if (!result && !value[BLOCK_DYNAMIC]) {
result = /* @__PURE__ */ isPlainObject(value) || isArray(value);
}
}
return result;
}
function throwInvalidAccess(message) {
throwTypeError("InvalidAccess:" + message);
}
var arrayMethodsToPatch = [
"push",
"pop",
"shift",
"unshift",
"splice"
];
var _throwDynamicError = function(logger2, name, desc, e) {
logger2 && logger2[_DYN_THROW_INTERNAL](3, 108, "".concat(desc, " [").concat(name, "] failed - ") + /* @__PURE__ */ dumpObj(e));
};
function _patchArray(state, target, name) {
if (isArray(target)) {
arrForEach(arrayMethodsToPatch, function(method) {
var orgMethod = target[method];
target[method] = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var result = orgMethod[_DYN_APPLY](this, args);
_makeDynamicObject(state, target, name, "Patching");
return result;
};
});
}
}
function _getOwnPropGetter(target, name) {
var propDesc = objGetOwnPropertyDescriptor(target, name);
return propDesc && propDesc.get;
}
function _createDynamicProperty(state, theConfig, name, value) {
var detail = {
n: name,
h: [],
trk: function(handler) {
if (handler && handler.fn) {
if (arrIndexOf(detail.h, handler) === -1) {
detail.h[_DYN_PUSH](handler);
}
state.trk(handler, detail);
}
},
clr: function(handler) {
var idx = arrIndexOf(detail.h, handler);
if (idx !== -1) {
detail.h[_DYN_SPLICE](idx, 1);
}
}
};
var checkDynamic = true;
var isObjectOrArray = false;
function _getProperty() {
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
value = _makeDynamicObject(state, value, name, "Converting");
}
checkDynamic = false;
}
var activeHandler = state.act;
if (activeHandler) {
detail.trk(activeHandler);
}
return value;
}
_getProperty[state.prop] = {
chng: function() {
state.add(detail);
}
};
function _setProperty(newValue) {
if (value !== newValue) {
if (!!_getProperty[state.ro] && !state.upd) {
throwInvalidAccess("[" + name + "] is read-only:" + /* @__PURE__ */ dumpObj(theConfig));
}
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
checkDynamic = false;
}
var isReferenced = isObjectOrArray && _getProperty[state.rf];
if (isObjectOrArray) {
if (isReferenced) {
objForEachKey(value, function(key) {
value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
});
try {
objForEachKey(newValue, function(key, theValue) {
_setDynamicProperty(state, value, key, theValue);
});
newValue = value;
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Assigning", e);
isObjectOrArray = false;
}
} else if (value && value[CFG_HANDLER_LINK]) {
objForEachKey(value, function(key) {
var getter = _getOwnPropGetter(value, key);
if (getter) {
var valueState = getter[state.prop];
valueState && valueState.chng();
}
});
}
}
if (newValue !== value) {
var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
if (!isReferenced && newIsObjectOrArray) {
newValue = _makeDynamicObject(state, newValue, name, "Converting");
}
value = newValue;
isObjectOrArray = newIsObjectOrArray;
}
state.add(detail);
}
}
objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
}
function _setDynamicProperty(state, target, name, value) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
if (!isDynamic) {
_createDynamicProperty(state, target, name, value);
} else {
target[name] = value;
}
}
return target;
}
function _setDynamicPropertyState(state, target, name, flags) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
var inPlace = flags && flags[0];
var rdOnly = flags && flags[1];
var blkProp = flags && flags[2];
if (!isDynamic) {
if (blkProp) {
try {
blockDynamicConversion(target);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Blocking", e);
}
}
try {
_setDynamicProperty(state, target, name, target[name]);
getter = _getOwnPropGetter(target, name);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "State", e);
}
}
if (inPlace) {
getter[state.rf] = inPlace;
}
if (rdOnly) {
getter[state.ro] = rdOnly;
}
if (blkProp) {
getter[state.blkVal] = true;
}
}
return target;
}
function _makeDynamicObject(state, target, name, desc) {
try {
objForEachKey(target, function(key, value) {
_setDynamicProperty(state, target, key, value);
});
if (!target[CFG_HANDLER_LINK]) {
objDefineProp(target, CFG_HANDLER_LINK, {
get: function() {
return state.hdlr;
}
});
_patchArray(state, target, name);
}
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, desc, e);
}
return target;
}
var symPrefix = "[[ai_";
var symPostfix = "]]";
function _createState(cfgHandler) {
var dynamicPropertySymbol = /* @__PURE__ */ newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
var dynamicPropertyReadOnly = /* @__PURE__ */ newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
var dynamicPropertyReferenced = /* @__PURE__ */ newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
var dynamicPropertyBlockValue = /* @__PURE__ */ newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
var dynamicPropertyDetail = /* @__PURE__ */ newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
var _waitingHandlers = null;
var _watcherTimer = null;
var theState;
function _useHandler(activeHandler, callback) {
var prevWatcher = theState.act;
try {
theState.act = activeHandler;
if (activeHandler && activeHandler[dynamicPropertyDetail]) {
arrForEach(activeHandler[dynamicPropertyDetail], function(detail) {
detail.clr(activeHandler);
});
activeHandler[dynamicPropertyDetail] = [];
}
callback({
cfg: cfgHandler.cfg,
set: cfgHandler.set.bind(cfgHandler),
setDf: cfgHandler.setDf.bind(cfgHandler),
ref: cfgHandler.ref.bind(cfgHandler),
rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
});
} catch (e) {
var logger2 = cfgHandler[_DYN_LOGGER];
if (logger2) {
logger2[_DYN_THROW_INTERNAL](1, 107, /* @__PURE__ */ dumpObj(e));
}
throw e;
} finally {
theState.act = prevWatcher || null;
}
}
function _notifyWatchers() {
if (_waitingHandlers) {
var notifyHandlers = _waitingHandlers;
_waitingHandlers = null;
_watcherTimer && _watcherTimer[_DYN_CANCEL]();
_watcherTimer = null;
var watcherFailures_1 = [];
arrForEach(notifyHandlers, function(handler) {
if (handler) {
if (handler[dynamicPropertyDetail]) {
arrForEach(handler[dynamicPropertyDetail], function(detail) {
detail.clr(handler);
});
handler[dynamicPropertyDetail] = null;
}
if (handler.fn) {
try {
_useHandler(handler, handler.fn);
} catch (e) {
watcherFailures_1[_DYN_PUSH](e);
}
}
}
});
if (_waitingHandlers) {
try {
_notifyWatchers();
} catch (e) {
watcherFailures_1[_DYN_PUSH](e);
}
}
if (watcherFailures_1[_DYN_LENGTH$1] > 0) {
throwAggregationError("Watcher error(s): ", watcherFailures_1);
}
}
}
function _addWatcher(detail) {
if (detail && detail.h[_DYN_LENGTH$1] > 0) {
if (!_waitingHandlers) {
_waitingHandlers = [];
}
if (!_watcherTimer) {
_watcherTimer = scheduleTimeout(function() {
_watcherTimer = null;
_notifyWatchers();
}, 0);
}
for (var idx = 0; idx < detail.h[_DYN_LENGTH$1]; idx++) {
var handler = detail.h[idx];
if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
_waitingHandlers[_DYN_PUSH](handler);
}
}
}
}
function _trackHandler(handler, detail) {
if (handler) {
var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
if (arrIndexOf(details, detail) === -1) {
details[_DYN_PUSH](detail);
}
}
}
theState = {
prop: dynamicPropertySymbol,
ro: dynamicPropertyReadOnly,
rf: dynamicPropertyReferenced,
blkVal: dynamicPropertyBlockValue,
hdlr: cfgHandler,
add: _addWatcher,
notify: _notifyWatchers,
use: _useHandler,
trk: _trackHandler
};
return theState;
}
function _createAndUseHandler(state, configHandler) {
var handler = {
fn: configHandler,
rm: function() {
handler.fn = null;
state = null;
configHandler = null;
}
};
objDefine(handler, "toJSON", { v: function() {
return "WatcherHandler" + (handler.fn ? "" : "[X]");
} });
state.use(handler, configHandler);
return handler;
}
function _createDynamicHandler(logger2, target, inPlace) {
var dynamicHandler = getDynamicConfigHandler(target);
if (dynamicHandler) {
return dynamicHandler;
}
var uid = createUniqueNamespace("dyncfg", true);
var newTarget = target && inPlace !== false ? target : _cfgDeepCopy(target);
var theState;
function _notifyWatchers() {
theState.notify();
}
function _setValue(target2, name, value) {
try {
target2 = _setDynamicProperty(theState, target2, name, value);
} catch (e) {
_throwDynamicError(logger2, name, "Setting value", e);
}
return target2[name];
}
function _watch(configHandler) {
return _createAndUseHandler(theState, configHandler);
}
function _block(configHandler, allowUpdate) {
theState.use(null, function(details) {
var prevUpd = theState.upd;
try {
if (!/* @__PURE__ */ isUndefined(allowUpdate)) {
theState.upd = allowUpdate;
}
configHandler(details);
} finally {
theState.upd = prevUpd;
}
});
}
function _ref(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[0] = true, _a2))[name];
}
function _rdOnly(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[1] = true, _a2))[name];
}
function _blkPropValue(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[2] = true, _a2))[name];
}
function _applyDefaults(theConfig, defaultValues2) {
if (defaultValues2) {
objForEachKey(defaultValues2, function(name, value) {
_applyDefaultValue(cfgHandler, theConfig, name, value);
});
}
return theConfig;
}
var cfgHandler = {
uid: null,
cfg: newTarget,
logger: logger2,
notify: _notifyWatchers,
set: _setValue,
setDf: _applyDefaults,
watch: _watch,
ref: _ref,
rdOnly: _rdOnly,
blkVal: _blkPropValue,
_block
};
objDefine(cfgHandler, "uid", {
c: false,
e: false,
w: false,
v: uid
});
theState = _createState(cfgHandler);
_makeDynamicObject(theState, newTarget, "config", "Creating");
return cfgHandler;
}
function _logInvalidAccess(logger2, message) {
if (logger2) {
logger2[_DYN_WARN_TO_CONSOLE](message);
logger2[_DYN_THROW_INTERNAL](2, 108, message);
} else {
throwInvalidAccess(message);
}
}
function createDynamicConfig(config, defaultConfig2, logger2, inPlace) {
var dynamicHandler = _createDynamicHandler(logger2, config || {}, inPlace);
if (defaultConfig2) {
dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig2);
}
return dynamicHandler;
}
function onConfigChange(config, configHandler, logger2) {
var handler = config[CFG_HANDLER_LINK] || config;
if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler[_DYN_WATCH](configHandler);
}
_logInvalidAccess(logger2, STR_NOT_DYNAMIC_ERROR + /* @__PURE__ */ dumpObj(config));
return createDynamicConfig(config, null, logger2)[_DYN_WATCH](configHandler);
}
function runTargetUnload(target, isAsync) {
if (target && target[_DYN_UNLOAD]) {
return target[_DYN_UNLOAD](isAsync);
}
}
function doUnloadAll(targets, isAsync, done) {
var result;
if (!done) {
result = createPromise(function(resolved) {
done = resolved;
});
}
if (targets && getLength(targets) > 0) {
doAwaitResponse(runTargetUnload(targets[0], isAsync), function() {
doUnloadAll(arrSlice(targets, 1), isAsync, done);
});
} else {
done();
}
return result;
}
var ChannelControllerPriority = 500;
var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
function cfgDfMerge(defaultValue) {
return {
mrg: true,
v: defaultValue
};
}
var listenerFuncs = [STR_EVENTS_SENT, STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_PERF_EVENT];
var _aiNamespace = null;
var _debugListener;
function _listenerProxyFunc(name, config) {
return function() {
var args = arguments;
var dbgExt = getDebugExt(config);
if (dbgExt) {
var listener = dbgExt.listener;
if (listener && listener[name]) {
listener[name][_DYN_APPLY](listener, args);
}
}
};
}
function _getExtensionNamespace() {
var target = /* @__PURE__ */ getInst("Microsoft");
if (target) {
_aiNamespace = target["ApplicationInsights"];
}
return _aiNamespace;
}
function getDebugExt(config) {
var ns = _aiNamespace;
if (!ns && config.disableDbgExt !== true) {
ns = _aiNamespace || _getExtensionNamespace();
}
return ns ? ns["ChromeDbgExt"] : null;
}
function getDebugListener(config) {
if (!_debugListener) {
_debugListener = {};
for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH$1]; lp++) {
_debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
}
}
return _debugListener;
}
var _a$4;
var STR_WARN_TO_CONSOLE = "warnToConsole";
var AiNonUserActionablePrefix = "AI (Internal): ";
var AiUserActionablePrefix = "AI: ";
var AIInternalMessagePrefix = "AITR_";
var defaultValues$2 = {
loggingLevelConsole: 0,
loggingLevelTelemetry: 1,
maxMessageLimit: 25,
enableDebug: false
};
var _logFuncs = (_a$4 = {}, _a$4[0] = null, _a$4[1] = "errorToConsole", _a$4[2] = STR_WARN_TO_CONSOLE, _a$4[3] = "debugToConsole", _a$4);
function _sanitizeDiagnosticText(text) {
if (text) {
return '"' + text[_DYN_REPLACE](/\"/g, STR_EMPTY$2) + '"';
}
return STR_EMPTY$2;
}
function _logToConsole(func, message) {
var theConsole = getConsole();
if (!!theConsole) {
var logFunc = "log";
if (theConsole[func]) {
logFunc = func;
}
if (isFunction(theConsole[logFunc])) {
theConsole[logFunc](message);
}
}
}
var _InternalLogMessage = (
/** @class */
(function() {
function _InternalLogMessage2(msgId, msg, isUserAct, properties) {
if (isUserAct === void 0) {
isUserAct = false;
}
var _self = this;
_self[_DYN_MESSAGE_ID] = msgId;
_self[_DYN_MESSAGE] = (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) + msgId;
var strProps = STR_EMPTY$2;
if (hasJSON()) {
strProps = getJSON().stringify(properties);
}
var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$2) + (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$2);
_self[_DYN_MESSAGE] += diagnosticText;
}
_InternalLogMessage2.dataType = "MessageData";
return _InternalLogMessage2;
})()
);
function safeGetLogger(core, config) {
return (core || {})[_DYN_LOGGER] || new DiagnosticLogger(config);
}
var DiagnosticLogger = (
/** @class */
(function() {
function DiagnosticLogger2(config) {
this.identifier = "DiagnosticLogger";
this.queue = [];
var _messageCount = 0;
var _messageLogged = {};
var _loggingLevelConsole;
var _loggingLevelTelemetry;
var _maxInternalMessageLimit;
var _enableDebug;
var _unloadHandler;
dynamicProto(DiagnosticLogger2, this, function(_self) {
_unloadHandler = _setDefaultsFromConfig(config || {});
_self.consoleLoggingLevel = function() {
return _loggingLevelConsole;
};
_self[_DYN_THROW_INTERNAL] = function(severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
if (_enableDebug) {
throw /* @__PURE__ */ dumpObj(message);
} else {
var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
if (!/* @__PURE__ */ isUndefined(message[_DYN_MESSAGE])) {
if (isUserAct) {
var messageKey = +message[_DYN_MESSAGE_ID];
if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE]);
_messageLogged[messageKey] = true;
}
} else {
if (_loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE]);
}
}
_logInternalMessage2(severity, message);
} else {
_debugExtMsg("throw" + (severity === 1 ? "Critical" : "Warning"), message);
}
}
};
_self.debugToConsole = function(message) {
_logToConsole("debug", message);
_debugExtMsg("warning", message);
};
_self[_DYN_WARN_TO_CONSOLE] = function(message) {
_logToConsole("warn", message);
_debugExtMsg("warning", message);
};
_self.errorToConsole = function(message) {
_logToConsole("error", message);
_debugExtMsg("error", message);
};
_self.resetInternalMessageCount = function() {
_messageCount = 0;
_messageLogged = {};
};
_self.logInternalMessage = _logInternalMessage2;
_self[_DYN_UNLOAD] = function(isAsync) {
_unloadHandler && _unloadHandler.rm();
_unloadHandler = null;
};
function _logInternalMessage2(severity, message) {
if (_areInternalMessagesThrottled()) {
return;
}
var logMessage = true;
var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID];
if (_messageLogged[messageKey]) {
logMessage = false;
} else {
_messageLogged[messageKey] = true;
}
if (logMessage) {
if (severity <= _loggingLevelTelemetry) {
_self.queue[_DYN_PUSH](message);
_messageCount++;
_debugExtMsg(severity === 1 ? "error" : "warn", message);
}
if (_messageCount === _maxInternalMessageLimit) {
var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
var throttleMessage = new _InternalLogMessage(23, throttleLimitMessage, false);
_self.queue[_DYN_PUSH](throttleMessage);
if (severity === 1) {
_self.errorToConsole(throttleLimitMessage);
} else {
_self[_DYN_WARN_TO_CONSOLE](throttleLimitMessage);
}
}
}
}
function _setDefaultsFromConfig(config2) {
return onConfigChange(createDynamicConfig(config2, defaultValues$2, _self).cfg, function(details) {
var config3 = details.cfg;
_loggingLevelConsole = config3[_DYN_LOGGING_LEVEL_CONSOL4];
_loggingLevelTelemetry = config3.loggingLevelTelemetry;
_maxInternalMessageLimit = config3.maxMessageLimit;
_enableDebug = config3.enableDebug;
});
}
function _areInternalMessagesThrottled() {
return _messageCount >= _maxInternalMessageLimit;
}
function _debugExtMsg(name, data) {
var dbgExt = getDebugExt(config || {});
if (dbgExt && dbgExt[_DYN_DIAG_LOG]) {
dbgExt[_DYN_DIAG_LOG](name, data);
}
}
});
}
DiagnosticLogger2.__ieDyn = 1;
return DiagnosticLogger2;
})()
);
function _getLogger(logger2) {
return logger2 || new DiagnosticLogger();
}
function _throwInternal(logger2, severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
_getLogger(logger2)[_DYN_THROW_INTERNAL](severity, msgId, msg, properties, isUserAct);
}
function _warnToConsole(logger2, message) {
_getLogger(logger2)[_DYN_WARN_TO_CONSOLE](message);
}
function _logInternalMessage(logger2, severity, message) {
_getLogger(logger2).logInternalMessage(severity, message);
}
var _a$3, _b;
var strToGMTString = "toGMTString";
var strToUTCString = "toUTCString";
var strCookie = "cookie";
var strExpires = "expires";
var strIsCookieUseDisabled = "isCookieUseDisabled";
var strDisableCookiesUsage = "disableCookiesUsage";
var strConfigCookieMgr = "_ckMgr";
var _supportsCookies = null;
var _allowUaSameSite = null;
var _parsedCookieValue = null;
var _doc;
var _cookieCache = {};
var _globalCookieConfig = {};
var rootDefaultConfig = (_a$3 = {
cookieCfg: cfgDfMerge((_b = {}, _b[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined }, _b.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined }, _b.enabled = UNDEFINED_VALUE, _b.ignoreCookies = UNDEFINED_VALUE, _b.blockedCookies = UNDEFINED_VALUE, _b.disableCookieDefer = false, _b)),
cookieDomain: UNDEFINED_VALUE,
cookiePath: UNDEFINED_VALUE
}, _a$3[strDisableCookiesUsage] = UNDEFINED_VALUE, _a$3);
function _getDoc() {
!_doc && (_doc = /* @__PURE__ */ getLazy(function() {
return getDocument();
}));
}
function _gblCookieMgr(config, logger2) {
var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
if (!inst) {
inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger2);
_globalCookieConfig[strConfigCookieMgr] = inst;
}
return inst;
}
function _isMgrEnabled(cookieMgr) {
if (cookieMgr) {
return cookieMgr.isEnabled();
}
return true;
}
function _isIgnoredCookie(cookieMgrCfg, name) {
if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
}
return false;
}
function _isBlockedCookie(cookieMgrCfg, name) {
if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
return true;
}
}
return _isIgnoredCookie(cookieMgrCfg, name);
}
function _isCfgEnabled(rootConfig, cookieMgrConfig) {
var isCfgEnabled = cookieMgrConfig[_DYN_ENABLED];
if (/* @__PURE__ */ isNullOrUndefined(isCfgEnabled)) {
var cookieEnabled = void 0;
if (!/* @__PURE__ */ isUndefined(rootConfig[strIsCookieUseDisabled])) {
cookieEnabled = !rootConfig[strIsCookieUseDisabled];
}
if (!/* @__PURE__ */ isUndefined(rootConfig[strDisableCookiesUsage])) {
cookieEnabled = !rootConfig[strDisableCookiesUsage];
}
isCfgEnabled = cookieEnabled;
}
return isCfgEnabled;
}
function safeGetCookieMgr(core, config) {
var cookieMgr;
if (core) {
cookieMgr = core.getCookieMgr();
} else if (config) {
var cookieCfg = config.cookieCfg;
if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
cookieMgr = cookieCfg[strConfigCookieMgr];
} else {
cookieMgr = createCookieMgr(config);
}
}
if (!cookieMgr) {
cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER]);
}
return cookieMgr;
}
function createCookieMgr(rootConfig, logger2) {
var cookieMgrConfig;
var _path;
var _domain;
var unloadHandler;
var _enabled;
var _getCookieFn;
var _setCookieFn;
var _delCookieFn;
var _pendingCookies = [];
function _formatDeletionValue(path11) {
var _a2;
var values = (_a2 = {}, _a2[STR_PATH] = path11 ? path11 : "/", _a2[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT", _a2);
if (!isIE()) {
values["max-age"] = "0";
}
return _formatCookieValue(STR_EMPTY$2, values);
}
function _formatSetCookieValue(value, maxAgeSec, domain, path11) {
var values = {};
var theValue = strTrim(value || STR_EMPTY$2);
var idx = strIndexOf(theValue, ";");
if (idx !== -1) {
theValue = strTrim(/* @__PURE__ */ strLeft(value, idx));
values = _extractParts(strSubstring(value, idx + 1));
}
setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
if (!/* @__PURE__ */ isNullOrUndefined(maxAgeSec)) {
var _isIE = isIE();
if (/* @__PURE__ */ isUndefined(values[strExpires])) {
var nowMs = /* @__PURE__ */ utcNow();
var expireMs = nowMs + maxAgeSec * 1e3;
if (expireMs > 0) {
var expiry = /* @__PURE__ */ new Date();
expiry.setTime(expireMs);
setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY$2, isTruthy);
}
}
if (!_isIE) {
setValue(values, "max-age", STR_EMPTY$2 + maxAgeSec, null, isUndefined);
}
}
var location2 = getLocation();
if (location2 && location2.protocol === "https:") {
setValue(values, "secure", null, null, isUndefined);
if (_allowUaSameSite === null) {
_allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT]);
}
if (_allowUaSameSite) {
setValue(values, "SameSite", "None", null, isUndefined);
}
}
setValue(values, STR_PATH, path11 || _path, null, isUndefined);
return _formatCookieValue(theValue, values);
}
function _removePendingCookie(name) {
if (_pendingCookies) {
for (var i = _pendingCookies[_DYN_LENGTH$1] - 1; i >= 0; i--) {
if (_pendingCookies[i].n === name) {
_pendingCookies[_DYN_SPLICE](i, 1);
}
}
}
}
function _flushPendingCookies() {
if (areCookiesSupported(logger2) && _pendingCookies) {
arrForEach(_pendingCookies, function(pendingData) {
if (!_isBlockedCookie(cookieMgrConfig, pendingData.n)) {
if (pendingData.o === 0) {
_setCookieFn(pendingData.n, pendingData.v);
} else if (pendingData.o === 1) {
_delCookieFn(pendingData.n, pendingData.v);
}
}
});
_pendingCookies = [];
}
}
rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger2).cfg;
unloadHandler = onConfigChange(rootConfig, function(details) {
details.setDf(details.cfg, rootDefaultConfig);
cookieMgrConfig = details.ref(details.cfg, "cookieCfg");
_path = cookieMgrConfig[STR_PATH] || "/";
_domain = cookieMgrConfig[STR_DOMAIN];
if (cookieMgrConfig.disableCookieDefer) {
_pendingCookies = null;
} else if (_pendingCookies === null) {
_pendingCookies = [];
}
var wasEnabled = _enabled;
_enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false;
_getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
_setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
_delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
if (!wasEnabled && _enabled && _pendingCookies) {
_flushPendingCookies();
}
}, logger2);
var cookieMgr = {
isEnabled: function() {
var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger2);
var gblManager = _globalCookieConfig[strConfigCookieMgr];
if (enabled && gblManager && cookieMgr !== gblManager) {
enabled = _isMgrEnabled(gblManager);
}
return enabled;
},
setEnabled: function(value) {
cookieMgrConfig[_DYN_ENABLED] = value;
if (!/* @__PURE__ */ isUndefined(rootConfig[strDisableCookiesUsage])) {
rootConfig[strDisableCookiesUsage] = !value;
}
},
set: function(name, value, maxAgeSec, domain, path11) {
var result = false;
var isBlocked = _isBlockedCookie(cookieMgrConfig, name);
if (!isBlocked) {
var cookieValue = _formatSetCookieValue(value, maxAgeSec, domain, path11);
if (_isMgrEnabled(cookieMgr)) {
_setCookieFn(name, cookieValue);
result = true;
} else if (_pendingCookies) {
_removePendingCookie(name);
_pendingCookies[_DYN_PUSH]({
n: name,
o: 0,
v: cookieValue
});
result = true;
}
}
return result;
},
get: function(name) {
var value = STR_EMPTY$2;
var isIgnored = _isIgnoredCookie(cookieMgrConfig, name);
if (!isIgnored) {
if (_isMgrEnabled(cookieMgr)) {
value = _getCookieFn(name);
} else if (_pendingCookies) {
for (var i = _pendingCookies[_DYN_LENGTH$1] - 1; i >= 0; i--) {
var pendingData = _pendingCookies[i];
if (pendingData.n === name) {
if (pendingData.o === 0) {
var cookieValue = pendingData.v;
var idx = strIndexOf(cookieValue, ";");
value = idx !== -1 ? strTrim(/* @__PURE__ */ strLeft(cookieValue, idx)) : strTrim(cookieValue);
}
break;
}
}
}
}
return value;
},
del: function(name, path11) {
var result = false;
if (_isMgrEnabled(cookieMgr)) {
result = cookieMgr.purge(name, path11);
} else if (_pendingCookies) {
_removePendingCookie(name);
_pendingCookies[_DYN_PUSH]({
n: name,
o: 1,
v: _formatDeletionValue(path11)
});
result = true;
}
return result;
},
purge: function(name, path11) {
var result = false;
if (areCookiesSupported(logger2)) {
_delCookieFn(name, _formatDeletionValue(path11));
result = true;
}
return result;
},
unload: function(isAsync) {
unloadHandler && unloadHandler.rm();
unloadHandler = null;
_pendingCookies = null;
}
};
cookieMgr[strConfigCookieMgr] = cookieMgr;
return cookieMgr;
}
function areCookiesSupported(logger2) {
if (_supportsCookies === null) {
_supportsCookies = false;
!_doc && _getDoc();
try {
var doc = _doc.v || {};
_supportsCookies = doc[strCookie] !== void 0;
} catch (e) {
_throwInternal(logger2, 2, 68, "Cannot access document.cookie - " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return _supportsCookies;
}
function _extractParts(theValue) {
var values = {};
if (theValue && theValue[_DYN_LENGTH$1]) {
var parts = strTrim(theValue)[_DYN_SPLIT](";");
arrForEach(parts, function(thePart) {
thePart = strTrim(thePart || STR_EMPTY$2);
if (thePart) {
var idx = strIndexOf(thePart, "=");
if (idx === -1) {
values[thePart] = null;
} else {
values[strTrim(/* @__PURE__ */ strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
}
}
});
}
return values;
}
function _formatDate(theDate, func) {
if (isFunction(theDate[func])) {
return theDate[func]();
}
return null;
}
function _formatCookieValue(value, values) {
var cookieValue = value || STR_EMPTY$2;
objForEachKey(values, function(name, theValue) {
cookieValue += "; " + name + (!/* @__PURE__ */ isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY$2);
});
return cookieValue;
}
function _getCookieValue(name) {
var cookieValue = STR_EMPTY$2;
!_doc && _getDoc();
if (_doc.v) {
var theCookie = _doc.v[strCookie] || STR_EMPTY$2;
if (_parsedCookieValue !== theCookie) {
_cookieCache = _extractParts(theCookie);
_parsedCookieValue = theCookie;
}
cookieValue = strTrim(_cookieCache[name] || STR_EMPTY$2);
}
return cookieValue;
}
function _setCookieValue(name, cookieValue) {
!_doc && _getDoc();
if (_doc.v) {
_doc.v[strCookie] = name + "=" + cookieValue;
}
}
function uaDisallowsSameSiteNone(userAgent) {
if (!isString(userAgent)) {
return false;
}
if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
return true;
}
if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
return true;
}
if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
return true;
}
if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
return true;
}
if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
return true;
}
if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
return true;
}
return false;
}
var defaultValues$1 = {
perfEvtsSendAll: false
};
function _runScheduledListeners(asyncNotifications) {
asyncNotifications.h = null;
var callbacks = asyncNotifications.cb;
asyncNotifications.cb = [];
arrForEach(callbacks, function(cb) {
safe(cb.fn, [cb.arg]);
});
}
function _runListeners(listeners, name, asyncNotifications, callback) {
arrForEach(listeners, function(listener) {
if (listener && listener[name]) {
if (asyncNotifications) {
asyncNotifications.cb[_DYN_PUSH]({
fn: callback,
arg: listener
});
asyncNotifications.h = asyncNotifications.h || scheduleTimeout(_runScheduledListeners, 0, asyncNotifications);
} else {
safe(callback, [listener]);
}
}
});
}
var NotificationManager = (
/** @class */
(function() {
function NotificationManager2(config) {
this.listeners = [];
var perfEvtsSendAll;
var unloadHandler;
var _listeners = [];
var _asyncNotifications = {
h: null,
cb: []
};
var cfgHandler = createDynamicConfig(config, defaultValues$1);
unloadHandler = cfgHandler[_DYN_WATCH](function(details) {
perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
});
dynamicProto(NotificationManager2, this, function(_self) {
objDefine(_self, "listeners", {
g: function() {
return _listeners;
}
});
_self[_DYN_ADD_NOTIFICATION_LIS1] = function(listener) {
_listeners[_DYN_PUSH](listener);
};
_self[_DYN_REMOVE_NOTIFICATION_0] = function(listener) {
var index = arrIndexOf(_listeners, listener);
while (index > -1) {
_listeners[_DYN_SPLICE](index, 1);
index = arrIndexOf(_listeners, listener);
}
};
_self[STR_EVENTS_SENT] = function(events) {
_runListeners(_listeners, STR_EVENTS_SENT, _asyncNotifications, function(listener) {
listener[STR_EVENTS_SENT](events);
});
};
_self[STR_EVENTS_DISCARDED] = function(events, reason) {
_runListeners(_listeners, STR_EVENTS_DISCARDED, _asyncNotifications, function(listener) {
listener[STR_EVENTS_DISCARDED](events, reason);
});
};
_self[STR_EVENTS_SEND_REQUEST] = function(sendReason, isAsync) {
_runListeners(_listeners, STR_EVENTS_SEND_REQUEST, isAsync ? _asyncNotifications : null, function(listener) {
listener[STR_EVENTS_SEND_REQUEST](sendReason, isAsync);
});
};
_self[STR_PERF_EVENT] = function(perfEvent) {
if (perfEvent) {
if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT]()) {
_runListeners(_listeners, STR_PERF_EVENT, null, function(listener) {
if (perfEvent.isAsync) {
scheduleTimeout(function() {
return listener[STR_PERF_EVENT](perfEvent);
}, 0);
} else {
listener[STR_PERF_EVENT](perfEvent);
}
});
}
}
};
_self[STR_OFFLINE_STORE] = function(events) {
if (events && events[_DYN_LENGTH$1]) {
_runListeners(_listeners, STR_OFFLINE_STORE, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_STORE](events);
});
}
};
_self[STR_OFFLINE_SENT] = function(batch) {
if (batch && batch[_DYN_DATA]) {
_runListeners(_listeners, STR_OFFLINE_SENT, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_SENT](batch);
});
}
};
_self[STR_OFFLINE_DROP] = function(cnt, reason) {
if (cnt > 0) {
var rn_1 = reason || 0;
_runListeners(_listeners, STR_OFFLINE_DROP, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_DROP](cnt, rn_1);
});
}
};
_self[_DYN_UNLOAD] = function(isAsync) {
var _finishUnload = function() {
unloadHandler && unloadHandler.rm();
unloadHandler = null;
_listeners = [];
_asyncNotifications.h && _asyncNotifications.h[_DYN_CANCEL]();
_asyncNotifications.h = null;
_asyncNotifications.cb = [];
};
var waiting;
_runListeners(_listeners, "unload", null, function(listener) {
var asyncUnload = listener[_DYN_UNLOAD](isAsync);
if (asyncUnload) {
if (!waiting) {
waiting = [];
}
waiting[_DYN_PUSH](asyncUnload);
}
});
if (waiting) {
return createPromise(function(resolve3) {
return doAwaitResponse(createAllPromise(waiting), function() {
_finishUnload();
resolve3();
});
});
} else {
_finishUnload();
}
};
});
}
NotificationManager2.__ieDyn = 1;
return NotificationManager2;
})()
);
var strExecutionContextKey = "ctx";
var strParentContextKey = "ParentContextKey";
var strChildrenContextKey = "ChildrenContextKey";
var _defaultPerfManager = null;
var PerfEvent = (
/** @class */
(function() {
function PerfEvent2(name, payloadDetails, isAsync) {
var _self = this;
_self.start = /* @__PURE__ */ utcNow();
_self[_DYN_NAME] = name;
_self.isAsync = isAsync;
_self[_DYN_IS_CHILD_EVT] = function() {
return false;
};
if (isFunction(payloadDetails)) {
var theDetails_1;
objDefine(_self, "payload", {
g: function() {
if (!theDetails_1 && isFunction(payloadDetails)) {
theDetails_1 = payloadDetails();
payloadDetails = null;
}
return theDetails_1;
}
});
}
_self[_DYN_GET_CTX] = function(key) {
if (key) {
if (key === PerfEvent2[strParentContextKey] || key === PerfEvent2[strChildrenContextKey]) {
return _self[key];
}
return (_self[strExecutionContextKey] || {})[key];
}
return null;
};
_self[_DYN_SET_CTX] = function(key, value) {
if (key) {
if (key === PerfEvent2[strParentContextKey]) {
if (!_self[key]) {
_self[_DYN_IS_CHILD_EVT] = function() {
return true;
};
}
_self[key] = value;
} else if (key === PerfEvent2[strChildrenContextKey]) {
_self[key] = value;
} else {
var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
ctx[key] = value;
}
}
};
_self.complete = function() {
var childTime = 0;
var childEvts = _self[_DYN_GET_CTX](PerfEvent2[strChildrenContextKey]);
if (isArray(childEvts)) {
for (var lp = 0; lp < childEvts[_DYN_LENGTH$1]; lp++) {
var childEvt = childEvts[lp];
if (childEvt) {
childTime += childEvt.time;
}
}
}
_self.time = /* @__PURE__ */ utcNow() - _self.start;
_self.exTime = _self.time - childTime;
_self.complete = function() {
};
};
}
PerfEvent2.ParentContextKey = "parent";
PerfEvent2.ChildrenContextKey = "childEvts";
return PerfEvent2;
})()
);
var PerfManager = (
/** @class */
(function() {
function PerfManager2(manager) {
this.ctx = {};
dynamicProto(PerfManager2, this, function(_self) {
_self.create = function(src, payloadDetails, isAsync) {
return new PerfEvent(src, payloadDetails, isAsync);
};
_self.fire = function(perfEvent) {
if (perfEvent) {
perfEvent.complete();
if (manager && isFunction(manager[STR_PERF_EVENT])) {
manager[STR_PERF_EVENT](perfEvent);
}
}
};
_self[_DYN_SET_CTX] = function(key, value) {
if (key) {
var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
ctx[key] = value;
}
};
_self[_DYN_GET_CTX] = function(key) {
return (_self[strExecutionContextKey] || {})[key];
};
});
}
PerfManager2.__ieDyn = 1;
return PerfManager2;
})()
);
var doPerfActiveKey = "CoreUtils.doPerf";
function doPerf(mgrSource, getSource, func, details, isAsync) {
if (mgrSource) {
var perfMgr = mgrSource;
if (perfMgr[STR_GET_PERF_MGR]) {
perfMgr = perfMgr[STR_GET_PERF_MGR]();
}
if (perfMgr) {
var perfEvt = void 0;
var currentActive = perfMgr[_DYN_GET_CTX](doPerfActiveKey);
try {
perfEvt = perfMgr.create(getSource(), details, isAsync);
if (perfEvt) {
if (currentActive && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX](PerfEvent[strParentContextKey], currentActive);
if (currentActive[_DYN_GET_CTX] && currentActive[_DYN_SET_CTX]) {
var children = currentActive[_DYN_GET_CTX](PerfEvent[strChildrenContextKey]);
if (!children) {
children = [];
currentActive[_DYN_SET_CTX](PerfEvent[strChildrenContextKey], children);
}
children[_DYN_PUSH](perfEvt);
}
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, perfEvt);
return func(perfEvt);
}
} catch (ex) {
if (perfEvt && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX]("exception", ex);
}
} finally {
if (perfEvt) {
perfMgr.fire(perfEvt);
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, currentActive);
}
}
}
return func();
}
function getGblPerfMgr() {
return _defaultPerfManager;
}
function newGuid() {
var uuid = generateW3CId();
return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
}
function generateW3CId() {
var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
var oct = STR_EMPTY$2, tmp;
for (var a = 0; a < 4; a++) {
tmp = random32();
oct += hexValues[tmp & 15] + hexValues[tmp >> 4 & 15] + hexValues[tmp >> 8 & 15] + hexValues[tmp >> 12 & 15] + hexValues[tmp >> 16 & 15] + hexValues[tmp >> 20 & 15] + hexValues[tmp >> 24 & 15] + hexValues[tmp >> 28 & 15];
}
var clockSequenceHi = hexValues[8 + (random32() & 3) | 0];
return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
}
var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
var DEFAULT_VERSION = "00";
var INVALID_VERSION = "ff";
var INVALID_TRACE_ID = "00000000000000000000000000000000";
var INVALID_SPAN_ID = "0000000000000000";
var SAMPLED_FLAG = 1;
function _isValid(value, len, invalidValue) {
if (value && value[_DYN_LENGTH$1] === len && value !== invalidValue) {
return !!value.match(/^[\da-f]*$/i);
}
return false;
}
function _formatValue(value, len, defValue) {
if (_isValid(value, len)) {
return value;
}
return defValue;
}
function _formatFlags(value) {
if (isNaN(value) || value < 0 || value > 255) {
value = 1;
}
var result = value.toString(16);
while (result[_DYN_LENGTH$1] < 2) {
result = "0" + result;
}
return result;
}
function createTraceParent(traceId, spanId, flags, version2) {
return {
version: _isValid(version2, 2, INVALID_VERSION) ? version2 : DEFAULT_VERSION,
traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
spanId: isValidSpanId(spanId) ? spanId : /* @__PURE__ */ strLeft(generateW3CId(), 16),
traceFlags: flags >= 0 && flags <= 255 ? flags : 1
};
}
function parseTraceParent(value, selectIdx) {
if (!value) {
return null;
}
if (isArray(value)) {
value = value[0] || "";
}
if (!value || !isString(value) || value[_DYN_LENGTH$1] > 8192) {
return null;
}
if (value[_DYN_INDEX_OF$1](",") !== -1) {
var values = value[_DYN_SPLIT](",");
value = values[selectIdx > 0 && values[_DYN_LENGTH$1] > selectIdx ? selectIdx : 0];
}
var match = TRACE_PARENT_REGEX.exec(strTrim(value));
if (!match || match[1] === INVALID_VERSION || match[2] === INVALID_TRACE_ID || match[3] === INVALID_SPAN_ID) {
return null;
}
return {
version: (match[1] || STR_EMPTY$2)[_DYN_TO_LOWER_CASE](),
traceId: (match[2] || STR_EMPTY$2)[_DYN_TO_LOWER_CASE](),
spanId: (match[3] || STR_EMPTY$2)[_DYN_TO_LOWER_CASE](),
traceFlags: parseInt(match[4], 16)
};
}
function isValidTraceId(value) {
return _isValid(value, 32, INVALID_TRACE_ID);
}
function isValidSpanId(value) {
return _isValid(value, 16, INVALID_SPAN_ID);
}
function isValidTraceParent(value) {
if (!value || !_isValid(value[_DYN_VERSION], 2, INVALID_VERSION) || !_isValid(value.traceId, 32, INVALID_TRACE_ID) || !_isValid(value.spanId, 16, INVALID_SPAN_ID) || !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS]), 2)) {
return false;
}
return true;
}
function isSampledFlag(value) {
if (isValidTraceParent(value)) {
return (value[_DYN_TRACE_FLAGS] & SAMPLED_FLAG) === SAMPLED_FLAG;
}
return false;
}
function formatTraceParent(value) {
if (value) {
var flags = _formatFlags(value[_DYN_TRACE_FLAGS]);
if (!_isValid(flags, 2)) {
flags = "01";
}
var version2 = value[_DYN_VERSION] || DEFAULT_VERSION;
if (version2 !== "00" && version2 !== "ff") {
version2 = DEFAULT_VERSION;
}
return "".concat(version2.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
}
return "";
}
function findW3cTraceParent(selectIdx) {
var name = "traceparent";
var traceParent = parseTraceParent(findMetaTag(name), selectIdx);
if (!traceParent) {
traceParent = parseTraceParent(findNamedServerTiming(name), selectIdx);
}
return traceParent;
}
var pluginStateData = createElmNodeData("plugin");
function _getPluginState(plugin) {
return pluginStateData.get(plugin, "state", {}, true);
}
function initializePlugins(processContext, extensions3) {
var initPlugins = [];
var lastPlugin = null;
var proxy = processContext[_DYN_GET_NEXT]();
var pluginState;
while (proxy) {
var thePlugin = proxy[_DYN_GET_PLUGIN]();
if (thePlugin) {
if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN] && thePlugin[STR_PROCESS_TELEMETRY]) {
lastPlugin[_DYN_SET_NEXT_PLUGIN](thePlugin);
}
pluginState = _getPluginState(thePlugin);
var isInitialized = !!pluginState[_DYN_IS_INITIALIZED];
if (thePlugin[_DYN_IS_INITIALIZED]) {
isInitialized = thePlugin[_DYN_IS_INITIALIZED]();
}
if (!isInitialized) {
initPlugins[_DYN_PUSH](thePlugin);
}
lastPlugin = thePlugin;
proxy = proxy[_DYN_GET_NEXT]();
}
}
arrForEach(initPlugins, function(thePlugin2) {
var core = processContext[STR_CORE]();
thePlugin2[_DYN_INITIALIZE$1](processContext.getCfg(), core, extensions3, processContext[_DYN_GET_NEXT]());
pluginState = _getPluginState(thePlugin2);
if (!thePlugin2[STR_CORE] && !pluginState[STR_CORE]) {
pluginState[STR_CORE] = core;
}
pluginState[_DYN_IS_INITIALIZED] = true;
delete pluginState[_DYN_TEARDOWN];
});
}
function sortPlugins(plugins) {
return plugins.sort(function(extA, extB) {
var result = 0;
if (extB) {
var bHasProcess = extB[STR_PROCESS_TELEMETRY];
if (extA[STR_PROCESS_TELEMETRY]) {
result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;
} else if (bHasProcess) {
result = -1;
}
} else {
result = extA ? 1 : -1;
}
return result;
});
}
function createDistributedTraceContext(parentCtx) {
var trace = {};
return {
getName: function() {
return trace[_DYN_NAME];
},
setName: function(newValue) {
parentCtx && parentCtx.setName(newValue);
trace[_DYN_NAME] = newValue;
},
getTraceId: function() {
return trace.traceId;
},
setTraceId: function(newValue) {
parentCtx && parentCtx.setTraceId(newValue);
if (isValidTraceId(newValue)) {
trace.traceId = newValue;
}
},
getSpanId: function() {
return trace.spanId;
},
setSpanId: function(newValue) {
parentCtx && parentCtx.setSpanId(newValue);
if (isValidSpanId(newValue)) {
trace.spanId = newValue;
}
},
getTraceFlags: function() {
return trace[_DYN_TRACE_FLAGS];
},
setTraceFlags: function(newTraceFlags) {
parentCtx && parentCtx.setTraceFlags(newTraceFlags);
trace[_DYN_TRACE_FLAGS] = newTraceFlags;
}
};
}
var strTelemetryPluginChain = "TelemetryPluginChain";
var strHasRunFlags = "_hasRun";
var strGetTelCtx = "_getTelCtx";
var _chainId = 0;
function _getNextProxyStart(proxy, core, startAt) {
while (proxy) {
if (proxy[_DYN_GET_PLUGIN]() === startAt) {
return proxy;
}
proxy = proxy[_DYN_GET_NEXT]();
}
return createTelemetryProxyChain([startAt], core.config || {}, core);
}
function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
var _nextProxy = null;
var _onComplete = [];
if (!dynamicHandler) {
dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER]);
}
if (startAt !== null) {
_nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
}
var context = {
_next: _moveNext,
ctx: {
core: function() {
return core;
},
diagLog: function() {
return safeGetLogger(core, dynamicHandler.cfg);
},
getCfg: function() {
return dynamicHandler.cfg;
},
getExtCfg: _resolveExtCfg,
getConfig: _getConfig,
hasNext: function() {
return !!_nextProxy;
},
getNext: function() {
return _nextProxy;
},
setNext: function(nextPlugin) {
_nextProxy = nextPlugin;
},
iterate: _iterateChain,
onComplete: _addOnComplete
}
};
function _addOnComplete(onComplete, that) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
if (onComplete) {
_onComplete[_DYN_PUSH]({
func: onComplete,
self: !/* @__PURE__ */ isUndefined(that) ? that : context.ctx,
args
});
}
}
function _moveNext() {
var nextProxy = _nextProxy;
_nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT]() : null;
if (!nextProxy) {
var onComplete = _onComplete;
if (onComplete && onComplete[_DYN_LENGTH$1] > 0) {
arrForEach(onComplete, function(completeDetails) {
try {
completeDetails.func.call(completeDetails.self, completeDetails.args);
} catch (e) {
_throwInternal(core[_DYN_LOGGER], 2, 73, "Unexpected Exception during onComplete - " + /* @__PURE__ */ dumpObj(e));
}
});
_onComplete = [];
}
}
return nextProxy;
}
function _getExtCfg(identifier, createIfMissing) {
var idCfg = null;
var cfg = dynamicHandler.cfg;
if (cfg && identifier) {
var extCfg = cfg[STR_EXTENSION_CONFIG];
if (!extCfg && createIfMissing) {
extCfg = {};
}
cfg[STR_EXTENSION_CONFIG] = extCfg;
extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
if (extCfg) {
idCfg = extCfg[identifier];
if (!idCfg && createIfMissing) {
idCfg = {};
}
extCfg[identifier] = idCfg;
idCfg = dynamicHandler.ref(extCfg, identifier);
}
}
return idCfg;
}
function _resolveExtCfg(identifier, defaultValues2) {
var newConfig = _getExtCfg(identifier, true);
if (defaultValues2) {
objForEachKey(defaultValues2, function(field, defaultValue) {
if (/* @__PURE__ */ isNullOrUndefined(newConfig[field])) {
var cfgValue = dynamicHandler.cfg[field];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
newConfig[field] = cfgValue;
}
}
_applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
});
}
return dynamicHandler.setDf(newConfig, defaultValues2);
}
function _getConfig(identifier, field, defaultValue) {
if (defaultValue === void 0) {
defaultValue = false;
}
var theValue;
var extConfig = _getExtCfg(identifier, false);
var rootConfig = dynamicHandler.cfg;
if (extConfig && (extConfig[field] || !/* @__PURE__ */ isNullOrUndefined(extConfig[field]))) {
theValue = extConfig[field];
} else if (rootConfig[field] || !/* @__PURE__ */ isNullOrUndefined(rootConfig[field])) {
theValue = rootConfig[field];
}
return theValue || !/* @__PURE__ */ isNullOrUndefined(theValue) ? theValue : defaultValue;
}
function _iterateChain(cb) {
var nextPlugin;
while (!!(nextPlugin = context._next())) {
var plugin = nextPlugin[_DYN_GET_PLUGIN]();
if (plugin) {
cb(plugin);
}
}
}
return context;
}
function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
var config = createDynamicConfig(cfg);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(env2) {
var nextPlugin = internalContext._next();
if (nextPlugin) {
nextPlugin[STR_PROCESS_TELEMETRY](env2, context);
}
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT](), config.cfg, core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(unloadState) {
var nextPlugin = internalContext._next();
nextPlugin && nextPlugin[_DYN_UNLOAD](context, unloadState);
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(updateState) {
return context.iterate(function(plugin) {
if (isFunction(plugin[_DYN_UPDATE])) {
plugin[_DYN_UPDATE](context, updateState);
}
});
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createTelemetryProxyChain(plugins, config, core, startAt) {
var firstProxy = null;
var add = startAt ? false : true;
if (isArray(plugins) && plugins[_DYN_LENGTH$1] > 0) {
var lastProxy_1 = null;
arrForEach(plugins, function(thePlugin) {
if (!add && startAt === thePlugin) {
add = true;
}
if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY])) {
var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
if (!firstProxy) {
firstProxy = newProxy;
}
if (lastProxy_1) {
lastProxy_1._setNext(newProxy);
}
lastProxy_1 = newProxy;
}
});
}
if (startAt && !firstProxy) {
return createTelemetryProxyChain([startAt], config, core);
}
return firstProxy;
}
function createTelemetryPluginProxy(plugin, config, core) {
var nextProxy = null;
var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY]);
var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN]);
var chainId;
if (plugin) {
chainId = plugin[_DYN_IDENTIFIER] + "-" + plugin[STR_PRIORITY] + "-" + _chainId++;
} else {
chainId = "Unknown-0-" + _chainId++;
}
var proxyChain = {
getPlugin: function() {
return plugin;
},
getNext: function() {
return nextProxy;
},
processTelemetry: _processTelemetry,
unload: _unloadPlugin,
update: _updatePlugin,
_id: chainId,
_setNext: function(nextPlugin) {
nextProxy = nextPlugin;
}
};
function _getTelCtx() {
var itemCtx;
if (plugin && isFunction(plugin[strGetTelCtx])) {
itemCtx = plugin[strGetTelCtx]();
}
if (!itemCtx) {
itemCtx = createProcessTelemetryContext(proxyChain, config, core);
}
return itemCtx;
}
function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
var hasRun = false;
var identifier = plugin ? plugin[_DYN_IDENTIFIER] : strTelemetryPluginChain;
var hasRunContext = itemCtx[strHasRunFlags];
if (!hasRunContext) {
hasRunContext = itemCtx[strHasRunFlags] = {};
}
itemCtx.setNext(nextProxy);
if (plugin) {
doPerf(itemCtx[STR_CORE](), function() {
return identifier + ":" + name;
}, function() {
hasRunContext[chainId] = true;
try {
var nextId = nextProxy ? nextProxy._id : STR_EMPTY$2;
if (nextId) {
hasRunContext[nextId] = false;
}
hasRun = processPluginFn(itemCtx);
} catch (error) {
var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
if (hasNextRun) {
hasRun = true;
}
if (!nextProxy || !hasNextRun) {
_throwInternal(itemCtx[_DYN_DIAG_LOG](), 1, 73, "Plugin [" + identifier + "] failed during " + name + " - " + /* @__PURE__ */ dumpObj(error) + ", run flags: " + /* @__PURE__ */ dumpObj(hasRunContext));
}
}
}, details, isAsync);
}
return hasRun;
}
function _processTelemetry(env2, itemCtx) {
itemCtx = itemCtx || _getTelCtx();
function _callProcessTelemetry(itemCtx2) {
if (!plugin || !hasProcessTelemetry) {
return false;
}
var pluginState = _getPluginState(plugin);
if (pluginState[_DYN_TEARDOWN] || pluginState[STR_DISABLED]) {
return false;
}
if (hasSetNext) {
plugin[_DYN_SET_NEXT_PLUGIN](nextProxy);
}
plugin[STR_PROCESS_TELEMETRY](env2, itemCtx2);
return true;
}
if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function() {
return { item: env2 };
}, !env2.sync)) {
itemCtx[_DYN_PROCESS_NEXT](env2);
}
}
function _unloadPlugin(unloadCtx, unloadState) {
function _callTeardown() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
pluginState[STR_CORE] = null;
pluginState[_DYN_TEARDOWN] = true;
pluginState[_DYN_IS_INITIALIZED] = false;
if (plugin[_DYN_TEARDOWN] && plugin[_DYN_TEARDOWN](unloadCtx, unloadState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(unloadCtx, _callTeardown, "unload", function() {
}, unloadState.isAsync)) {
unloadCtx[_DYN_PROCESS_NEXT](unloadState);
}
}
function _updatePlugin(updateCtx, updateState) {
function _callUpdate() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
if (plugin[_DYN_UPDATE] && plugin[_DYN_UPDATE](updateCtx, updateState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(updateCtx, _callUpdate, "update", function() {
}, false)) {
updateCtx[_DYN_PROCESS_NEXT](updateState);
}
}
return objFreeze(proxyChain);
}
var ProcessTelemetryContext = (
/** @class */
/* @__PURE__ */ (function() {
function ProcessTelemetryContext2(pluginChain, config, core, startAt) {
var _self = this;
var context = createProcessTelemetryContext(pluginChain, config, core, startAt);
proxyFunctions(_self, context, objKeys(context));
}
return ProcessTelemetryContext2;
})()
);
function createUnloadHandlerContainer() {
var handlers = [];
function _addHandler(handler) {
if (handler) {
handlers[_DYN_PUSH](handler);
}
}
function _runHandlers(unloadCtx, unloadState) {
arrForEach(handlers, function(handler) {
try {
handler(unloadCtx, unloadState);
} catch (e) {
_throwInternal(unloadCtx[_DYN_DIAG_LOG](), 2, 73, "Unexpected error calling unload handler - " + /* @__PURE__ */ dumpObj(e));
}
});
handlers = [];
}
return {
add: _addHandler,
run: _runHandlers
};
}
var _maxHooks;
var _hookAddMonitor;
function _testHookMaxUnloadHooksCb(maxHooks, addMonitor) {
_maxHooks = maxHooks;
_hookAddMonitor = addMonitor;
}
function createUnloadHookContainer() {
var _hooks = [];
function _doUnload(logger2) {
var oldHooks = _hooks;
_hooks = [];
arrForEach(oldHooks, function(fn) {
try {
(fn.rm || fn.remove).call(fn);
} catch (e) {
_throwInternal(logger2, 2, 73, "Unloading:" + /* @__PURE__ */ dumpObj(e));
}
});
if (_maxHooks && oldHooks[_DYN_LENGTH$1] > _maxHooks) {
_hookAddMonitor ? _hookAddMonitor("doUnload", oldHooks) : _throwInternal(null, 1, 48, "Max unload hooks exceeded. An excessive number of unload hooks has been detected.");
}
}
function _addHook(hooks) {
if (hooks) {
arrAppend(_hooks, hooks);
if (_maxHooks && _hooks[_DYN_LENGTH$1] > _maxHooks) {
_hookAddMonitor ? _hookAddMonitor("Add", _hooks) : _throwInternal(null, 1, 48, "Max unload hooks exceeded. An excessive number of unload hooks has been detected.");
}
}
}
return {
run: _doUnload,
add: _addHook
};
}
var _a$2;
var strGetPlugin = "getPlugin";
var defaultValues = (_a$2 = {}, _a$2[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} }, _a$2);
var BaseTelemetryPlugin = (
/** @class */
(function() {
function BaseTelemetryPlugin2() {
var _self = this;
var _isinitialized;
var _rootCtx;
var _nextPlugin;
var _unloadHandlerContainer;
var _hookContainer;
_initDefaults();
dynamicProto(BaseTelemetryPlugin2, _self, function(_self2) {
_self2[_DYN_INITIALIZE$1] = function(config, core, extensions3, pluginChain) {
_setDefaults(config, core, pluginChain);
_isinitialized = true;
};
_self2[_DYN_TEARDOWN] = function(unloadCtx, unloadState) {
var core = _self2[STR_CORE];
if (!core || unloadCtx && core !== unloadCtx[STR_CORE]()) {
return;
}
var result;
var unloadDone = false;
var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUnloadState = unloadState || {
reason: 0,
isAsync: false
};
function _unloadCallback() {
if (!unloadDone) {
unloadDone = true;
_unloadHandlerContainer.run(theUnloadCtx, unloadState);
_hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG]());
if (result === true) {
theUnloadCtx[_DYN_PROCESS_NEXT](theUnloadState);
}
_initDefaults();
}
}
if (!_self2[_DYN__DO_TEARDOWN] || _self2[_DYN__DO_TEARDOWN](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
_unloadCallback();
} else {
result = true;
}
return result;
};
_self2[_DYN_UPDATE] = function(updateCtx, updateState) {
var core = _self2[STR_CORE];
if (!core || updateCtx && core !== updateCtx[STR_CORE]()) {
return;
}
var result;
var updateDone = false;
var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUpdateState = updateState || {
reason: 0
};
function _updateCallback() {
if (!updateDone) {
updateDone = true;
_setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT]());
}
}
if (!_self2._doUpdate || _self2._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
_updateCallback();
} else {
result = true;
}
return result;
};
proxyFunctionAs(_self2, "_addUnloadCb", function() {
return _unloadHandlerContainer;
}, "add");
proxyFunctionAs(_self2, "_addHook", function() {
return _hookContainer;
}, "add");
objDefine(_self2, "_unloadHooks", { g: function() {
return _hookContainer;
} });
});
_self[_DYN_DIAG_LOG] = function(itemCtx) {
return _getTelCtx(itemCtx)[_DYN_DIAG_LOG]();
};
_self[_DYN_IS_INITIALIZED] = function() {
return _isinitialized;
};
_self.setInitialized = function(isInitialized) {
_isinitialized = isInitialized;
};
_self[_DYN_SET_NEXT_PLUGIN] = function(next) {
_nextPlugin = next;
};
_self[_DYN_PROCESS_NEXT] = function(env2, itemCtx) {
if (itemCtx) {
itemCtx[_DYN_PROCESS_NEXT](env2);
} else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY])) {
_nextPlugin[STR_PROCESS_TELEMETRY](env2, null);
}
};
_self._getTelCtx = _getTelCtx;
function _getTelCtx(currentCtx) {
if (currentCtx === void 0) {
currentCtx = null;
}
var itemCtx = currentCtx;
if (!itemCtx) {
var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE]);
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin[strGetPlugin]);
} else {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin);
}
}
return itemCtx;
}
function _setDefaults(config, core, pluginChain) {
createDynamicConfig(config, defaultValues, safeGetLogger(core));
if (!pluginChain && core) {
pluginChain = core[_DYN_GET_PROCESS_TEL_CONT2]()[_DYN_GET_NEXT]();
}
var nextPlugin = _nextPlugin;
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
nextPlugin = _nextPlugin[strGetPlugin]();
}
_self[STR_CORE] = core;
_rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
}
function _initDefaults() {
_isinitialized = false;
_self[STR_CORE] = null;
_rootCtx = null;
_nextPlugin = null;
_hookContainer = createUnloadHookContainer();
_unloadHandlerContainer = createUnloadHandlerContainer();
}
}
BaseTelemetryPlugin2.__ieDyn = 1;
return BaseTelemetryPlugin2;
})()
);
function _addInitializer(_initializers, id, telemetryInitializer) {
var theInitializer = {
id,
fn: telemetryInitializer
};
arrAppend(_initializers, theInitializer);
var handler = {
remove: function() {
arrForEach(_initializers, function(initializer, idx) {
if (initializer.id === theInitializer.id) {
_initializers[_DYN_SPLICE](idx, 1);
return -1;
}
});
}
};
return handler;
}
function _runInitializers(_initializers, item, logger2) {
var doNotSendItem = false;
var telemetryInitializersCount = _initializers[_DYN_LENGTH$1];
for (var i = 0; i < telemetryInitializersCount; ++i) {
var telemetryInitializer = _initializers[i];
if (telemetryInitializer) {
try {
if (telemetryInitializer.fn[_DYN_APPLY](null, [item]) === false) {
doNotSendItem = true;
break;
}
} catch (e) {
_throwInternal(logger2, 2, 64, "Telemetry initializer failed: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) }, true);
}
}
}
return !doNotSendItem;
}
var TelemetryInitializerPlugin = (
/** @class */
(function(_super) {
__extendsFn(TelemetryInitializerPlugin2, _super);
function TelemetryInitializerPlugin2() {
var _this = _super.call(this) || this;
_this.identifier = "TelemetryInitializerPlugin";
_this.priority = 199;
var _id;
var _initializers;
_initDefaults();
dynamicProto(TelemetryInitializerPlugin2, _this, function(_self, _base) {
_self.addTelemetryInitializer = function(telemetryInitializer) {
return _addInitializer(_initializers, _id++, telemetryInitializer);
};
_self[STR_PROCESS_TELEMETRY] = function(item, itemCtx) {
if (_runInitializers(_initializers, item, itemCtx ? itemCtx[_DYN_DIAG_LOG]() : _self[_DYN_DIAG_LOG]())) {
_self[_DYN_PROCESS_NEXT](item, itemCtx);
}
};
_self[_DYN__DO_TEARDOWN] = function() {
_initDefaults();
};
});
function _initDefaults() {
_id = 0;
_initializers = [];
}
return _this;
}
TelemetryInitializerPlugin2.__ieDyn = 1;
return TelemetryInitializerPlugin2;
})(BaseTelemetryPlugin)
);
var _a$1;
var strValidationError = "Plugins must provide initialize method";
var strNotificationManager = "_notificationManager";
var strSdkUnloadingError = "SDK is still unloading...";
var strSdkNotInitialized = "SDK is not initialized";
var maxInitQueueSize = 100;
var maxInitTimeout = 5e4;
var defaultConfig$1 = objDeepFreeze((_a$1 = {
cookieCfg: {}
}, _a$1[STR_EXTENSIONS] = { rdOnly: true, ref: true, v: [] }, _a$1[STR_CHANNELS] = { rdOnly: true, ref: true, v: [] }, _a$1[STR_EXTENSION_CONFIG] = { ref: true, v: {} }, _a$1[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE, _a$1.loggingLevelConsole = 0, _a$1.diagnosticLogInterval = UNDEFINED_VALUE, _a$1));
function _createPerfManager(core, notificationMgr) {
return new PerfManager(notificationMgr);
}
function _validateExtensions(logger2, channelPriority, allExtensions) {
var coreExtensions = [];
var channels = [];
var extPriorities = {};
arrForEach(allExtensions, function(ext) {
if (/* @__PURE__ */ isNullOrUndefined(ext) || /* @__PURE__ */ isNullOrUndefined(ext[_DYN_INITIALIZE$1])) {
throwError(strValidationError);
}
var extPriority = ext[STR_PRIORITY];
var identifier = ext[_DYN_IDENTIFIER];
if (ext && extPriority) {
if (!/* @__PURE__ */ isNullOrUndefined(extPriorities[extPriority])) {
_warnToConsole(logger2, "Two extensions have same priority #" + extPriority + " - " + extPriorities[extPriority] + ", " + identifier);
} else {
extPriorities[extPriority] = identifier;
}
}
if (!extPriority || extPriority < channelPriority) {
coreExtensions[_DYN_PUSH](ext);
} else {
channels[_DYN_PUSH](ext);
}
});
return {
core: coreExtensions,
channels
};
}
function _isPluginPresent(thePlugin, plugins) {
var exists = false;
arrForEach(plugins, function(plugin) {
if (plugin === thePlugin) {
exists = true;
return -1;
}
});
return exists;
}
function _deepMergeConfig(details, target, newValues, merge) {
if (newValues) {
objForEachKey(newValues, function(key, value) {
if (merge) {
if (/* @__PURE__ */ isPlainObject(value) && /* @__PURE__ */ isPlainObject(target[key])) {
_deepMergeConfig(details, target[key], value, merge);
}
}
if (merge && /* @__PURE__ */ isPlainObject(value) && /* @__PURE__ */ isPlainObject(target[key])) {
_deepMergeConfig(details, target[key], value, merge);
} else {
details.set(target, key, value);
}
});
}
}
function _findWatcher(listeners, newWatcher) {
var theListener = null;
var idx = -1;
arrForEach(listeners, function(listener, lp) {
if (listener.w === newWatcher) {
theListener = listener;
idx = lp;
return -1;
}
});
return { i: idx, l: theListener };
}
function _addDelayedCfgListener(listeners, newWatcher) {
var theListener = _findWatcher(listeners, newWatcher).l;
if (!theListener) {
theListener = {
w: newWatcher,
rm: function() {
var fnd = _findWatcher(listeners, newWatcher);
if (fnd.i !== -1) {
listeners[_DYN_SPLICE](fnd.i, 1);
}
}
};
listeners[_DYN_PUSH](theListener);
}
return theListener;
}
function _registerDelayedCfgListener(config, listeners, logger2) {
arrForEach(listeners, function(listener) {
var unloadHdl = onConfigChange(config, listener.w, logger2);
delete listener.w;
listener.rm = function() {
unloadHdl.rm();
};
});
}
function _initDebugListener(configHandler, unloadContainer, notificationManager, debugListener) {
unloadContainer.add(configHandler[_DYN_WATCH](function(details) {
var disableDbgExt = details.cfg.disableDbgExt;
if (disableDbgExt === true && debugListener) {
notificationManager[_DYN_REMOVE_NOTIFICATION_0](debugListener);
debugListener = null;
}
if (notificationManager && !debugListener && disableDbgExt !== true) {
debugListener = getDebugListener(details.cfg);
notificationManager[_DYN_ADD_NOTIFICATION_LIS1](debugListener);
}
}));
return debugListener;
}
function _createUnloadHook(unloadHook) {
return objDefine({
rm: function() {
unloadHook.rm();
}
}, "toJSON", { v: function() {
return "aicore::onCfgChange<" + JSON.stringify(unloadHook) + ">";
} });
}
var AppInsightsCore$1 = (
/** @class */
(function() {
function AppInsightsCore2() {
var _configHandler;
var _isInitialized;
var _logger;
var _eventQueue;
var _notificationManager;
var _perfManager;
var _cfgPerfManager;
var _cookieManager;
var _pluginChain;
var _configExtensions;
var _channelConfig;
var _channels;
var _isUnloading;
var _telemetryInitializerPlugin;
var _internalLogsEventName;
var _evtNamespace;
var _unloadHandlers;
var _hookContainer;
var _debugListener2;
var _traceCtx;
var _instrumentationKey;
var _cfgListeners;
var _extensions;
var _pluginVersionStringArr;
var _pluginVersionString;
var _activeStatus;
var _endpoint;
var _initInMemoMaxSize;
var _isStatusSet;
var _initTimer;
var _internalLogPoller;
var _internalLogPollerListening;
var _forceStopInternalLogPoller;
dynamicProto(AppInsightsCore2, this, function(_self) {
_initDefaults();
_self["_getDbgPlgTargets"] = function() {
return [_extensions, _eventQueue];
};
_self[_DYN_IS_INITIALIZED] = function() {
return _isInitialized;
};
_self.activeStatus = function() {
return _activeStatus;
};
_self._setPendingStatus = function() {
_activeStatus = 3;
};
_self[_DYN_INITIALIZE$1] = function(config, extensions3, logger2, notificationManager) {
if (_isUnloading) {
throwError(strSdkUnloadingError);
}
if (_self[_DYN_IS_INITIALIZED]()) {
throwError("Core cannot be initialized more than once");
}
_configHandler = createDynamicConfig(config, defaultConfig$1, logger2 || _self[_DYN_LOGGER], false);
config = _configHandler.cfg;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var rootCfg = details.cfg;
_initInMemoMaxSize = rootCfg.initInMemoMaxSize || maxInitQueueSize;
_handleIKeyEndpointPromises(rootCfg);
var extCfg = details.ref(details.cfg, STR_EXTENSION_CONFIG);
objForEachKey(extCfg, function(key) {
details.ref(extCfg, key);
});
}));
_notificationManager = notificationManager;
_debugListener2 = _initDebugListener(_configHandler, _hookContainer, _notificationManager && _self[_DYN_GET_NOTIFY_MGR](), _debugListener2);
_initPerfManager();
_self[_DYN_LOGGER] = logger2;
var cfgExtensions = config[STR_EXTENSIONS];
_configExtensions = [];
_configExtensions[_DYN_PUSH].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions3, false), cfgExtensions));
_channelConfig = config[STR_CHANNELS];
_initPluginChain(null);
if (!_channels || _channels[_DYN_LENGTH$1] === 0) {
throwError("No " + STR_CHANNELS + " available");
}
if (_channelConfig && _channelConfig[_DYN_LENGTH$1] > 1) {
var teeController = _self[_DYN_GET_PLUGIN]("TeeChannelController");
if (!teeController || !teeController.plugin) {
_throwInternal(_logger, 1, 28, "TeeChannel required");
}
}
_registerDelayedCfgListener(config, _cfgListeners, _logger);
_cfgListeners = null;
_isInitialized = true;
if (_activeStatus === ActiveStatus.ACTIVE) {
_releaseQueues();
}
};
_self.getChannels = function() {
var controls = [];
if (_channels) {
arrForEach(_channels, function(channel) {
controls[_DYN_PUSH](channel);
});
}
return objFreeze(controls);
};
_self.track = function(telemetryItem) {
doPerf(_self[STR_GET_PERF_MGR](), function() {
return "AppInsightsCore:track";
}, function() {
if (telemetryItem === null) {
_notifyInvalidEvent(telemetryItem);
throwError("Invalid telemetry item");
}
if (!telemetryItem[_DYN_NAME] && /* @__PURE__ */ isNullOrUndefined(telemetryItem[_DYN_NAME])) {
_notifyInvalidEvent(telemetryItem);
throwError("telemetry name required");
}
telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;
telemetryItem.time = telemetryItem.time || toISOString(/* @__PURE__ */ new Date());
telemetryItem.ver = telemetryItem.ver || "4.0";
if (!_isUnloading && _self[_DYN_IS_INITIALIZED]() && _activeStatus === ActiveStatus.ACTIVE) {
_createTelCtx()[_DYN_PROCESS_NEXT](telemetryItem);
} else if (_activeStatus !== ActiveStatus.INACTIVE) {
if (_eventQueue[_DYN_LENGTH$1] <= _initInMemoMaxSize) {
_eventQueue[_DYN_PUSH](telemetryItem);
}
}
}, function() {
return { item: telemetryItem };
}, !telemetryItem.sync);
};
_self[_DYN_GET_PROCESS_TEL_CONT2] = _createTelCtx;
_self[_DYN_GET_NOTIFY_MGR] = function() {
if (!_notificationManager) {
_notificationManager = new NotificationManager(_configHandler.cfg);
_self[strNotificationManager] = _notificationManager;
}
return _notificationManager;
};
_self[_DYN_ADD_NOTIFICATION_LIS1] = function(listener) {
_self.getNotifyMgr()[_DYN_ADD_NOTIFICATION_LIS1](listener);
};
_self[_DYN_REMOVE_NOTIFICATION_0] = function(listener) {
if (_notificationManager) {
_notificationManager[_DYN_REMOVE_NOTIFICATION_0](listener);
}
};
_self.getCookieMgr = function() {
if (!_cookieManager) {
_cookieManager = createCookieMgr(_configHandler.cfg, _self[_DYN_LOGGER]);
}
return _cookieManager;
};
_self.setCookieMgr = function(cookieMgr) {
if (_cookieManager !== cookieMgr) {
runTargetUnload(_cookieManager, false);
_cookieManager = cookieMgr;
}
};
_self[STR_GET_PERF_MGR] = function() {
return _perfManager || _cfgPerfManager || getGblPerfMgr();
};
_self.setPerfMgr = function(perfMgr) {
_perfManager = perfMgr;
};
_self.eventCnt = function() {
return _eventQueue[_DYN_LENGTH$1];
};
_self.releaseQueue = function() {
if (_isInitialized && _eventQueue[_DYN_LENGTH$1] > 0) {
var eventQueue = _eventQueue;
_eventQueue = [];
if (_activeStatus === 2) {
arrForEach(eventQueue, function(event) {
event.iKey = event.iKey || _instrumentationKey;
_createTelCtx()[_DYN_PROCESS_NEXT](event);
});
} else {
_throwInternal(_logger, 2, 20, "core init status is not active");
}
}
};
_self.pollInternalLogs = function(eventName) {
_internalLogsEventName = eventName || null;
_forceStopInternalLogPoller = false;
_internalLogPoller && _internalLogPoller[_DYN_CANCEL]();
return _startLogPoller(true);
};
function _handleIKeyEndpointPromises(theConfig) {
var ikey = theConfig.instrumentationKey;
var endpointUrl = theConfig.endpointUrl;
if (_activeStatus !== 3) {
if (/* @__PURE__ */ isNullOrUndefined(ikey)) {
_instrumentationKey = null;
_activeStatus = ActiveStatus.INACTIVE;
var msg = "Please provide instrumentation key";
if (!_isInitialized) {
throwError(msg);
} else {
_throwInternal(_logger, 1, 100, msg);
_releaseQueues();
}
return;
}
var promises = [];
if (/* @__PURE__ */ isPromiseLike(ikey)) {
promises[_DYN_PUSH](ikey);
_instrumentationKey = null;
} else {
_instrumentationKey = ikey;
}
if (/* @__PURE__ */ isPromiseLike(endpointUrl)) {
promises[_DYN_PUSH](endpointUrl);
_endpoint = null;
} else {
_endpoint = endpointUrl;
}
if (promises[_DYN_LENGTH$1]) {
_waitForInitPromises(theConfig, promises);
} else {
_setStatus();
}
}
}
function _waitForInitPromises(theConfig, promises) {
_isStatusSet = false;
_activeStatus = 3;
var initTimeout = isNotNullOrUndefined(theConfig.initTimeOut) ? theConfig.initTimeOut : maxInitTimeout;
var allPromises = createSyncAllSettledPromise(promises);
if (_initTimer) {
_initTimer[_DYN_CANCEL]();
}
_initTimer = scheduleTimeout(function() {
_initTimer = null;
if (!_isStatusSet) {
_setStatus();
}
}, initTimeout);
doAwaitResponse(allPromises, function(response) {
try {
if (_isStatusSet) {
return;
}
if (!response.rejected) {
var values = response[_DYN_VALUE$1];
if (values && values[_DYN_LENGTH$1]) {
var ikeyRes = values[0];
_instrumentationKey = ikeyRes && ikeyRes[_DYN_VALUE$1];
if (values[_DYN_LENGTH$1] > 1) {
var endpointRes = values[1];
_endpoint = endpointRes && endpointRes[_DYN_VALUE$1];
}
}
if (_instrumentationKey) {
theConfig.instrumentationKey = _instrumentationKey;
theConfig.endpointUrl = _endpoint;
}
}
_setStatus();
} catch (e) {
if (!_isStatusSet) {
_setStatus();
}
}
});
}
function _setStatus() {
_isStatusSet = true;
if (/* @__PURE__ */ isNullOrUndefined(_instrumentationKey)) {
_activeStatus = ActiveStatus.INACTIVE;
_throwInternal(_logger, 1, 112, "ikey can't be resolved from promises");
} else {
_activeStatus = ActiveStatus.ACTIVE;
}
_releaseQueues();
}
function _releaseQueues() {
if (_isInitialized) {
_self.releaseQueue();
_self.pollInternalLogs();
}
}
function _startLogPoller(alwaysStart) {
if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED]) && !_forceStopInternalLogPoller) {
var shouldStart = alwaysStart || _logger && _logger.queue[_DYN_LENGTH$1] > 0;
if (shouldStart) {
if (!_internalLogPollerListening) {
_internalLogPollerListening = true;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var interval = details.cfg.diagnosticLogInterval;
if (!interval || !(interval > 0)) {
interval = 1e4;
}
var isRunning = false;
if (_internalLogPoller) {
isRunning = _internalLogPoller[_DYN_ENABLED];
_internalLogPoller[_DYN_CANCEL]();
}
_internalLogPoller = createTimeout(_flushInternalLogs, interval);
_internalLogPoller.unref();
_internalLogPoller[_DYN_ENABLED] = isRunning;
}));
}
_internalLogPoller[_DYN_ENABLED] = true;
}
}
return _internalLogPoller;
}
_self[_DYN_STOP_POLLING_INTERNA3] = function() {
_forceStopInternalLogPoller = true;
_internalLogPoller && _internalLogPoller[_DYN_CANCEL]();
_flushInternalLogs();
};
proxyFunctions(_self, function() {
return _telemetryInitializerPlugin;
}, ["addTelemetryInitializer"]);
_self[_DYN_UNLOAD] = function(isAsync, unloadComplete, cbTimeout) {
if (isAsync === void 0) {
isAsync = true;
}
if (!_isInitialized) {
throwError(strSdkNotInitialized);
}
if (_isUnloading) {
throwError(strSdkUnloadingError);
}
var unloadState = {
reason: 50,
isAsync,
flushComplete: false
};
var result;
if (isAsync && !unloadComplete) {
result = createPromise(function(resolve3) {
unloadComplete = resolve3;
});
}
var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
processUnloadCtx[_DYN_ON_COMPLETE](function() {
_hookContainer.run(_self[_DYN_LOGGER]);
doUnloadAll([_cookieManager, _notificationManager, _logger], isAsync, function() {
_initDefaults();
unloadComplete && unloadComplete(unloadState);
});
}, _self);
function _doUnload(flushComplete) {
unloadState.flushComplete = flushComplete;
_isUnloading = true;
_unloadHandlers.run(processUnloadCtx, unloadState);
_self[_DYN_STOP_POLLING_INTERNA3]();
processUnloadCtx[_DYN_PROCESS_NEXT](unloadState);
}
_flushInternalLogs();
if (!_flushChannels(isAsync, _doUnload, 6, cbTimeout)) ;
return result;
};
_self[_DYN_GET_PLUGIN] = _getPlugin;
_self.addPlugin = function(plugin, replaceExisting, isAsync, addCb) {
if (!plugin) {
addCb && addCb(false);
_logOrThrowError(strValidationError);
return;
}
var existingPlugin = _getPlugin(plugin[_DYN_IDENTIFIER]);
if (existingPlugin && !replaceExisting) {
addCb && addCb(false);
_logOrThrowError("Plugin [" + plugin[_DYN_IDENTIFIER] + "] is already loaded!");
return;
}
var updateState = {
reason: 16
};
function _addPlugin(removed) {
_configExtensions[_DYN_PUSH](plugin);
updateState.added = [plugin];
_initPluginChain(updateState);
addCb && addCb(true);
}
if (existingPlugin) {
var removedPlugins_1 = [existingPlugin.plugin];
var unloadState = {
reason: 2,
isAsync: !!isAsync
};
_removePlugins(removedPlugins_1, unloadState, function(removed) {
if (!removed) {
addCb && addCb(false);
} else {
updateState.removed = removedPlugins_1;
updateState.reason |= 32;
_addPlugin();
}
});
} else {
_addPlugin();
}
};
_self.updateCfg = function(newConfig, mergeExisting) {
if (mergeExisting === void 0) {
mergeExisting = true;
}
var updateState;
if (_self[_DYN_IS_INITIALIZED]()) {
updateState = {
reason: 1,
cfg: _configHandler.cfg,
oldCfg: deepExtend({}, _configHandler.cfg),
newConfig: deepExtend({}, newConfig),
merge: mergeExisting
};
newConfig = updateState.newConfig;
var cfg = _configHandler.cfg;
newConfig[STR_EXTENSIONS] = cfg[STR_EXTENSIONS];
newConfig[STR_CHANNELS] = cfg[STR_CHANNELS];
}
_configHandler._block(function(details) {
var theConfig = details.cfg;
_deepMergeConfig(details, theConfig, newConfig, mergeExisting);
if (!mergeExisting) {
objForEachKey(theConfig, function(key) {
if (!objHasOwn(newConfig, key)) {
details.set(theConfig, key, UNDEFINED_VALUE);
}
});
}
details.setDf(theConfig, defaultConfig$1);
}, true);
_configHandler.notify();
if (updateState) {
_doUpdate(updateState);
}
};
_self.evtNamespace = function() {
return _evtNamespace;
};
_self.flush = _flushChannels;
_self.getTraceCtx = function(createNew) {
if (!_traceCtx) {
_traceCtx = createDistributedTraceContext();
}
return _traceCtx;
};
_self.setTraceCtx = function(traceCtx) {
_traceCtx = traceCtx || null;
};
_self.addUnloadHook = _addUnloadHook;
proxyFunctionAs(_self, "addUnloadCb", function() {
return _unloadHandlers;
}, "add");
_self.onCfgChange = function(handler) {
var unloadHook;
if (!_isInitialized) {
unloadHook = _addDelayedCfgListener(_cfgListeners, handler);
} else {
unloadHook = onConfigChange(_configHandler.cfg, handler, _self[_DYN_LOGGER]);
}
return _createUnloadHook(unloadHook);
};
_self.getWParam = function() {
return /* @__PURE__ */ hasDocument() || !!_configHandler.cfg.enableWParam ? 0 : -1;
};
function _setPluginVersions() {
var thePlugins = {};
_pluginVersionStringArr = [];
var _addPluginVersions = function(plugins) {
if (plugins) {
arrForEach(plugins, function(plugin) {
if (plugin[_DYN_IDENTIFIER] && plugin[_DYN_VERSION] && !thePlugins[plugin.identifier]) {
var ver = plugin[_DYN_IDENTIFIER] + "=" + plugin[_DYN_VERSION];
_pluginVersionStringArr[_DYN_PUSH](ver);
thePlugins[plugin.identifier] = plugin;
}
});
}
};
_addPluginVersions(_channels);
if (_channelConfig) {
arrForEach(_channelConfig, function(channels) {
_addPluginVersions(channels);
});
}
_addPluginVersions(_configExtensions);
}
function _initDefaults() {
_isInitialized = false;
_configHandler = createDynamicConfig({}, defaultConfig$1, _self[_DYN_LOGGER]);
_configHandler.cfg[_DYN_LOGGING_LEVEL_CONSOL4] = 1;
objDefine(_self, "config", {
g: function() {
return _configHandler.cfg;
},
s: function(newValue) {
_self.updateCfg(newValue, false);
}
});
objDefine(_self, "pluginVersionStringArr", {
g: function() {
if (!_pluginVersionStringArr) {
_setPluginVersions();
}
return _pluginVersionStringArr;
}
});
objDefine(_self, "pluginVersionString", {
g: function() {
if (!_pluginVersionString) {
if (!_pluginVersionStringArr) {
_setPluginVersions();
}
_pluginVersionString = _pluginVersionStringArr.join(";");
}
return _pluginVersionString || STR_EMPTY$2;
}
});
objDefine(_self, "logger", {
g: function() {
if (!_logger) {
_logger = new DiagnosticLogger(_configHandler.cfg);
_configHandler[_DYN_LOGGER] = _logger;
}
return _logger;
},
s: function(newLogger) {
_configHandler[_DYN_LOGGER] = newLogger;
if (_logger !== newLogger) {
runTargetUnload(_logger, false);
_logger = newLogger;
}
}
});
_self[_DYN_LOGGER] = new DiagnosticLogger(_configHandler.cfg);
_extensions = [];
var cfgExtensions = _self.config[STR_EXTENSIONS] || [];
cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH$1]);
arrAppend(cfgExtensions, _extensions);
_telemetryInitializerPlugin = new TelemetryInitializerPlugin();
_eventQueue = [];
runTargetUnload(_notificationManager, false);
_notificationManager = null;
_perfManager = null;
_cfgPerfManager = null;
runTargetUnload(_cookieManager, false);
_cookieManager = null;
_pluginChain = null;
_configExtensions = [];
_channelConfig = null;
_channels = null;
_isUnloading = false;
_internalLogsEventName = null;
_evtNamespace = createUniqueNamespace("AIBaseCore", true);
_unloadHandlers = createUnloadHandlerContainer();
_traceCtx = null;
_instrumentationKey = null;
_hookContainer = createUnloadHookContainer();
_cfgListeners = [];
_pluginVersionString = null;
_pluginVersionStringArr = null;
_forceStopInternalLogPoller = false;
_internalLogPoller = null;
_internalLogPollerListening = false;
_activeStatus = 0;
_endpoint = null;
_initInMemoMaxSize = null;
_isStatusSet = false;
_initTimer = null;
}
function _createTelCtx() {
var theCtx = createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
theCtx[_DYN_ON_COMPLETE](_startLogPoller);
return theCtx;
}
function _initPluginChain(updateState) {
var theExtensions = _validateExtensions(_self[_DYN_LOGGER], ChannelControllerPriority, _configExtensions);
_pluginChain = null;
_pluginVersionString = null;
_pluginVersionStringArr = null;
_channels = (_channelConfig || [])[0] || [];
_channels = sortPlugins(arrAppend(_channels, theExtensions[STR_CHANNELS]));
var allExtensions = arrAppend(sortPlugins(theExtensions[STR_CORE]), _channels);
_extensions = objFreeze(allExtensions);
var cfgExtensions = _self.config[STR_EXTENSIONS] || [];
cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH$1]);
arrAppend(cfgExtensions, _extensions);
var rootCtx = _createTelCtx();
if (_channels && _channels[_DYN_LENGTH$1] > 0) {
initializePlugins(rootCtx[_DYN_CREATE_NEW](_channels), allExtensions);
}
initializePlugins(rootCtx, allExtensions);
if (updateState) {
_doUpdate(updateState);
}
}
function _getPlugin(pluginIdentifier) {
var theExt = null;
var thePlugin = null;
var channelHosts = [];
arrForEach(_extensions, function(ext) {
if (ext[_DYN_IDENTIFIER] === pluginIdentifier && ext !== _telemetryInitializerPlugin) {
thePlugin = ext;
return -1;
}
if (ext.getChannel) {
channelHosts[_DYN_PUSH](ext);
}
});
if (!thePlugin && channelHosts[_DYN_LENGTH$1] > 0) {
arrForEach(channelHosts, function(host) {
thePlugin = host.getChannel(pluginIdentifier);
if (!thePlugin) {
return -1;
}
});
}
if (thePlugin) {
theExt = {
plugin: thePlugin,
setEnabled: function(enabled) {
_getPluginState(thePlugin)[STR_DISABLED] = !enabled;
},
isEnabled: function() {
var pluginState = _getPluginState(thePlugin);
return !pluginState[_DYN_TEARDOWN] && !pluginState[STR_DISABLED];
},
remove: function(isAsync, removeCb) {
if (isAsync === void 0) {
isAsync = true;
}
var pluginsToRemove = [thePlugin];
var unloadState = {
reason: 1,
isAsync
};
_removePlugins(pluginsToRemove, unloadState, function(removed) {
if (removed) {
_initPluginChain({
reason: 32,
removed: pluginsToRemove
});
}
removeCb && removeCb(removed);
});
}
};
}
return theExt;
}
function _getPluginChain() {
if (!_pluginChain) {
var extensions3 = (_extensions || []).slice();
if (arrIndexOf(extensions3, _telemetryInitializerPlugin) === -1) {
extensions3[_DYN_PUSH](_telemetryInitializerPlugin);
}
_pluginChain = createTelemetryProxyChain(sortPlugins(extensions3), _configHandler.cfg, _self);
}
return _pluginChain;
}
function _removePlugins(thePlugins, unloadState, removeComplete) {
if (thePlugins && thePlugins[_DYN_LENGTH$1] > 0) {
var unloadChain = createTelemetryProxyChain(thePlugins, _configHandler.cfg, _self);
var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);
unloadCtx[_DYN_ON_COMPLETE](function() {
var removed = false;
var newConfigExtensions = [];
arrForEach(_configExtensions, function(plugin, idx) {
if (!_isPluginPresent(plugin, thePlugins)) {
newConfigExtensions[_DYN_PUSH](plugin);
} else {
removed = true;
}
});
_configExtensions = newConfigExtensions;
_pluginVersionString = null;
_pluginVersionStringArr = null;
var newChannelConfig = [];
if (_channelConfig) {
arrForEach(_channelConfig, function(queue, idx) {
var newQueue = [];
arrForEach(queue, function(channel) {
if (!_isPluginPresent(channel, thePlugins)) {
newQueue[_DYN_PUSH](channel);
} else {
removed = true;
}
});
newChannelConfig[_DYN_PUSH](newQueue);
});
_channelConfig = newChannelConfig;
}
removeComplete && removeComplete(removed);
_startLogPoller();
});
unloadCtx[_DYN_PROCESS_NEXT](unloadState);
} else {
removeComplete(false);
}
}
function _flushInternalLogs() {
if (_logger && _logger.queue) {
var queue = _logger.queue.slice(0);
_logger.queue[_DYN_LENGTH$1] = 0;
arrForEach(queue, function(logMessage) {
var item = {
name: _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID],
iKey: _instrumentationKey,
time: toISOString(/* @__PURE__ */ new Date()),
baseType: _InternalLogMessage.dataType,
baseData: { message: logMessage[_DYN_MESSAGE] }
};
_self.track(item);
});
}
}
function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
var waiting = 1;
var doneIterating = false;
var cbTimer = null;
cbTimeout = cbTimeout || 5e3;
function doCallback() {
waiting--;
if (doneIterating && waiting === 0) {
cbTimer && cbTimer[_DYN_CANCEL]();
cbTimer = null;
callBack && callBack(doneIterating);
callBack = null;
}
}
if (_channels && _channels[_DYN_LENGTH$1] > 0) {
var flushCtx = _createTelCtx()[_DYN_CREATE_NEW](_channels);
flushCtx.iterate(function(plugin) {
if (plugin.flush) {
waiting++;
var handled_1 = false;
if (!plugin.flush(isAsync, function() {
handled_1 = true;
doCallback();
}, sendReason)) {
if (!handled_1) {
if (isAsync && cbTimer == null) {
cbTimer = scheduleTimeout(function() {
cbTimer = null;
doCallback();
}, cbTimeout);
} else {
doCallback();
}
}
}
}
});
}
doneIterating = true;
doCallback();
return true;
}
function _initPerfManager() {
var prevCfgPerfMgr;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var enablePerfMgr = details.cfg.enablePerfMgr;
if (enablePerfMgr) {
var createPerfMgr = details.cfg[STR_CREATE_PERF_MGR];
if (prevCfgPerfMgr !== createPerfMgr || !prevCfgPerfMgr) {
if (!createPerfMgr) {
createPerfMgr = _createPerfManager;
}
getSetValue(details.cfg, STR_CREATE_PERF_MGR, createPerfMgr);
prevCfgPerfMgr = createPerfMgr;
_cfgPerfManager = null;
}
if (!_perfManager && !_cfgPerfManager && isFunction(createPerfMgr)) {
_cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR]());
}
} else {
_cfgPerfManager = null;
prevCfgPerfMgr = null;
}
}));
}
function _doUpdate(updateState) {
var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);
updateCtx[_DYN_ON_COMPLETE](_startLogPoller);
if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
updateCtx[_DYN_PROCESS_NEXT](updateState);
}
}
function _logOrThrowError(message) {
var logger2 = _self[_DYN_LOGGER];
if (logger2) {
_throwInternal(logger2, 2, 73, message);
_startLogPoller();
} else {
throwError(message);
}
}
function _notifyInvalidEvent(telemetryItem) {
var manager = _self[_DYN_GET_NOTIFY_MGR]();
if (manager) {
manager[STR_EVENTS_DISCARDED]([telemetryItem], 2);
}
}
function _addUnloadHook(hooks) {
_hookContainer.add(hooks);
}
});
}
AppInsightsCore2.__ieDyn = 1;
return AppInsightsCore2;
})()
);
function parseResponse(response, diagLog) {
try {
if (response && response !== "") {
var result = getJSON().parse(response);
if (result && result[_DYN_ITEMS_RECEIVED] && result[_DYN_ITEMS_RECEIVED] >= result.itemsAccepted && result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH$1]) {
return result;
}
}
} catch (e) {
_throwInternal(diagLog, 1, 43, "Cannot parse the response. " + (e[_DYN_NAME] || /* @__PURE__ */ dumpObj(e)), {
response
});
}
return null;
}
var STR_EMPTY$1 = "";
var STR_NO_RESPONSE_BODY = "NoResponseBody";
var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
var STR_POST_METHOD = "POST";
var SenderPostManager = (
/** @class */
(function() {
function SenderPostManager2() {
var _syncFetchPayload = 0;
var _enableSendPromise;
var _isInitialized;
var _diagLog;
var _isOneDs;
var _onCompleteFuncs;
var _disableCredentials;
var _fetchCredentials;
var _fallbackInst;
var _disableXhr;
var _disableBeacon;
var _disableBeaconSync;
var _disableFetchKeepAlive;
var _addNoResponse;
var _timeoutWrapper;
dynamicProto(SenderPostManager2, this, function(_self, _base) {
var _sendCredentials = true;
_initDefaults();
_self[_DYN_INITIALIZE$1] = function(config, diagLog) {
_diagLog = diagLog;
if (_isInitialized) {
_throwInternal(_diagLog, 1, 28, "Sender is already initialized");
}
_self.SetConfig(config);
_isInitialized = true;
};
_self["_getDbgPlgTargets"] = function() {
return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
};
_self.SetConfig = function(config) {
try {
_onCompleteFuncs = config.senderOnCompleteCallBack || {};
_disableCredentials = !!config.disableCredentials;
_fetchCredentials = config.fetchCredentials;
_isOneDs = !!config.isOneDs;
_enableSendPromise = !!config.enableSendPromise;
_disableXhr = !!config.disableXhr;
_disableBeacon = !!config.disableBeacon;
_disableBeaconSync = !!config.disableBeaconSync;
_timeoutWrapper = config.timeWrapper;
_addNoResponse = !!config.addNoResponse;
_disableFetchKeepAlive = !!config.disableFetchKeepAlive;
_fallbackInst = { sendPOST: _xhrSender };
if (!_isOneDs) {
_sendCredentials = false;
}
if (_disableCredentials) {
var location_1 = getLocation();
if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE]() === "file:") {
_sendCredentials = false;
}
}
return true;
} catch (e) {
}
return false;
};
_self.getSyncFetchPayload = function() {
return _syncFetchPayload;
};
_self.getSenderInst = function(transports, sync) {
if (transports && transports[_DYN_LENGTH$1]) {
return _getSenderInterface(transports, sync);
}
return null;
};
_self.getFallbackInst = function() {
return _fallbackInst;
};
_self[_DYN__DO_TEARDOWN] = function(unloadCtx, unloadState) {
_initDefaults();
};
_self.preparePayload = function(callback, zipPayload, payload, isSync) {
if (!zipPayload || isSync || !payload[_DYN_DATA]) {
callback(payload);
return;
}
try {
var csStream = /* @__PURE__ */ getInst("CompressionStream");
if (!isFunction(csStream)) {
callback(payload);
return;
}
var body = new ReadableStream({
start: function(controller) {
controller.enqueue(isString(payload[_DYN_DATA]) ? new TextEncoder().encode(payload[_DYN_DATA]) : payload[_DYN_DATA]);
controller.close();
}
});
var compressedStream = body.pipeThrough(new csStream("gzip"));
var reader_1 = compressedStream.getReader();
var chunks_1 = [];
var totalLength_1 = 0;
var callbackCalled_1 = false;
doAwaitResponse(reader_1.read(), function processChunk(response) {
if (!callbackCalled_1 && !response.rejected) {
var result = response[_DYN_VALUE$1];
if (!result.done) {
chunks_1[_DYN_PUSH](result[_DYN_VALUE$1]);
totalLength_1 += result.value[_DYN_LENGTH$1];
return doAwaitResponse(reader_1.read(), processChunk);
}
var combined = new Uint8Array(totalLength_1);
var offset = 0;
for (var _i = 0, chunks_2 = chunks_1; _i < chunks_2.length; _i++) {
var chunk = chunks_2[_i];
combined.set(chunk, offset);
offset += chunk[_DYN_LENGTH$1];
}
payload[_DYN_DATA] = combined;
payload[_DYN_HEADERS]["Content-Encoding"] = "gzip";
payload._chunkCount = chunks_1[_DYN_LENGTH$1];
}
if (!callbackCalled_1) {
callbackCalled_1 = true;
callback(payload);
}
});
return reader_1;
} catch (error) {
callback(payload);
return;
}
};
function _onSuccess(res, onComplete) {
_doOnComplete(onComplete, 200, {}, res);
}
function _onError(message, onComplete) {
_throwInternal(_diagLog, 2, 26, "Failed to send telemetry.", { message });
_doOnComplete(onComplete, 400, {});
}
function _onNoPayloadUrl(onComplete) {
_onError("No endpoint url is provided for the batch", onComplete);
}
function _getSenderInterface(transports, syncSupport) {
var transportType = 0;
var sendPostFunc = null;
var lp = 0;
while (sendPostFunc == null && lp < transports[_DYN_LENGTH$1]) {
transportType = transports[lp];
if (!_disableXhr && transportType === 1) {
if (useXDomainRequest()) {
sendPostFunc = _xdrSender;
} else if (isXhrSupported()) {
sendPostFunc = _xhrSender;
}
} else if (transportType === 2 && isFetchSupported(syncSupport) && (!syncSupport || !_disableFetchKeepAlive)) {
sendPostFunc = _doFetchSender;
} else if (transportType === 3 && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
sendPostFunc = _beaconSender;
}
lp++;
}
if (sendPostFunc) {
return {
_transport: transportType,
_isSync: syncSupport,
sendPOST: sendPostFunc
};
}
return null;
}
function _doOnComplete(oncomplete, status, headers, response) {
try {
oncomplete && oncomplete(status, headers, response);
} catch (e) {
}
}
function _doBeaconSend(payload, oncomplete) {
var nav = getNavigator();
var url = payload[_DYN_URL_STRING];
if (!url) {
_onNoPayloadUrl(oncomplete);
return true;
}
url = payload[_DYN_URL_STRING] + (_addNoResponse ? _noResponseQs : STR_EMPTY$1);
var data = payload[_DYN_DATA];
var plainTextBatch = _isOneDs ? data : new Blob([data], { type: "text/plain;charset=UTF-8" });
var queued = nav.sendBeacon(url, plainTextBatch);
return queued;
}
function _beaconSender(payload, oncomplete, sync) {
var data = payload[_DYN_DATA];
try {
if (data) {
if (!_doBeaconSend(payload, oncomplete)) {
var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
if (onRetry && isFunction(onRetry)) {
onRetry(payload, oncomplete, _doBeaconSend);
} else {
_fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
_throwInternal(_diagLog, 2, 40, ". Failed to send telemetry with Beacon API, retried with normal sender.");
}
} else {
_onSuccess(STR_EMPTY$1, oncomplete);
}
}
} catch (e) {
_isOneDs && _warnToConsole(_diagLog, "Failed to send telemetry using sendBeacon API. Ex:" + /* @__PURE__ */ dumpObj(e));
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, STR_EMPTY$1);
}
return;
}
function _xhrSender(payload, oncomplete, sync) {
var thePromise;
var resolveFunc;
var rejectFunc;
var headers = payload[_DYN_HEADERS] || {};
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (_isOneDs && sync && payload.disableXhrSync) {
sync = false;
}
var endPointUrl = payload[_DYN_URL_STRING];
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
var xhr = openXhr$1(STR_POST_METHOD, endPointUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT]);
if (!_isOneDs) {
xhr.setRequestHeader("Content-type", "application/json");
}
arrForEach(objKeys(headers), function(headerName) {
xhr.setRequestHeader(headerName, headers[headerName]);
});
xhr.onreadystatechange = function() {
if (!_isOneDs) {
_doOnReadyFunc(xhr);
if (xhr.readyState === 4) {
resolveFunc && resolveFunc(true);
}
}
};
xhr.onload = function() {
if (_isOneDs) {
_doOnReadyFunc(xhr);
}
};
function _doOnReadyFunc(xhr2) {
var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
if (onReadyFuncExist) {
onReadyFunc(xhr2, oncomplete, payload);
} else {
var response = getResponseText(xhr2);
_doOnComplete(oncomplete, xhr2[_DYN_STATUS], _getAllResponseHeaders(xhr2, _isOneDs), response);
}
}
xhr.onerror = function(event) {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 400, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$1 : formatErrorMessageXhr(xhr));
rejectFunc && rejectFunc(event);
};
xhr.ontimeout = function() {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 500, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$1 : formatErrorMessageXhr(xhr));
resolveFunc && resolveFunc(false);
};
xhr.send(payload[_DYN_DATA]);
return thePromise;
}
function _doFetchSender(payload, oncomplete, sync) {
var _a2;
var endPointUrl = payload[_DYN_URL_STRING];
var batch = payload[_DYN_DATA];
var plainTextBatch = _isOneDs ? batch : new Blob([batch], { type: "application/json" });
var thePromise;
var resolveFunc;
var rejectFunc;
var requestHeaders = new Headers();
var batchLength = batch[_DYN_LENGTH$1];
var ignoreResponse = false;
var responseHandled = false;
var headers = payload[_DYN_HEADERS] || {};
var init = (_a2 = {
method: STR_POST_METHOD,
body: plainTextBatch
}, _a2[DisabledPropertyName] = true, _a2);
if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH$1] > 0) {
arrForEach(objKeys(headers), function(headerName) {
requestHeaders.append(headerName, headers[headerName]);
});
init[_DYN_HEADERS] = requestHeaders;
}
if (_fetchCredentials) {
init.credentials = _fetchCredentials;
} else if (_sendCredentials && _isOneDs) {
init.credentials = "include";
}
if (sync) {
init.keepalive = true;
_syncFetchPayload += batchLength;
if (_isOneDs) {
if (payload["_sendReason"] === 2) {
ignoreResponse = true;
if (_addNoResponse) {
endPointUrl += _noResponseQs;
}
}
} else {
ignoreResponse = true;
}
}
var request = new Request(endPointUrl, init);
try {
request[DisabledPropertyName] = true;
} catch (e) {
}
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
function _handleError(res, statusCode) {
if (statusCode) {
_doOnComplete(oncomplete, _isOneDs ? 0 : statusCode, {}, _isOneDs ? STR_EMPTY$1 : res);
} else {
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, _isOneDs ? STR_EMPTY$1 : res);
}
}
function _onFetchComplete(response, payload2, value) {
var status = response[_DYN_STATUS];
var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
if (onCompleteFunc && isFunction(onCompleteFunc)) {
onCompleteFunc(response, oncomplete, value || STR_EMPTY$1, payload2);
} else {
_doOnComplete(oncomplete, status, {}, value || STR_EMPTY$1);
}
}
try {
doAwaitResponse(fetch(_isOneDs ? endPointUrl : request, _isOneDs ? init : null), function(result) {
if (sync) {
_syncFetchPayload -= batchLength;
batchLength = 0;
}
if (!responseHandled) {
responseHandled = true;
if (!result.rejected) {
var response_1 = result[_DYN_VALUE$1];
try {
if (!_isOneDs && !response_1.ok) {
if (response_1[_DYN_STATUS]) {
_handleError(response_1.statusText, response_1[_DYN_STATUS]);
} else {
_handleError(response_1.statusText, 499);
}
resolveFunc && resolveFunc(false);
} else {
if (_isOneDs && !response_1.body) {
_onFetchComplete(response_1, null, STR_EMPTY$1);
resolveFunc && resolveFunc(true);
} else {
doAwaitResponse(response_1.text(), function(resp) {
_onFetchComplete(response_1, payload, resp[_DYN_VALUE$1]);
resolveFunc && resolveFunc(true);
});
}
}
} catch (e) {
if (response_1 && response_1[_DYN_STATUS]) {
_handleError(/* @__PURE__ */ dumpObj(e), response_1[_DYN_STATUS]);
} else {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
}
rejectFunc && rejectFunc(e);
}
} else {
_handleError(result.reason && result.reason[_DYN_MESSAGE], 499);
rejectFunc && rejectFunc(result.reason);
}
}
});
} catch (e) {
if (!responseHandled) {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
rejectFunc && rejectFunc(e);
}
}
if (ignoreResponse && !responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 200, {});
resolveFunc && resolveFunc(true);
}
if (_isOneDs && !responseHandled && payload[_DYN_TIMEOUT] > 0) {
_timeoutWrapper && _timeoutWrapper.set(function() {
if (!responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 500, {});
resolveFunc && resolveFunc(true);
}
}, payload[_DYN_TIMEOUT]);
}
return thePromise;
}
function _xdrSender(payload, oncomplete, sync) {
var _window = getWindow();
var xdr = new XDomainRequest();
var data = payload[_DYN_DATA];
xdr.onload = function() {
var response = getResponseText(xdr);
var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
if (onloadFunc && isFunction(onloadFunc)) {
onloadFunc(xdr, oncomplete, payload);
} else {
_doOnComplete(oncomplete, 200, {}, response);
}
};
xdr.onerror = function() {
_doOnComplete(oncomplete, 400, {}, _isOneDs ? STR_EMPTY$1 : formatErrorMessageXdr(xdr));
};
xdr.ontimeout = function() {
_doOnComplete(oncomplete, 500, {});
};
xdr.onprogress = function() {
};
var hostingProtocol = _window && _window.location && _window.location.protocol || "";
var endpoint = payload[_DYN_URL_STRING];
if (!endpoint) {
_onNoPayloadUrl(oncomplete);
return;
}
if (!_isOneDs && endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
_throwInternal(_diagLog, 2, 40, ". " + msg);
_onError(msg, oncomplete);
return;
}
var endpointUrl = _isOneDs ? endpoint : endpoint[_DYN_REPLACE](/^(https?:)/, "");
xdr.open(STR_POST_METHOD, endpointUrl);
if (payload[_DYN_TIMEOUT]) {
xdr[_DYN_TIMEOUT] = payload[_DYN_TIMEOUT];
}
xdr.send(data);
if (_isOneDs && sync) {
_timeoutWrapper && _timeoutWrapper.set(function() {
xdr.send(data);
}, 0);
} else {
xdr.send(data);
}
}
function _initDefaults() {
_syncFetchPayload = 0;
_isInitialized = false;
_enableSendPromise = false;
_diagLog = null;
_isOneDs = null;
_onCompleteFuncs = null;
_disableCredentials = null;
_fetchCredentials = null;
_fallbackInst = null;
_disableXhr = false;
_disableBeacon = false;
_disableBeaconSync = false;
_disableFetchKeepAlive = false;
_addNoResponse = false;
_timeoutWrapper = null;
}
});
}
SenderPostManager2.__ieDyn = 1;
return SenderPostManager2;
})()
);
var strOnPrefix = "on";
var strAttachEvent = "attachEvent";
var strAddEventHelper = "addEventListener";
var strDetachEvent = "detachEvent";
var strRemoveEventListener = "removeEventListener";
var strEvents = "events";
var strVisibilityChangeEvt = "visibilitychange";
var strPageHide = "pagehide";
var strPageShow = "pageshow";
var strUnload = "unload";
var strBeforeUnload = "beforeunload";
var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
var rRemoveEmptyNs = /\.[\.]+/g;
var rRemoveTrailingEmptyNs = /[\.]+$/;
var _guid = 1;
var elmNodeData = createElmNodeData("events");
var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
function _normalizeNamespace(name) {
if (name && name[_DYN_REPLACE]) {
return name[_DYN_REPLACE](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$2);
}
return name;
}
function _getEvtNamespace(eventName, evtNamespace) {
if (evtNamespace) {
var theNamespace_1 = STR_EMPTY$2;
if (isArray(evtNamespace)) {
theNamespace_1 = STR_EMPTY$2;
arrForEach(evtNamespace, function(name) {
name = _normalizeNamespace(name);
if (name) {
if (name[0] !== ".") {
name = "." + name;
}
theNamespace_1 += name;
}
});
} else {
theNamespace_1 = _normalizeNamespace(evtNamespace);
}
if (theNamespace_1) {
if (theNamespace_1[0] !== ".") {
theNamespace_1 = "." + theNamespace_1;
}
eventName = (eventName || STR_EMPTY$2) + theNamespace_1;
}
}
var parsedEvent = eventNamespace.exec(eventName || STR_EMPTY$2) || [];
return {
type: parsedEvent[1],
ns: (parsedEvent[2] || STR_EMPTY$2).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$2)[_DYN_SPLIT](".").sort().join(".")
};
}
function __getRegisteredEvents(target, eventName, evtNamespace) {
var theEvents = [];
var eventCache = elmNodeData.get(target, strEvents, {}, false);
var evtName = _getEvtNamespace(eventName, evtNamespace);
objForEachKey(eventCache, function(evtType, registeredEvents) {
arrForEach(registeredEvents, function(value) {
if (!evtName[_DYN_TYPE] || evtName[_DYN_TYPE] === value[_DYN_EVT_NAME][_DYN_TYPE]) {
if (!evtName.ns || evtName.ns === evtName.ns) {
theEvents[_DYN_PUSH]({
name: value.evtName[_DYN_TYPE] + (value[_DYN_EVT_NAME].ns ? "." + value[_DYN_EVT_NAME].ns : STR_EMPTY$2),
handler: value.handler
});
}
}
});
});
return theEvents;
}
function _getRegisteredEvents(target, evtName, addDefault) {
if (addDefault === void 0) {
addDefault = true;
}
var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
var registeredEvents = aiEvts[evtName];
if (!registeredEvents) {
registeredEvents = aiEvts[evtName] = [];
}
return registeredEvents;
}
function _doDetach(obj, evtName, handlerRef, useCapture) {
if (obj && evtName && evtName[_DYN_TYPE]) {
if (obj[strRemoveEventListener]) {
obj[strRemoveEventListener](evtName[_DYN_TYPE], handlerRef, useCapture);
} else if (obj[strDetachEvent]) {
obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
}
}
}
function _doAttach(obj, evtName, handlerRef, useCapture) {
var result = false;
if (obj && evtName && evtName[_DYN_TYPE] && handlerRef) {
if (obj[strAddEventHelper]) {
obj[strAddEventHelper](evtName[_DYN_TYPE], handlerRef, useCapture);
result = true;
} else if (obj[strAttachEvent]) {
obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
result = true;
}
}
return result;
}
function _doUnregister(target, events, evtName, unRegFn) {
var idx = events[_DYN_LENGTH$1];
while (idx--) {
var theEvent = events[idx];
if (theEvent) {
if (!evtName.ns || evtName.ns === theEvent[_DYN_EVT_NAME].ns) {
if (!unRegFn || unRegFn(theEvent)) {
_doDetach(target, theEvent[_DYN_EVT_NAME], theEvent.handler, theEvent.capture);
events[_DYN_SPLICE](idx, 1);
}
}
}
}
}
function _unregisterEvents(target, evtName, unRegFn) {
if (evtName[_DYN_TYPE]) {
_doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE]), evtName, unRegFn);
} else {
var eventCache = elmNodeData.get(target, strEvents, {});
objForEachKey(eventCache, function(evtType, events) {
_doUnregister(target, events, evtName, unRegFn);
});
if (objKeys(eventCache)[_DYN_LENGTH$1] === 0) {
elmNodeData.kill(target, strEvents);
}
}
}
function mergeEvtNamespace(theNamespace, namespaces) {
var newNamespaces;
if (namespaces) {
if (isArray(namespaces)) {
newNamespaces = [theNamespace].concat(namespaces);
} else {
newNamespaces = [theNamespace, namespaces];
}
newNamespaces = _getEvtNamespace("xx", newNamespaces).ns[_DYN_SPLIT](".");
} else {
newNamespaces = theNamespace;
}
return newNamespaces;
}
function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
var result = false;
if (target) {
try {
var evtName = _getEvtNamespace(eventName, evtNamespace);
result = _doAttach(target, evtName, handlerRef, useCapture);
if (result && elmNodeData.accept(target)) {
var registeredEvent = {
guid: _guid++,
evtName,
handler: handlerRef,
capture: useCapture
};
_getRegisteredEvents(target, evtName.type)[_DYN_PUSH](registeredEvent);
}
} catch (e) {
}
}
return result;
}
function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
if (target) {
try {
var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
var found_1 = false;
_unregisterEvents(target, evtName_1, function(regEvent) {
if (evtName_1.ns && !handlerRef || regEvent.handler === handlerRef) {
found_1 = true;
return true;
}
return false;
});
if (!found_1) {
_doDetach(target, evtName_1, handlerRef, useCapture);
}
} catch (e) {
}
}
}
function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
}
function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);
}
function addEventHandler(eventName, callback, evtNamespace) {
var result = false;
var w = getWindow();
if (w) {
result = eventOn(w, eventName, callback, evtNamespace);
result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
}
var doc = getDocument();
if (doc) {
result = eventOn(doc, eventName, callback, evtNamespace) || result;
}
return result;
}
function removeEventHandler(eventName, callback, evtNamespace) {
var w = getWindow();
if (w) {
eventOff(w, eventName, callback, evtNamespace);
eventOff(w["body"], eventName, callback, evtNamespace);
}
var doc = getDocument();
if (doc) {
eventOff(doc, eventName, callback, evtNamespace);
}
}
function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
var added = false;
if (listener && events && events[_DYN_LENGTH$1] > 0) {
arrForEach(events, function(name) {
if (name) {
if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
added = addEventHandler(name, listener, evtNamespace) || added;
}
}
});
}
return added;
}
function addEventListeners(events, listener, excludeEvents, evtNamespace) {
var added = false;
if (listener && events && isArray(events)) {
added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
if (!added && excludeEvents && excludeEvents[_DYN_LENGTH$1] > 0) {
added = _addEventListeners(events, listener, null, evtNamespace);
}
}
return added;
}
function removeEventListeners(events, listener, evtNamespace) {
if (events && isArray(events)) {
arrForEach(events, function(name) {
if (name) {
removeEventHandler(name, listener, evtNamespace);
}
});
}
}
function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
}
function removePageUnloadEventListener(listener, evtNamespace) {
removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
}
function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
function _handlePageVisibility(evt) {
var doc = getDocument();
if (listener && doc && doc.visibilityState === "hidden") {
listener(evt);
}
}
var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
}
if (!pageUnloadAdded && excludeEvents) {
pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
}
return pageUnloadAdded;
}
function removePageHideEventListener(listener, evtNamespace) {
var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
removeEventListeners([strPageHide], listener, newNamespaces);
removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
}
function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
function _handlePageVisibility(evt) {
var doc = getDocument();
if (listener && doc && doc.visibilityState === "visible") {
listener(evt);
}
}
var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
if (!pageShowAdded && excludeEvents) {
pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
}
return pageShowAdded;
}
function removePageShowEventListener(listener, evtNamespace) {
var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
removeEventListeners([strPageShow], listener, newNamespaces);
removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
}
var LoggingSeverity = /* @__PURE__ */ createEnumStyle({
DISABLED: 0,
CRITICAL: 1,
WARNING: 2,
DEBUG: 3
});
var STR_EMPTY = "";
var STR_DEFAULT_ENDPOINT_URL = "https://browser.events.data.microsoft.com/OneCollector/1.0/";
var STR_VERSION = "version";
var STR_PROPERTIES = "properties";
var _DYN_INITIALIZE = "initialize";
var _DYN_INDEX_OF = "indexOf";
var _DYN_TIMINGS = "timings";
var _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
var _DYN_VALUE = "value";
var _DYN_LENGTH = "length";
var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
var _DYN_HANDLE_FIELD = "handleField";
var _DYN_RM_SANITIZER = "rmSanitizer";
var _DYN_RM_FIELD_SANITIZER = "rmFieldSanitizer";
var _DYN_CAN_HANDLE = "canHandle";
var _a;
var Version = "4.3.10";
var FullVersionString = "1DS-Web-JS-" + Version;
var ObjHasOwnProperty = ObjProto$1.hasOwnProperty;
var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var strWithCredentials = "withCredentials";
var strTimeout = "timeout";
var _fieldTypeEventPropMap = (_a = {}, _a[0] = 0, _a[2] = 6, _a[1] = 1, _a[3] = 7, _a[4096 | 2] = 6, _a[4096 | 1] = 1, _a[4096 | 3] = 7, _a);
var uInt8ArraySupported = null;
var isDocumentObjectAvailable = /* @__PURE__ */ hasDocument();
var isWindowObjectAvailable = /* @__PURE__ */ hasWindow();
function isValueAssigned(value) {
return !(value === STR_EMPTY || /* @__PURE__ */ isNullOrUndefined(value));
}
function getTenantId(apiKey) {
if (apiKey) {
var indexTenantId = strIndexOf(apiKey, "-");
if (indexTenantId > -1) {
return /* @__PURE__ */ strLeft(apiKey, indexTenantId);
}
}
return STR_EMPTY;
}
function isUint8ArrayAvailable() {
if (uInt8ArraySupported === null) {
uInt8ArraySupported = !/* @__PURE__ */ isUndefined(Uint8Array) && !isSafariOrFirefox() && !isReactNative();
}
return uInt8ArraySupported;
}
function isLatency(value) {
if (value && isNumber(value) && value >= 1 && value <= 4) {
return true;
}
return false;
}
function sanitizeProperty(name, property, stringifyObjects) {
if (!property && !isValueAssigned(property) || typeof name !== "string") {
return null;
}
var propType = typeof property;
if (propType === "string" || propType === "number" || propType === "boolean" || isArray(property)) {
property = { value: property };
} else if (propType === "object" && !ObjHasOwnProperty.call(property, "value")) {
property = { value: stringifyObjects ? JSON.stringify(property) : property };
} else if (/* @__PURE__ */ isNullOrUndefined(property[_DYN_VALUE]) || property[_DYN_VALUE] === STR_EMPTY || !isString(property[_DYN_VALUE]) && !isNumber(property[_DYN_VALUE]) && !isBoolean(property[_DYN_VALUE]) && !isArray(property[_DYN_VALUE])) {
return null;
}
if (isArray(property[_DYN_VALUE]) && !isArrayValid(property[_DYN_VALUE])) {
return null;
}
if (!/* @__PURE__ */ isNullOrUndefined(property.kind)) {
if (isArray(property[_DYN_VALUE]) || !isValueKind(property.kind)) {
return null;
}
property[_DYN_VALUE] = property[_DYN_VALUE].toString();
}
return property;
}
function getCommonSchemaMetaData(value, kind, type) {
var encodedTypeValue = -1;
if (!/* @__PURE__ */ isUndefined(value)) {
if (kind > 0) {
if (kind === 32) {
encodedTypeValue = 1 << 13;
} else if (kind <= 13) {
encodedTypeValue = kind << 5;
}
}
if (isDataType(type)) {
if (encodedTypeValue === -1) {
encodedTypeValue = 0;
}
encodedTypeValue |= type;
} else {
var propType = _fieldTypeEventPropMap[getFieldValueType(value)] || -1;
if (encodedTypeValue !== -1 && propType !== -1) {
encodedTypeValue |= propType;
} else if (propType === 6) {
encodedTypeValue = propType;
}
}
}
return encodedTypeValue;
}
function getCookieValue(cookieMgr, name, decode) {
if (decode === void 0) {
decode = true;
}
var cookieValue;
if (cookieMgr) {
cookieValue = cookieMgr.get(name);
if (decode && cookieValue && decodeURIComponent) {
cookieValue = decodeURIComponent(cookieValue);
}
}
return cookieValue || STR_EMPTY;
}
function createGuid(style) {
if (style === void 0) {
style = "D";
}
var theGuid = newGuid();
if (style === "B") {
theGuid = "{" + theGuid + "}";
} else if (style === "P") {
theGuid = "(" + theGuid + ")";
} else if (style === "N") {
theGuid = theGuid.replace(/-/g, STR_EMPTY);
}
return theGuid;
}
function extend(obj, obj2, obj3, obj4, obj5) {
var extended = {};
var deep = false;
var i = 0;
var length = arguments[_DYN_LENGTH];
var theArgs = arguments;
if (isBoolean(theArgs[0])) {
deep = theArgs[0];
i++;
}
for (; i < length; i++) {
var obj = theArgs[i];
objForEachKey(obj, function(prop, value) {
if (deep && value && /* @__PURE__ */ isObject(value)) {
if (isArray(value)) {
extended[prop] = extended[prop] || [];
arrForEach(value, function(arrayValue, arrayIndex) {
if (arrayValue && /* @__PURE__ */ isObject(arrayValue)) {
extended[prop][arrayIndex] = extend(true, extended[prop][arrayIndex], arrayValue);
} else {
extended[prop][arrayIndex] = arrayValue;
}
});
} else {
extended[prop] = extend(true, extended[prop], value);
}
} else {
extended[prop] = value;
}
});
}
return extended;
}
var getTime = perfNow;
function isValueKind(value) {
if (value === 0 || (value > 0 && value <= 13 || value === 32)) {
return true;
}
return false;
}
function isDataType(value) {
if (value >= 0 && value <= 9) {
return true;
}
return false;
}
function isSafariOrFirefox() {
var nav = getNavigator();
if (!/* @__PURE__ */ isUndefined(nav) && nav.userAgent) {
var ua = nav.userAgent.toLowerCase();
if ((ua[_DYN_INDEX_OF]("safari") >= 0 || ua[_DYN_INDEX_OF]("firefox") >= 0) && ua[_DYN_INDEX_OF]("chrome") < 0) {
return true;
}
}
return false;
}
function isArrayValid(value) {
return value[_DYN_LENGTH] > 0;
}
function setProcessTelemetryTimings(event, identifier) {
var evt = event;
evt[_DYN_TIMINGS] = evt[_DYN_TIMINGS] || {};
evt[_DYN_TIMINGS][_DYN_PROCESS_TELEMETRY_ST0] = evt[_DYN_TIMINGS][_DYN_PROCESS_TELEMETRY_ST0] || {};
evt[_DYN_TIMINGS][_DYN_PROCESS_TELEMETRY_ST0][identifier] = getTime();
}
function getFieldValueType(value) {
var theType = 0;
if (value !== null && value !== void 0) {
var objType = typeof value;
if (objType === "string") {
theType = 1;
} else if (objType === "number") {
theType = 2;
} else if (objType === "boolean") {
theType = 3;
} else if (objType === strShimObject) {
theType = 4;
if (isArray(value)) {
theType = 4096;
if (value[_DYN_LENGTH] > 0) {
theType |= getFieldValueType(value[0]);
}
} else if (ObjHasOwnProperty.call(value, "value")) {
theType = 8192 | getFieldValueType(value[_DYN_VALUE]);
}
}
}
return theType;
}
function isChromium() {
return !!/* @__PURE__ */ getInst("chrome");
}
function openXhr(method, urlString, withCredentials, disabled, isSync, timeout) {
if (disabled === void 0) {
disabled = false;
}
if (isSync === void 0) {
isSync = false;
}
function _wrapSetXhrProp(xhr2, prop, value) {
try {
xhr2[prop] = value;
} catch (e) {
}
}
var xhr = new XMLHttpRequest();
if (disabled) {
_wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
}
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
xhr.open(method, urlString, !isSync);
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
if (!isSync && timeout) {
_wrapSetXhrProp(xhr, strTimeout, timeout);
}
return xhr;
}
function isGreaterThanZero(value) {
return value > 0;
}
var defaultConfig = objDeepFreeze({
endpointUrl: STR_DEFAULT_ENDPOINT_URL,
propertyStorageOverride: { isVal: _chkPropOverride }
});
function _chkPropOverride(propertyStorageOverride) {
if (propertyStorageOverride && (!propertyStorageOverride.getProperty || !propertyStorageOverride.setProperty)) {
throwError("Invalid property storage override passed.");
}
return true;
}
var AppInsightsCore = (
/** @class */
(function(_super) {
__extendsFn(AppInsightsCore2, _super);
function AppInsightsCore2() {
var _this = _super.call(this) || this;
dynamicProto(AppInsightsCore2, _this, function(_self, _base) {
_self[_DYN_INITIALIZE] = function(config, extensions3, logger2, notificationManager) {
doPerf(_self, function() {
return "AppInsightsCore.initialize";
}, function() {
try {
_base[_DYN_INITIALIZE](createDynamicConfig(config, defaultConfig, logger2 || _self.logger, false).cfg, extensions3, logger2, notificationManager);
} catch (e) {
var logger_1 = _self.logger;
var message = /* @__PURE__ */ dumpObj(e);
if (message[_DYN_INDEX_OF]("channels") !== -1) {
message += "\n - Channels must be provided through config.channels only!";
}
_throwInternal(logger_1, 1, 514, "SDK Initialization Failed - no telemetry will be sent: " + message);
}
}, function() {
return { config, extensions: extensions3, logger: logger2, notificationManager };
});
};
_self.track = function(item) {
doPerf(_self, function() {
return "AppInsightsCore.track";
}, function() {
var telemetryItem = item;
if (telemetryItem) {
telemetryItem[_DYN_TIMINGS] = telemetryItem[_DYN_TIMINGS] || {};
telemetryItem[_DYN_TIMINGS].trackStart = getTime();
if (!isLatency(telemetryItem.latency)) {
telemetryItem.latency = 1;
}
var itemExt = telemetryItem.ext = telemetryItem.ext || {};
itemExt.sdk = itemExt.sdk || {};
itemExt.sdk.ver = FullVersionString;
var baseData = telemetryItem.baseData = telemetryItem.baseData || {};
baseData[STR_PROPERTIES] = baseData[STR_PROPERTIES] || {};
var itemProperties = baseData[STR_PROPERTIES];
itemProperties[STR_VERSION] = itemProperties[STR_VERSION] || _self.pluginVersionString || STR_EMPTY;
}
_base.track(telemetryItem);
}, function() {
return { item };
}, !item.sync);
};
_self[_DYN_POLL_INTERNAL_LOGS] = function(eventName) {
return _base[_DYN_POLL_INTERNAL_LOGS](eventName || "InternalLog");
};
});
return _this;
}
AppInsightsCore2.__ieDyn = 1;
return AppInsightsCore2;
})(AppInsightsCore$1)
);
var ValueKind = /* @__PURE__ */ createEnumStyle({
NotSet: 0,
Pii_DistinguishedName: 1,
Pii_GenericData: 2,
Pii_IPV4Address: 3,
Pii_IPv6Address: 4,
Pii_MailSubject: 5,
Pii_PhoneNumber: 6,
Pii_QueryString: 7,
Pii_SipAddress: 8,
Pii_SmtpAddress: 9,
Pii_Identity: 10,
Pii_Uri: 11,
Pii_Fqdn: 12,
Pii_IPV4AddressLegacy: 13,
Pii_IPv6ScrubLastHextets: 14,
Pii_DropValue: 15,
CustomerContent_GenericContent: 32
});
var EventLatency = /* @__PURE__ */ createEnumStyle({
Normal: 1,
CostDeferred: 2,
RealTime: 3,
Immediate: 4
});
var EventPropertyType = /* @__PURE__ */ createEnumStyle({
Unspecified: 0,
String: 1,
Int32: 2,
UInt32: 3,
Int64: 4,
UInt64: 5,
Double: 6,
Bool: 7,
Guid: 8,
DateTime: 9
});
var EventPersistence = /* @__PURE__ */ createEnumStyle({
Normal: 1,
Critical: 2
});
var TraceLevel = /* @__PURE__ */ createEnumStyle({
NONE: 0,
ERROR: 1,
WARNING: 2,
INFORMATION: 3
});
function _isSpecialName(name) {
return name == "__proto__" || name == "constructor" || name == "prototype";
}
var ValueSanitizer = (
/** @class */
(function() {
function ValueSanitizer2(fieldSanitizerProvider) {
var _self = this;
var _sanitizerMap = {};
var _sanitizers = [];
var _fieldSanitizers = [];
if (fieldSanitizerProvider) {
_fieldSanitizers.push(fieldSanitizerProvider);
}
function _getFieldSanitizer(path11, name) {
var result;
var fieldLookup = _sanitizerMap[path11];
if (fieldLookup) {
result = fieldLookup[name];
}
if (!result && result !== null) {
if (isString(path11) && isString(name)) {
if (_fieldSanitizers[_DYN_LENGTH] > 0) {
for (var lp = 0; lp < _fieldSanitizers[_DYN_LENGTH]; lp++) {
if (_fieldSanitizers[lp][_DYN_HANDLE_FIELD](path11, name)) {
result = {
canHandle: true,
fieldHandler: _fieldSanitizers[lp]
};
break;
}
}
} else if (_sanitizers[_DYN_LENGTH] === 0) {
result = {
canHandle: true
};
}
}
if (!result && result !== null) {
result = null;
for (var lp = 0; lp < _sanitizers[_DYN_LENGTH]; lp++) {
if (_sanitizers[lp][_DYN_HANDLE_FIELD](path11, name)) {
result = {
canHandle: true,
handler: _sanitizers[lp],
fieldHandler: null
};
break;
}
}
}
if (!fieldLookup) {
if (_isSpecialName(path11)) {
return null;
}
fieldLookup = _sanitizerMap[path11] = {};
}
if (_isSpecialName(name)) {
return null;
}
fieldLookup[name] = result;
}
return result;
}
_self.clearCache = function() {
_sanitizerMap = {};
};
_self.addSanitizer = function(newSanitizer) {
if (newSanitizer) {
if (!arrIncludes(_sanitizers, newSanitizer)) {
_sanitizers.push(newSanitizer);
}
_sanitizerMap = {};
}
};
_self.addFieldSanitizer = function(fieldSanitizer) {
if (fieldSanitizer) {
if (!arrIncludes(_fieldSanitizers, fieldSanitizer)) {
_fieldSanitizers.push(fieldSanitizer);
}
_sanitizerMap = {};
}
};
_self[_DYN_RM_SANITIZER] = function(theSanitizer) {
if (theSanitizer) {
var idx = arrIndexOf(_sanitizers, theSanitizer);
if (idx !== -1) {
_sanitizers.splice(idx, 1);
_sanitizerMap = {};
}
arrForEach(_sanitizers, function(sanitizer) {
sanitizer && sanitizer[_DYN_RM_SANITIZER] && sanitizer[_DYN_RM_SANITIZER](theSanitizer);
});
}
};
_self[_DYN_RM_FIELD_SANITIZER] = function(theFieldSanitizer) {
if (theFieldSanitizer) {
var idx = arrIndexOf(_fieldSanitizers, theFieldSanitizer);
if (idx !== -1) {
_fieldSanitizers.splice(idx, 1);
_sanitizerMap = {};
}
arrForEach(_sanitizers, function(sanitizer) {
sanitizer && sanitizer[_DYN_RM_FIELD_SANITIZER] && sanitizer[_DYN_RM_FIELD_SANITIZER](theFieldSanitizer);
});
}
};
_self.isEmpty = function() {
return getLength(_sanitizers) + getLength(_fieldSanitizers) === 0;
};
_self[_DYN_HANDLE_FIELD] = function(path11, name) {
var mapValue = _getFieldSanitizer(path11, name);
return mapValue ? mapValue[_DYN_CAN_HANDLE] : false;
};
_self[_DYN_VALUE] = function(path11, name, value, stringifyObjects) {
var mapValue = _getFieldSanitizer(path11, name);
if (mapValue && mapValue[_DYN_CAN_HANDLE]) {
if (!mapValue[_DYN_CAN_HANDLE]) {
return null;
}
if (mapValue.handler) {
return mapValue.handler[_DYN_VALUE](path11, name, value, stringifyObjects);
}
if (!isString(name) || /* @__PURE__ */ isNullOrUndefined(value) || value === STR_EMPTY) {
return null;
}
var property = null;
var fieldType = getFieldValueType(value);
if ((fieldType & 8192) === 8192) {
var subType = fieldType & ~8192;
property = value;
if (!isValueAssigned(property[_DYN_VALUE]) || subType !== 1 && subType !== 2 && subType !== 3 && (subType & 4096) !== 4096) {
return null;
}
} else if (fieldType === 1 || fieldType === 2 || fieldType === 3 || (fieldType & 4096) === 4096) {
property = _convertToProperty(path11, name, value);
} else if (fieldType === 4) {
property = _convertToProperty(path11, name, !!stringifyObjects ? JSON.stringify(value) : value);
}
if (property) {
return _handleProperty(mapValue, path11, name, fieldType, property, stringifyObjects);
}
}
return null;
};
_self.property = function(path11, name, property, stringifyObjects) {
var mapValue = _getFieldSanitizer(path11, name);
if (!mapValue || !mapValue[_DYN_CAN_HANDLE]) {
return null;
}
if (!isString(name) || /* @__PURE__ */ isNullOrUndefined(property) || !isValueAssigned(property[_DYN_VALUE])) {
return null;
}
var fieldType = getFieldValueType(property[_DYN_VALUE]);
if (fieldType === 0) {
return null;
}
return _handleProperty(mapValue, path11, name, fieldType, property, stringifyObjects);
};
function _handleProperty(mapValue, path11, name, fieldType, property, stringifyObjects) {
if (mapValue.handler) {
return mapValue.handler.property(path11, name, property, stringifyObjects);
}
if (!/* @__PURE__ */ isNullOrUndefined(property.kind)) {
if ((fieldType & 4096) === 4096 || !isValueKind(property.kind)) {
return null;
}
property[_DYN_VALUE] = property[_DYN_VALUE].toString();
}
return _callFieldSanitizer(mapValue.fieldHandler, path11, name, fieldType, property);
}
function _convertToProperty(path11, name, value) {
if (isValueAssigned(value)) {
return { value };
}
return null;
}
function _callFieldSanitizer(fieldProvider, path11, name, theType, property) {
if (property && fieldProvider) {
var sanitizer = fieldProvider.getSanitizer(path11, name, theType, property.kind, property.propertyType);
if (sanitizer) {
if (theType === 4) {
var newValue_1 = {};
var propValue = property[_DYN_VALUE];
objForEachKey(propValue, function(propKey, theValue) {
var newPath = path11 + "." + name;
if (isValueAssigned(theValue)) {
var newProp = _convertToProperty(newPath, propKey, theValue);
newProp = _callFieldSanitizer(fieldProvider, newPath, propKey, getFieldValueType(theValue), newProp);
if (newProp) {
newValue_1[propKey] = newProp[_DYN_VALUE];
}
}
});
property[_DYN_VALUE] = newValue_1;
} else {
var details = {
path: path11,
name,
type: theType,
prop: property,
sanitizer: _self
};
property = sanitizer.call(_self, details);
}
}
}
return property;
}
}
ValueSanitizer2.getFieldType = getFieldValueType;
return ValueSanitizer2;
})()
);
exports3.ActiveStatus = ActiveStatus;
exports3.AppInsightsCore = AppInsightsCore;
exports3.BaseTelemetryPlugin = BaseTelemetryPlugin;
exports3.DiagnosticLogger = DiagnosticLogger;
exports3.EventLatency = EventLatency;
exports3.EventPersistence = EventPersistence;
exports3.EventPropertyType = EventPropertyType;
exports3.EventsDiscardedReason = EventsDiscardedReason;
exports3.FullVersionString = FullVersionString;
exports3.InternalAppInsightsCore = AppInsightsCore$1;
exports3.LoggingSeverity = LoggingSeverity;
exports3.MinChannelPriorty = MinChannelPriorty;
exports3.NotificationManager = NotificationManager;
exports3.PerfEvent = PerfEvent;
exports3.PerfManager = PerfManager;
exports3.ProcessTelemetryContext = ProcessTelemetryContext;
exports3.SenderPostManager = SenderPostManager;
exports3.TraceLevel = TraceLevel;
exports3.Undefined = strShimUndefined;
exports3.ValueKind = ValueKind;
exports3.ValueSanitizer = ValueSanitizer;
exports3.Version = Version;
exports3._InternalLogMessage = _InternalLogMessage;
exports3.__getRegisteredEvents = __getRegisteredEvents;
exports3._appendHeader = _appendHeader;
exports3._getAllResponseHeaders = _getAllResponseHeaders;
exports3._logInternalMessage = _logInternalMessage;
exports3._testHookMaxUnloadHooksCb = _testHookMaxUnloadHooksCb;
exports3._throwInternal = _throwInternal;
exports3._warnToConsole = _warnToConsole;
exports3.addEventHandler = addEventHandler;
exports3.addEventListeners = addEventListeners;
exports3.addPageHideEventListener = addPageHideEventListener;
exports3.addPageShowEventListener = addPageShowEventListener;
exports3.addPageUnloadEventListener = addPageUnloadEventListener;
exports3.areCookiesSupported = areCookiesSupported;
exports3.arrForEach = arrForEach;
exports3.arrIndexOf = arrIndexOf;
exports3.arrMap = arrMap;
exports3.arrReduce = arrReduce;
exports3.attachEvent = attachEvent;
exports3.blockDynamicConversion = blockDynamicConversion;
exports3.convertAllHeadersToMap = convertAllHeadersToMap;
exports3.cookieAvailable = areCookiesSupported;
exports3.createCookieMgr = createCookieMgr;
exports3.createDynamicConfig = createDynamicConfig;
exports3.createEnumStyle = createEnumStyle;
exports3.createGuid = createGuid;
exports3.createProcessTelemetryContext = createProcessTelemetryContext;
exports3.createTraceParent = createTraceParent;
exports3.createUniqueNamespace = createUniqueNamespace;
exports3.createUnloadHandlerContainer = createUnloadHandlerContainer;
exports3.dateNow = utcNow;
exports3.detachEvent = detachEvent;
exports3.disallowsSameSiteNone = uaDisallowsSameSiteNone;
exports3.doPerf = doPerf;
exports3.dumpObj = dumpObj;
exports3.eventOff = eventOff;
exports3.eventOn = eventOn;
exports3.extend = extend;
exports3.fieldRedaction = fieldRedaction;
exports3.findW3cTraceParent = findW3cTraceParent;
exports3.forceDynamicConversion = forceDynamicConversion;
exports3.formatErrorMessageXdr = formatErrorMessageXdr;
exports3.formatErrorMessageXhr = formatErrorMessageXhr;
exports3.formatTraceParent = formatTraceParent;
exports3.generateW3CId = generateW3CId;
exports3.getCommonSchemaMetaData = getCommonSchemaMetaData;
exports3.getConsole = getConsole;
exports3.getCookieValue = getCookieValue;
exports3.getCrypto = getCrypto;
exports3.getDocument = getDocument;
exports3.getDynamicConfigHandler = getDynamicConfigHandler;
exports3.getExceptionName = getExceptionName;
exports3.getFieldValueType = getFieldValueType;
exports3.getGlobal = getGlobal;
exports3.getGlobalInst = getInst;
exports3.getHistory = getHistory;
exports3.getIEVersion = getIEVersion;
exports3.getISOString = toISOString;
exports3.getJSON = getJSON;
exports3.getLocation = getLocation;
exports3.getMsCrypto = getMsCrypto;
exports3.getNavigator = getNavigator;
exports3.getPerformance = getPerformance;
exports3.getResponseText = getResponseText;
exports3.getSetValue = getSetValue;
exports3.getTenantId = getTenantId;
exports3.getTime = getTime;
exports3.getWindow = getWindow;
exports3.hasDocument = hasDocument;
exports3.hasHistory = hasHistory;
exports3.hasJSON = hasJSON;
exports3.hasNavigator = hasNavigator;
exports3.hasOwnProperty = objHasOwnProperty;
exports3.hasWindow = hasWindow;
exports3.isArray = isArray;
exports3.isArrayValid = isArrayValid;
exports3.isBeaconsSupported = isBeaconsSupported;
exports3.isBoolean = isBoolean;
exports3.isChromium = isChromium;
exports3.isDate = isDate;
exports3.isDocumentObjectAvailable = isDocumentObjectAvailable;
exports3.isError = isError;
exports3.isFeatureEnabled = isFeatureEnabled;
exports3.isFetchSupported = isFetchSupported;
exports3.isFunction = isFunction;
exports3.isGreaterThanZero = isGreaterThanZero;
exports3.isIE = isIE;
exports3.isLatency = isLatency;
exports3.isNotTruthy = isNotTruthy;
exports3.isNullOrUndefined = isNullOrUndefined;
exports3.isNumber = isNumber;
exports3.isObject = isObject;
exports3.isReactNative = isReactNative;
exports3.isSampledFlag = isSampledFlag;
exports3.isString = isString;
exports3.isTruthy = isTruthy;
exports3.isTypeof = isTypeof;
exports3.isUint8ArrayAvailable = isUint8ArrayAvailable;
exports3.isUndefined = isUndefined;
exports3.isValidSpanId = isValidSpanId;
exports3.isValidTraceId = isValidTraceId;
exports3.isValidTraceParent = isValidTraceParent;
exports3.isValueAssigned = isValueAssigned;
exports3.isValueKind = isValueKind;
exports3.isWindowObjectAvailable = isWindowObjectAvailable;
exports3.isXhrSupported = isXhrSupported;
exports3.mergeEvtNamespace = mergeEvtNamespace;
exports3.newGuid = newGuid;
exports3.newId = newId;
exports3.normalizeJsName = normalizeJsName;
exports3.objDefineAccessors = objDefineAccessors;
exports3.objForEachKey = objForEachKey;
exports3.objFreeze = objFreeze;
exports3.objKeys = objKeys;
exports3.objSeal = objSeal;
exports3.onConfigChange = onConfigChange;
exports3.openXhr = openXhr;
exports3.optimizeObject = optimizeObject;
exports3.parseResponse = parseResponse;
exports3.parseTraceParent = parseTraceParent;
exports3.perfNow = perfNow;
exports3.prependTransports = prependTransports;
exports3.proxyAssign = proxyAssign;
exports3.proxyFunctionAs = proxyFunctionAs;
exports3.proxyFunctions = proxyFunctions;
exports3.random32 = random32;
exports3.randomValue = randomValue;
exports3.removeEventHandler = removeEventHandler;
exports3.removeEventListeners = removeEventListeners;
exports3.removePageHideEventListener = removePageHideEventListener;
exports3.removePageShowEventListener = removePageShowEventListener;
exports3.removePageUnloadEventListener = removePageUnloadEventListener;
exports3.safeGetCookieMgr = safeGetCookieMgr;
exports3.safeGetLogger = safeGetLogger;
exports3.sanitizeProperty = sanitizeProperty;
exports3.setEnableEnvMocks = setEnableEnvMocks;
exports3.setProcessTelemetryTimings = setProcessTelemetryTimings;
exports3.setValue = setValue;
exports3.strContains = strContains;
exports3.strEndsWith = strEndsWith;
exports3.strFunction = strShimFunction;
exports3.strObject = strShimObject;
exports3.strPrototype = strShimPrototype;
exports3.strStartsWith = strStartsWith;
exports3.strTrim = strTrim;
exports3.strUndefined = strShimUndefined;
exports3.throwError = throwError;
exports3.toISOString = toISOString;
exports3.useXDomainRequest = useXDomainRequest;
}));
}
});
// node_modules/@microsoft/1ds-post-js/dist/es5/ms.post.js
var require_ms_post = __commonJS({
"node_modules/@microsoft/1ds-post-js/dist/es5/ms.post.js"(exports2, module2) {
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.oneDS = global2.oneDS || {}));
})(exports2, (function(exports3) {
"use strict";
var RT_PROFILE = "REAL_TIME";
var NRT_PROFILE = "NEAR_REAL_TIME";
var BE_PROFILE = "BEST_EFFORT";
var strShimFunction = "function";
var strShimObject = "object";
var strShimUndefined = "undefined";
var strShimPrototype = "prototype";
var ObjClass$1 = Object;
var ObjProto$1 = ObjClass$1[strShimPrototype];
// @__NO_SIDE_EFFECTS__
function _pureAssign(func1, func2) {
return func1 || func2;
}
// @__NO_SIDE_EFFECTS__
function _pureRef(value, name) {
return value[name];
}
var UNDEF_VALUE = void 0;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
var ObjClass = /* @__PURE__ */ _pureAssign(Object);
var ObjProto = /* @__PURE__ */ _pureRef(ObjClass, PROTOTYPE);
var StrCls = /* @__PURE__ */ _pureAssign(String);
var StrProto = /* @__PURE__ */ _pureRef(StrCls, PROTOTYPE);
var MathCls = /* @__PURE__ */ _pureAssign(Math);
var ArrCls = /* @__PURE__ */ _pureAssign(Array);
var ArrProto = /* @__PURE__ */ _pureRef(ArrCls, PROTOTYPE);
var ArrSlice = /* @__PURE__ */ _pureRef(ArrProto, "slice");
var POLYFILL_TAG = "_polyfill";
var POLYFILL_TYPE_NAME = "__nw21$polytype__";
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
} catch (e) {
return { e };
}
}
// @__NO_SIDE_EFFECTS__
function _createIs(theType) {
return function(value) {
return typeof value === theType;
};
}
// @__NO_SIDE_EFFECTS__
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
// @__NO_SIDE_EFFECTS__
function isStrictUndefined(arg) {
return arg === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isNullOrUndefined(value) {
return value === NULL_VALUE || /* @__PURE__ */ isUndefined(value);
}
// @__NO_SIDE_EFFECTS__
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
var isString = /* @__PURE__ */ _createIs("string");
var isFunction = /* @__PURE__ */ _createIs(FUNCTION);
// @__NO_SIDE_EFFECTS__
function isObject(value) {
if (!value && /* @__PURE__ */ isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = /* @__PURE__ */ _pureRef(ArrCls, "isArray");
var isNumber = /* @__PURE__ */ _createIs("number");
var isBoolean = /* @__PURE__ */ _createIs("boolean");
// @__NO_SIDE_EFFECTS__
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
function _returnNothing() {
return;
}
function _returnFalse() {
return false;
}
var asString = /* @__PURE__ */ _pureAssign(StrCls);
var ERROR_TYPE = "[object Error]";
// @__NO_SIDE_EFFECTS__
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? typeof format === "number" ? format : 4 : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
} catch (e) {
propertyValueDump = " - " + /* @__PURE__ */ dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwTypeError(message) {
throw new TypeError(message);
}
function _throwIfNullOrUndefined(obj) {
if (/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + /* @__PURE__ */ dumpObj(value) + "' is not a string");
}
}
// @__NO_SIDE_EFFECTS__
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
}
var _objGetOwnPropertyDescriptor$2 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var objHasOwn = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "hasOwn"), polyObjHasOwn);
// @__NO_SIDE_EFFECTS__
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return /* @__PURE__ */ objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (/* @__PURE__ */ isObject(theObject) || isFunction(theObject))) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var _unwrapFunction = _unwrapFunctionWithPoly;
// @__NO_SIDE_EFFECTS__
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function(thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError('"' + asString(funcName) + '" not defined for ' + /* @__PURE__ */ dumpObj(thisArg));
};
}
var _objGetOwnPropertyDescriptor$1 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
// @__NO_SIDE_EFFECTS__
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function() {
return value.l.v;
};
var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = function(newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function(key, value2) {
prop[propMap[key]] = /* @__PURE__ */ isStrictUndefined(value2) ? prop[propMap[key]] : value2;
});
return prop;
}
var objDefineProp = /* @__PURE__ */ _pureRef(ObjClass, "defineProperty");
var objDefineProperties = /* @__PURE__ */ _pureRef(ObjClass, "defineProperties");
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, /* @__PURE__ */ _createProp(propDesc));
}
// @__NO_SIDE_EFFECTS__
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function(key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value,
enumerable: true,
writable: false
});
}
var objIsFrozen = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "isFrozen"), _returnFalse);
var _objFreeze = /* @__PURE__ */ _pureRef(ObjClass, "freeze");
function _doNothing(value) {
return value;
}
// @__NO_SIDE_EFFECTS__
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = /* @__PURE__ */ _pureRef(ObjClass, "assign");
var objKeys = /* @__PURE__ */ _pureRef(ObjClass, "keys");
function _deepFreeze(val, visited) {
if ((isArray(val) || /* @__PURE__ */ isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
for (var lp = 0; lp < visited.length; lp++) {
if (visited[lp] === val) {
return val;
}
}
visited.push(val);
objForEachKey(val, function(_key, propValue) {
_deepFreeze(propValue, visited);
});
objFreeze(val);
}
return val;
}
function objDeepFreeze(value) {
return _objFreeze ? _deepFreeze(value, []) : value;
}
var objFreeze = /* @__PURE__ */ _pureAssign(_objFreeze, _doNothing);
var objGetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "getPrototypeOf"), _getProto);
// @__NO_SIDE_EFFECTS__
function createEnum(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 1, 0, objFreeze);
}
// @__NO_SIDE_EFFECTS__
function createEnumKeyMap(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 0, 0, objFreeze);
}
var _wellKnownSymbolMap = /* @__PURE__ */ createEnumKeyMap({
asyncIterator: 0,
hasInstance: 1,
isConcatSpreadable: 2,
iterator: 3,
match: 4,
matchAll: 5,
replace: 6,
search: 7,
species: 8,
split: 9,
toPrimitive: 10,
toStringTag: 11,
unscopables: 12
});
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
// @__NO_SIDE_EFFECTS__
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var mathMin = /* @__PURE__ */ _pureRef(MathCls, "min");
var mathMax = /* @__PURE__ */ _pureRef(MathCls, "max");
var strSlice = /* @__PURE__ */ _unwrapFunction("slice", StrProto);
var strSubstring = /* @__PURE__ */ _unwrapFunction("substring", StrProto);
var strSubstr = /* @__PURE__ */ _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
// @__NO_SIDE_EFFECTS__
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(value);
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (/* @__PURE__ */ isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
// @__NO_SIDE_EFFECTS__
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(function() {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
var objCreate = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "create"), polyObjCreate);
// @__NO_SIDE_EFFECTS__
function polyObjCreate(obj, properties) {
var newObj = null;
function tempFunc() {
}
if (!/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + /* @__PURE__ */ dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(function() {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
} else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
// @__NO_SIDE_EFFECTS__
function utcNow() {
return (Date.now || polyUtcNow)();
}
// @__NO_SIDE_EFFECTS__
function polyUtcNow() {
return (/* @__PURE__ */ new Date()).getTime();
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = /* @__PURE__ */ _getGlobalConfig();
}
// @__NO_SIDE_EFFECTS__
function getLazy(cb, argArray) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function() {
var result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
var mathRandom = /* @__PURE__ */ _pureRef(MathCls, "random");
var _uniqueInstanceId = /* @__PURE__ */ getLazy(function() {
var value = (/* @__PURE__ */ utcNow()).toString(36).slice(2);
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
});
var UNIQUE_REGISTRY_ID = "_urid";
var POLY_SYM = "$nw21sym";
var _polySymbols;
var _polyId = 0;
// @__NO_SIDE_EFFECTS__
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = /* @__PURE__ */ _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
var _wellKnownSymbolCache;
// @__NO_SIDE_EFFECTS__
function polyNewSymbol(description) {
var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
var symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
var theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, function() {
return symString + POLY_SYM + uniqueId;
});
_setProp("valueOf", function() {
return theSymbol;
});
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
// @__NO_SIDE_EFFECTS__
function polySymbolFor(key) {
var registry = /* @__PURE__ */ _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = /* @__PURE__ */ polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function() {
return regId_1 + "_" + newSymbol_1[TO_STRING]();
};
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
// @__NO_SIDE_EFFECTS__
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
var result;
var knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || /* @__PURE__ */ polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
// @__NO_SIDE_EFFECTS__
function createCachedValue(value) {
return objDefineProp({
toJSON: function() {
return value;
}
}, "v", { value });
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function() {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = /* @__PURE__ */ createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = /* @__PURE__ */ createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
// @__NO_SIDE_EFFECTS__
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
} else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
} catch (e) {
}
}
return NULL_VALUE;
}
var getDocument = /* @__PURE__ */ _getGlobalInstFn(getInst, ["document"]);
// @__NO_SIDE_EFFECTS__
function hasWindow() {
return !!/* @__PURE__ */ getWindow();
}
var getWindow = /* @__PURE__ */ _getGlobalInstFn(getInst, [WINDOW]);
// @__NO_SIDE_EFFECTS__
function hasNavigator() {
return !!/* @__PURE__ */ getNavigator();
}
var getNavigator = /* @__PURE__ */ _getGlobalInstFn(getInst, ["navigator"]);
var isNode = /* @__PURE__ */ _getGlobalInstFn(function() {
return !!safe(function() {
return process && (process.versions || {}).node;
}).v;
});
var _symbol;
var _symbolFor;
// @__NO_SIDE_EFFECTS__
function _initSymbol() {
_symbol = /* @__PURE__ */ createCachedValue(safe(getInst, [SYMBOL]).v);
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return gblSym.v ? gblSym.v[key] : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function hasSymbol() {
return !!/* @__PURE__ */ getSymbol();
}
// @__NO_SIDE_EFFECTS__
function getSymbol() {
!_globalLazyTestHooks && _initTestHooks();
return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol()).v;
}
// @__NO_SIDE_EFFECTS__
function getKnownSymbol(name, noPoly) {
var knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v[knownName || name] : !noPoly ? /* @__PURE__ */ polyGetKnownSymbol(name) : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v(description) : !noPoly ? /* @__PURE__ */ polyNewSymbol(description) : NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = (!_globalLazyTestHooks.lzy ? _symbolFor : 0) || /* @__PURE__ */ createCachedValue(safe(_getSymbolKey, ["for"]).v);
return (_symbolFor.v || polySymbolFor)(key);
}
// @__NO_SIDE_EFFECTS__
function isIterator(value) {
return !!value && isFunction(value.next);
}
// @__NO_SIDE_EFFECTS__
function isIterable(value) {
return !/* @__PURE__ */ isStrictNullOrUndefined(value) && isFunction(value[/* @__PURE__ */ getKnownSymbol(3)]);
}
var _iterSymbol$1;
function iterForOf(iter, callbackfn, thisArg) {
if (iter) {
if (!/* @__PURE__ */ isIterator(iter)) {
!_iterSymbol$1 && (_iterSymbol$1 = /* @__PURE__ */ createCachedValue(/* @__PURE__ */ getKnownSymbol(3)));
iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
}
if (/* @__PURE__ */ isIterator(iter)) {
var err = UNDEF_VALUE;
var iterResult = UNDEF_VALUE;
try {
var count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
break;
}
count++;
}
} catch (failed) {
err = { e: failed };
if (iter.throw) {
iterResult = NULL_VALUE;
iter.throw(err);
}
} finally {
try {
if (iterResult && !iterResult.done) {
iter.return && iter.return(iterResult);
}
} finally {
if (err) {
throw err.e;
}
}
}
}
}
}
function arrAppend(target, elms) {
if (!/* @__PURE__ */ isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
} else if (/* @__PURE__ */ isIterator(elms) || /* @__PURE__ */ isIterable(elms)) {
iterForOf(elms, function(elm) {
target.push(elm);
});
} else {
target.push(elms);
}
}
return target;
}
var arrIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", ArrProto);
function arrSlice(theArray, start, end) {
return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
}
var _isProtoArray;
var objSetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, "setPrototypeOf"), _polyObjSetPrototypeOf);
function _polyObjSetPrototypeOf(obj, proto) {
var _a2;
!_isProtoArray && (_isProtoArray = /* @__PURE__ */ createCachedValue((_a2 = {}, _a2[__PROTO__] = [], _a2) instanceof Array));
_isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function(key, value) {
return obj[key] = value;
});
return obj;
}
// @__NO_SIDE_EFFECTS__
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
// @__NO_SIDE_EFFECTS__
function createCustomError(name, constructCb, errorBase) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return /* @__PURE__ */ _createCustomError(name, function() {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
} finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
// @__NO_SIDE_EFFECTS__
function _createTrimFn(exp) {
return function _doTrim(value) {
_throwIfNullOrUndefined(value);
if (value && value.replace) {
value = value.replace(exp, EMPTY);
}
return value;
};
}
var polyStrTrim = /* @__PURE__ */ _createTrimFn(/^\s+|(?=\s)\s+$/g);
var strTrim = /* @__PURE__ */ _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
var mathFloor = /* @__PURE__ */ _pureRef(MathCls, "floor");
var mathCeil = /* @__PURE__ */ _pureRef(MathCls, "ceil");
var _fnToString;
var _objCtrFnString;
var _gblWindow;
// @__NO_SIDE_EFFECTS__
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = /* @__PURE__ */ hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (/* @__PURE__ */ objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
} catch (ex) {
}
}
return result;
}
// @__NO_SIDE_EFFECTS__
function perfNow() {
return /* @__PURE__ */ utcNow();
}
var objGetOwnPropertyDescriptor = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var strIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", StrProto);
var strStartsWith = /* @__PURE__ */ _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith);
// @__NO_SIDE_EFFECTS__
function polyStrStartsWith(value, searchString, position) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var pos = position > 0 ? position : 0;
return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
}
var REF = "ref";
var UNREF = "unref";
var HAS_REF = "hasRef";
var ENABLED = "enabled";
// @__NO_SIDE_EFFECTS__
function _createTimerHandler(startTimer, refreshFn, cancelFn) {
var ref = true;
var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
var theTimerHandler;
function _unref() {
ref = false;
timerId && timerId[UNREF] && timerId[UNREF]();
return theTimerHandler;
}
function _cancel() {
timerId && cancelFn(timerId);
timerId = NULL_VALUE;
}
function _refresh() {
timerId = refreshFn(timerId);
if (!ref) {
_unref();
}
return theTimerHandler;
}
function _setEnabled(value) {
!value && timerId && _cancel();
value && !timerId && _refresh();
}
theTimerHandler = {
cancel: _cancel,
refresh: _refresh
};
theTimerHandler[HAS_REF] = function() {
if (timerId && timerId[HAS_REF]) {
return timerId[HAS_REF]();
}
return ref;
};
theTimerHandler[REF] = function() {
ref = true;
timerId && timerId[REF] && timerId[REF]();
return theTimerHandler;
};
theTimerHandler[UNREF] = _unref;
theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
get: function() {
return !!timerId;
},
set: _setEnabled
});
return {
h: theTimerHandler,
dn: function() {
timerId = NULL_VALUE;
}
};
}
var _setTimeoutFn;
var _clearTimeoutFn;
function _resolveTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
result = globalOverrides[0];
}
}
return result || setTimeout;
}
function _resolveClearTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
result = globalOverrides[1];
}
}
return result || clearTimeout;
}
function _createTimeoutWith(startTimer, overrideFn, theArgs) {
var isArr = isArray(overrideFn);
var len = isArr ? overrideFn.length : 0;
var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : !isArr ? overrideFn : UNDEF_VALUE);
var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
var timerFn = theArgs[0];
theArgs[0] = function() {
handler.dn();
fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
};
var handler = /* @__PURE__ */ _createTimerHandler(startTimer, function(timerId) {
if (timerId) {
if (timerId.refresh) {
timerId.refresh();
return timerId;
}
fnApply(clearFn, UNDEF_VALUE, [timerId]);
}
return fnApply(setFn, UNDEF_VALUE, theArgs);
}, function(timerId) {
fnApply(clearFn, UNDEF_VALUE, [timerId]);
});
return handler.h;
}
function scheduleTimeout(callback, timeout) {
return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
function scheduleTimeoutWith(overrideFn, callback, timeout) {
return _createTimeoutWith(true, overrideFn, ArrSlice[CALL](arguments, 1));
}
(getGlobal() || {})["Symbol"];
(getGlobal() || {})["Reflect"];
var strHasOwnProperty = "hasOwnProperty";
var extendStaticsFn = function(d, b) {
extendStaticsFn = ObjClass$1["setPrototypeOf"] || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) {
if (b2[strHasOwnProperty](p)) {
d2[p] = b2[p];
}
}
};
return extendStaticsFn(d, b);
};
function __extendsFn(d, b) {
if (typeof b !== strShimFunction && b !== null) {
throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
}
extendStaticsFn(d, b);
function __() {
this.constructor = d;
}
d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
}
var _a$4;
var Constructor = "constructor";
var Prototype = "prototype";
var strFunction = "function";
var DynInstFuncTable = "_dynInstFuncs";
var DynProxyTag = "_isDynProxy";
var DynClassName = "_dynClass";
var DynClassNamePrefix = "_dynCls$";
var DynInstChkTag = "_dynInstChk";
var DynAllowInstChkTag = DynInstChkTag;
var DynProtoDefaultOptions = "_dfOpts";
var UnknownValue = "_unknown_";
var str__Proto = "__proto__";
var DynProtoBaseProto = "_dyn" + str__Proto;
var DynProtoGlobalSettings = "__dynProto$Gbl";
var DynProtoCurrent = "_dynInstProto";
var strUseBaseInst = "useBaseInst";
var strSetInstFuncs = "setInstFuncs";
var Obj = Object;
var _objGetPrototypeOf = Obj["getPrototypeOf"];
var _objGetOwnProps = Obj["getOwnPropertyNames"];
var _gbl = getGlobal();
var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
o: (_a$4 = {}, _a$4[strSetInstFuncs] = true, _a$4[strUseBaseInst] = true, _a$4),
n: 1e3
});
function _isObjectOrArrayPrototype(target) {
return target && (target === Obj[Prototype] || target === Array[Prototype]);
}
function _isObjectArrayOrFunctionPrototype(target) {
return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
}
function _getObjProto(target) {
var newProto;
if (target) {
if (_objGetPrototypeOf) {
return _objGetPrototypeOf(target);
}
var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
newProto = target[DynProtoBaseProto] || curProto;
if (!/* @__PURE__ */ objHasOwnProperty(target, DynProtoBaseProto)) {
delete target[DynProtoCurrent];
newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
target[DynProtoCurrent] = curProto;
}
}
return newProto;
}
function _forEachProp(target, func) {
var props = [];
if (_objGetOwnProps) {
props = _objGetOwnProps(target);
} else {
for (var name_1 in target) {
if (typeof name_1 === "string" && /* @__PURE__ */ objHasOwnProperty(target, name_1)) {
props.push(name_1);
}
}
}
if (props && props.length > 0) {
for (var lp = 0; lp < props.length; lp++) {
func(props[lp]);
}
}
}
function _isDynamicCandidate(target, funcName, skipOwn) {
return funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || /* @__PURE__ */ objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype;
}
function _throwTypeError(message) {
throwTypeError("DynamicProto: " + message);
}
function _getInstanceFuncs(thisTarget) {
var instFuncs = objCreate(null);
_forEachProp(thisTarget, function(name) {
if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
instFuncs[name] = thisTarget[name];
}
});
return instFuncs;
}
function _hasVisited(values, value) {
for (var lp = values.length - 1; lp >= 0; lp--) {
if (values[lp] === value) {
return true;
}
}
return false;
}
function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
function _instFuncProxy(target, funcHost, funcName) {
var theFunc = funcHost[funcName];
if (theFunc[DynProxyTag] && useBaseInst) {
var instFuncTable = target[DynInstFuncTable] || {};
if (instFuncTable[DynAllowInstChkTag] !== false) {
theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
}
}
return function() {
return theFunc.apply(target, arguments);
};
}
var baseFuncs = objCreate(null);
_forEachProp(instFuncs, function(name) {
baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
});
var baseProto = _getObjProto(classProto);
var visited = [];
while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
_forEachProp(baseProto, function(name) {
if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
}
});
visited.push(baseProto);
baseProto = _getObjProto(baseProto);
}
return baseFuncs;
}
function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
var instFunc = null;
if (target && /* @__PURE__ */ objHasOwnProperty(proto, DynClassName)) {
var instFuncTable = target[DynInstFuncTable] || objCreate(null);
instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
if (!instFunc) {
_throwTypeError("Missing [" + funcName + "] " + strFunction);
}
if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
var canAddInst = !/* @__PURE__ */ objHasOwnProperty(target, funcName);
var objProto = _getObjProto(target);
var visited = [];
while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
var protoFunc = objProto[funcName];
if (protoFunc) {
canAddInst = protoFunc === currentDynProtoProxy;
break;
}
visited.push(objProto);
objProto = _getObjProto(objProto);
}
try {
if (canAddInst) {
target[funcName] = instFunc;
}
instFunc[DynInstChkTag] = 1;
} catch (e) {
instFuncTable[DynAllowInstChkTag] = false;
}
}
}
return instFunc;
}
function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
var protoFunc = proto[funcName];
if (protoFunc === currentDynProtoProxy) {
protoFunc = _getObjProto(proto)[funcName];
}
if (typeof protoFunc !== strFunction) {
_throwTypeError("[" + funcName + "] is not a " + strFunction);
}
return protoFunc;
}
function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
function _createDynamicPrototype(proto2, funcName) {
var dynProtoProxy = function() {
var instFunc = _getInstFunc(this, funcName, proto2, dynProtoProxy) || _getProtoFunc(funcName, proto2, dynProtoProxy);
return instFunc.apply(this, arguments);
};
dynProtoProxy[DynProxyTag] = 1;
return dynProtoProxy;
}
if (!_isObjectOrArrayPrototype(proto)) {
var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
if (!_isObjectOrArrayPrototype(instFuncTable)) {
var instFuncs_1 = instFuncTable[className] = instFuncTable[className] || objCreate(null);
if (instFuncTable[DynAllowInstChkTag] !== false) {
instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
}
if (!_isObjectOrArrayPrototype(instFuncs_1)) {
_forEachProp(target, function(name) {
if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
instFuncs_1[name] = target[name];
delete target[name];
if (!/* @__PURE__ */ objHasOwnProperty(proto, name) || proto[name] && !proto[name][DynProxyTag]) {
proto[name] = _createDynamicPrototype(proto, name);
}
}
});
}
}
}
}
function _checkPrototype(classProto, thisTarget) {
if (_objGetPrototypeOf) {
var visited = [];
var thisProto = _getObjProto(thisTarget);
while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
if (thisProto === classProto) {
return true;
}
visited.push(thisProto);
thisProto = _getObjProto(thisProto);
}
return false;
}
return true;
}
function _getObjName(target, unknownValue) {
if (/* @__PURE__ */ objHasOwnProperty(target, Prototype)) {
return target.name || unknownValue || UnknownValue;
}
return ((target || {})[Constructor] || {}).name || unknownValue || UnknownValue;
}
function dynamicProto(theClass, target, delegateFunc, options) {
if (!/* @__PURE__ */ objHasOwnProperty(theClass, Prototype)) {
_throwTypeError("theClass is an invalid class definition.");
}
var classProto = theClass[Prototype];
if (!_checkPrototype(classProto, target)) {
_throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
}
var className = null;
if (/* @__PURE__ */ objHasOwnProperty(classProto, DynClassName)) {
className = classProto[DynClassName];
} else {
className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
_gblInst.n++;
classProto[DynClassName] = className;
}
var perfOptions = dynamicProto[DynProtoDefaultOptions];
var useBaseInst = !!perfOptions[strUseBaseInst];
if (useBaseInst && options && options[strUseBaseInst] !== void 0) {
useBaseInst = !!options[strUseBaseInst];
}
var instFuncs = _getInstanceFuncs(target);
var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
delegateFunc(target, baseFuncs);
var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
if (setInstanceFunc && options) {
setInstanceFunc = !!options[strSetInstFuncs];
}
_populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
}
dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
var createEnumStyle = createEnum;
var EventsDiscardedReason = /* @__PURE__ */ createEnumStyle({
Unknown: 0,
NonRetryableStatus: 1,
InvalidEvent: 2,
SizeLimitExceeded: 3,
KillSwitch: 4,
QueueFull: 5
});
var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
var _DYN_LENGTH$2 = "length";
var _DYN_WARN_TO_CONSOLE = "warnToConsole";
var _DYN_THROW_INTERNAL = "throwInternal";
var _DYN_WATCH = "watch";
var _DYN_APPLY = "apply";
var _DYN_PUSH$1 = "push";
var _DYN_SPLICE = "splice";
var _DYN_LOGGER = "logger";
var _DYN_CANCEL = "cancel";
var _DYN_INITIALIZE$1 = "initialize";
var _DYN_IDENTIFIER$1 = "identifier";
var _DYN_IS_INITIALIZED = "isInitialized";
var _DYN_GET_PLUGIN = "getPlugin";
var _DYN_NAME = "name";
var _DYN_PROCESS_NEXT = "processNext";
var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
var _DYN_VALUE$1 = "value";
var _DYN_UNLOAD = "unload";
var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
var _DYN_CREATE_NEW = "createNew";
var _DYN_TEARDOWN = "teardown";
var _DYN_MESSAGE_ID = "messageId";
var _DYN_MESSAGE = "message";
var _DYN_DIAG_LOG = "diagLog";
var _DYN__DO_TEARDOWN = "_doTeardown";
var _DYN_UPDATE = "update";
var _DYN_GET_NEXT = "getNext";
var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
var _DYN_USER_AGENT = "userAgent";
var _DYN_SPLIT$1 = "split";
var _DYN_REPLACE = "replace";
var _DYN_SUBSTRING = "substring";
var _DYN_INDEX_OF = "indexOf";
var _DYN_TYPE = "type";
var _DYN_EVT_NAME = "evtName";
var _DYN_STATUS = "status";
var _DYN_GET_ALL_RESPONSE_HEA5 = "getAllResponseHeaders";
var _DYN_IS_CHILD_EVT = "isChildEvt";
var _DYN_DATA = "data";
var _DYN_GET_CTX = "getCtx";
var _DYN_SET_CTX = "setCtx";
var _DYN_HEADERS$1 = "headers";
var _DYN_URL_STRING = "urlString";
var _DYN_TIMEOUT = "timeout";
var aggregationErrorType;
function throwAggregationError(message, sourceErrors) {
if (!aggregationErrorType) {
aggregationErrorType = /* @__PURE__ */ createCustomError("AggregationError", function(self2, args) {
if (args[_DYN_LENGTH$2] > 1) {
self2.errors = args[1];
}
});
}
var theMessage = message || "One or more errors occurred.";
arrForEach(sourceErrors, function(srcError, idx) {
theMessage += "\n".concat(idx, " > ").concat(/* @__PURE__ */ dumpObj(srcError));
});
throw new aggregationErrorType(theMessage, sourceErrors || []);
}
var STR_PROMISE = "Promise";
var REJECTED = "rejected";
function doAwaitResponse(value, cb) {
return doAwait(value, function(value2) {
return cb ? cb({
status: "fulfilled",
rejected: false,
value: value2
}) : value2;
}, function(reason) {
return cb ? cb({
status: REJECTED,
rejected: true,
reason
}) : reason;
});
}
function doAwait(value, resolveFn, rejectFn, finallyFn) {
var result = value;
try {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (resolveFn || rejectFn) {
result = value.then(resolveFn, rejectFn);
}
} else {
try {
if (resolveFn) {
result = resolveFn(value);
}
} catch (err) {
if (rejectFn) {
result = rejectFn(err);
} else {
throw err;
}
}
}
} finally {
if (finallyFn) {
doFinally(result, finallyFn);
}
}
return result;
}
function doFinally(value, finallyFn) {
var result = value;
if (finallyFn) {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (value.finally) {
result = value.finally(finallyFn);
} else {
result = value.then(function(value2) {
finallyFn();
return value2;
}, function(reason) {
finallyFn();
throw reason;
});
}
} else {
finallyFn();
}
}
return result;
}
var STRING_STATES = [
"pending",
"resolving",
"resolved",
REJECTED
];
var DISPATCH_EVENT = "dispatchEvent";
var _hasInitEvent;
function _hasInitEventFn(doc) {
var evt;
if (doc && doc.createEvent) {
evt = doc.createEvent("Event");
}
return !!evt && evt.initEvent;
}
function emitEvent(target, evtName, populateEvent, useNewEvent) {
var doc = getDocument();
!_hasInitEvent && (_hasInitEvent = /* @__PURE__ */ createCachedValue(!!safe(_hasInitEventFn, [doc]).v));
var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : useNewEvent ? new Event(evtName) : {};
populateEvent && populateEvent(theEvt);
if (_hasInitEvent.v) {
theEvt.initEvent(evtName, false, true);
}
if (theEvt && target[DISPATCH_EVENT]) {
target[DISPATCH_EVENT](theEvt);
} else {
var handler = target["on" + evtName];
if (handler) {
handler(theEvt);
} else {
var theConsole = /* @__PURE__ */ getInst("console");
theConsole && (theConsole["error"] || theConsole["log"])(evtName, /* @__PURE__ */ dumpObj(theEvt));
}
}
}
var NODE_UNHANDLED_REJECTION = "unhandledRejection";
var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
var _unhandledRejectionTimeout = 10;
var _hasPromiseRejectionEvent;
function dumpFnObj(value) {
if (isFunction(value)) {
return value.toString();
}
return /* @__PURE__ */ dumpObj(value);
}
function _createPromise(newPromise, processor, executor) {
var additionalArgs = arrSlice(arguments, 3);
var _state = 0;
var _hasResolved = false;
var _settledValue;
var _queue = [];
var _handled = false;
var _unHandledRejectionHandler = null;
var _thePromise;
function _then(onResolved, onRejected) {
try {
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
var thenPromise = newPromise(function(resolve3, reject) {
_queue.push(function() {
try {
var handler = _state === 2 ? onResolved : onRejected;
var value = /* @__PURE__ */ isUndefined(handler) ? _settledValue : isFunction(handler) ? handler(_settledValue) : handler;
if (/* @__PURE__ */ isPromiseLike(value)) {
value.then(resolve3, reject);
} else if (handler) {
resolve3(value);
} else if (_state === 3) {
reject(value);
} else {
resolve3(value);
}
} catch (e) {
reject(e);
}
});
if (_hasResolved) {
_processQueue();
}
}, additionalArgs);
return thenPromise;
} finally {
}
}
function _catch(onRejected) {
return _then(void 0, onRejected);
}
function _finally(onFinally) {
var thenFinally = onFinally;
var catchFinally = onFinally;
if (isFunction(onFinally)) {
thenFinally = function(value) {
onFinally && onFinally();
return value;
};
catchFinally = function(reason) {
onFinally && onFinally();
throw reason;
};
}
return _then(thenFinally, catchFinally);
}
function _strState() {
return STRING_STATES[_state];
}
function _processQueue() {
if (_queue.length > 0) {
var pending = _queue.slice();
_queue = [];
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
processor(pending);
}
}
function _createSettleIfFn(newState, allowState) {
return function(theValue) {
if (_state === allowState) {
if (newState === 2 && /* @__PURE__ */ isPromiseLike(theValue)) {
_state = 1;
theValue.then(_createSettleIfFn(2, 1), _createSettleIfFn(3, 1));
return;
}
_state = newState;
_hasResolved = true;
_settledValue = theValue;
_processQueue();
if (!_handled && newState === 3 && !_unHandledRejectionHandler) {
_unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
}
}
};
}
function _notifyUnhandledRejection() {
if (!_handled) {
_handled = true;
if (isNode()) {
process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
} else {
var gbl = getWindow() || getGlobal();
!_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE + "RejectionEvent"]).v));
emitEvent(gbl, UNHANDLED_REJECTION, function(theEvt) {
objDefine(theEvt, "promise", { g: function() {
return _thePromise;
} });
theEvt.reason = _settledValue;
return theEvt;
}, !!_hasPromiseRejectionEvent.v);
}
}
}
_thePromise = {
then: _then,
"catch": _catch,
finally: _finally
};
objDefineProp(_thePromise, "state", {
get: _strState
});
if (/* @__PURE__ */ hasSymbol()) {
_thePromise[/* @__PURE__ */ getKnownSymbol(11)] = "IPromise";
}
function _toString() {
return "IPromise " + _strState() + (_hasResolved ? " - " + dumpFnObj(_settledValue) : "");
}
_thePromise.toString = _toString;
(function _initialize() {
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
}
var _rejectFn = _createSettleIfFn(3, 0);
try {
executor.call(_thePromise, _createSettleIfFn(2, 0), _rejectFn);
} catch (e) {
_rejectFn(e);
}
})();
return _thePromise;
}
function syncItemProcessor(pending) {
arrForEach(pending, function(fn) {
try {
fn();
} catch (e) {
}
});
}
function timeoutItemProcessor(timeout) {
var callbackTimeout = isNumber(timeout) ? timeout : 0;
return function(pending) {
scheduleTimeout(function() {
syncItemProcessor(pending);
}, callbackTimeout);
};
}
function createAsyncPromise(executor, timeout) {
return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
}
var _promiseCls;
function createNativePromise(executor, timeout) {
!_promiseCls && (_promiseCls = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE]).v || null));
var PrmCls = _promiseCls.v;
if (!PrmCls) {
return createAsyncPromise(executor);
}
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + /* @__PURE__ */ dumpObj(executor));
}
var _state = 0;
function _strState() {
return STRING_STATES[_state];
}
var thePromise = new PrmCls(function(resolve3, reject) {
function _resolve(value) {
_state = 2;
resolve3(value);
}
function _reject(reason) {
_state = 3;
reject(reason);
}
executor(_resolve, _reject);
});
objDefineProp(thePromise, "state", {
get: _strState
});
return thePromise;
}
var _promiseCreator;
function createPromise(executor, timeout) {
!_promiseCreator && (_promiseCreator = /* @__PURE__ */ createCachedValue(createNativePromise));
return _promiseCreator.v.call(this, executor, timeout);
}
var UNDEFINED_VALUE = void 0;
var STR_EMPTY$3 = "";
var STR_CORE = "core";
var STR_DISABLED = "disabled";
var STR_EXTENSION_CONFIG = "extensionConfig";
var STR_PROCESS_TELEMETRY = "processTelemetry";
var STR_PRIORITY = "priority";
var STR_GET_PERF_MGR = "getPerfMgr";
var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
var rCamelCase = /-([a-z])/g;
var rNormalizeInvalid = /([^\w\d_$])/g;
var rLeadingNumeric = /^(\d+[\w\d_$])/;
function isNotNullOrUndefined(value) {
return !/* @__PURE__ */ isNullOrUndefined(value);
}
function normalizeJsName(name) {
var value = name;
if (value && isString(value)) {
value = value[_DYN_REPLACE](rCamelCase, function(_all, letter) {
return letter.toUpperCase();
});
value = value[_DYN_REPLACE](rNormalizeInvalid, "_");
value = value[_DYN_REPLACE](rLeadingNumeric, function(_all, match) {
return "_" + match;
});
}
return value;
}
function strContains(value, search) {
if (value && search) {
return strIndexOf(value, search) !== -1;
}
return false;
}
function _createProxyFunction(source, funcName) {
var srcFunc = null;
var src = null;
if (isFunction(source)) {
srcFunc = source;
} else {
src = source;
}
return function() {
var originalArguments = arguments;
if (srcFunc) {
src = srcFunc();
}
if (src) {
return src[funcName][_DYN_APPLY](src, originalArguments);
}
};
}
function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
if (target && name && source) {
if (overwriteTarget !== false || /* @__PURE__ */ isUndefined(target[name])) {
target[name] = _createProxyFunction(source, theFunc);
}
}
}
function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
if (target && source && /* @__PURE__ */ isObject(target) && isArray(functionsToProxy)) {
arrForEach(functionsToProxy, function(theFuncName) {
if (isString(theFuncName)) {
proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
}
});
}
return target;
}
function optimizeObject(theObject) {
if (theObject && objAssign) {
theObject = ObjClass$1(objAssign({}, theObject));
}
return theObject;
}
function isFeatureEnabled(feature, cfg, sdkDefaultState) {
var ft = cfg && cfg.featureOptIn && cfg.featureOptIn[feature];
if (feature && ft) {
var mode = ft.mode;
if (mode === 3) {
return true;
} else if (mode === 2) {
return false;
}
}
return sdkDefaultState;
}
function getResponseText(xhr) {
try {
return xhr.responseText;
} catch (e) {
}
return null;
}
function formatErrorMessageXdr(xdr, message) {
if (xdr) {
return "XDomainRequest,Response:" + getResponseText(xdr) || "";
}
return message;
}
function formatErrorMessageXhr(xhr, message) {
if (xhr) {
return "XMLHttpRequest,Status:" + xhr[_DYN_STATUS] + ",Response:" + getResponseText(xhr) || xhr.response || "";
}
return message;
}
function prependTransports(theTransports, newTransports) {
if (newTransports) {
if (isNumber(newTransports)) {
theTransports = [newTransports].concat(theTransports);
} else if (isArray(newTransports)) {
theTransports = newTransports.concat(theTransports);
}
}
return theTransports;
}
var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var strWithCredentials = "withCredentials";
var strTimeout = "timeout";
function openXhr(method, urlString, withCredentials, disabled, isSync, timeout) {
if (disabled === void 0) {
disabled = false;
}
if (isSync === void 0) {
isSync = false;
}
function _wrapSetXhrProp(xhr2, prop, value) {
try {
xhr2[prop] = value;
} catch (e) {
}
}
var xhr = new XMLHttpRequest();
if (disabled) {
_wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
}
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
xhr.open(method, urlString, !isSync);
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
if (!isSync && timeout) {
_wrapSetXhrProp(xhr, strTimeout, timeout);
}
return xhr;
}
function convertAllHeadersToMap(headersString) {
var headers = {};
if (isString(headersString)) {
var headersArray = strTrim(headersString)[_DYN_SPLIT$1](/[\r\n]+/);
arrForEach(headersArray, function(headerEntry) {
if (headerEntry) {
var idx = headerEntry[_DYN_INDEX_OF](": ");
if (idx !== -1) {
var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE$1]();
var value = strTrim(headerEntry[_DYN_SUBSTRING](idx + 1));
headers[header] = value;
} else {
headers[strTrim(headerEntry)] = 1;
}
}
});
}
return headers;
}
function _appendHeader(theHeaders, xhr, name) {
if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
var value = xhr.getResponseHeader(name);
if (value) {
theHeaders[name] = strTrim(value);
}
}
return theHeaders;
}
var STR_KILL_DURATION_HEADER$1 = "kill-duration";
var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
var STR_TIME_DELTA_HEADER$1 = "time-delta-millis";
function _getAllResponseHeaders(xhr, isOneDs) {
var theHeaders = {};
if (!xhr[_DYN_GET_ALL_RESPONSE_HEA5]) {
if (!!isOneDs) {
theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER$1);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER$1);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
}
} else {
theHeaders = convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA5]());
}
return theHeaders;
}
var strLocation = "location";
var strConsole = "console";
var strJSON = "JSON";
var strCrypto = "crypto";
var strMsCrypto = "msCrypto";
var strReactNative = "ReactNative";
var strMsie = "msie";
var strTrident = "trident/";
var strXMLHttpRequest = "XMLHttpRequest";
var _isTrident = null;
var _navUserAgentCheck = null;
var _enableMocks = false;
var _useXDomainRequest = null;
var _beaconsSupported = null;
function _hasProperty(theClass, property) {
var supported = false;
if (theClass) {
try {
supported = property in theClass;
if (!supported) {
var proto = theClass[strShimPrototype];
if (proto) {
supported = property in proto;
}
}
} catch (e) {
}
if (!supported) {
try {
var tmp = new theClass();
supported = !/* @__PURE__ */ isUndefined(tmp[property]);
} catch (e) {
}
}
}
return supported;
}
function getLocation(checkForMock) {
if (checkForMock && _enableMocks) {
var mockLocation = /* @__PURE__ */ getInst("__mockLocation");
if (mockLocation) {
return mockLocation;
}
}
if (typeof location === strShimObject && location) {
return location;
}
return /* @__PURE__ */ getInst(strLocation);
}
function getConsole() {
if (typeof console !== strShimUndefined) {
return console;
}
return /* @__PURE__ */ getInst(strConsole);
}
function hasJSON() {
return Boolean(typeof JSON === strShimObject && JSON || /* @__PURE__ */ getInst(strJSON) !== null);
}
function getJSON() {
if (hasJSON()) {
return JSON || /* @__PURE__ */ getInst(strJSON);
}
return null;
}
function getCrypto() {
return /* @__PURE__ */ getInst(strCrypto);
}
function getMsCrypto() {
return /* @__PURE__ */ getInst(strMsCrypto);
}
function isReactNative() {
var nav = getNavigator();
if (nav && nav.product) {
return nav.product === strReactNative;
}
return false;
}
function isIE() {
var nav = getNavigator();
if (nav && (nav[_DYN_USER_AGENT] !== _navUserAgentCheck || _isTrident === null)) {
_navUserAgentCheck = nav[_DYN_USER_AGENT];
var userAgent = (_navUserAgentCheck || STR_EMPTY$3)[_DYN_TO_LOWER_CASE$1]();
_isTrident = strContains(userAgent, strMsie) || strContains(userAgent, strTrident);
}
return _isTrident;
}
function isBeaconsSupported(useCached) {
if (_beaconsSupported === null || useCached === false) {
_beaconsSupported = /* @__PURE__ */ hasNavigator() && Boolean(getNavigator().sendBeacon);
}
return _beaconsSupported;
}
function isFetchSupported(withKeepAlive) {
var isSupported = false;
try {
isSupported = !!/* @__PURE__ */ getInst("fetch");
var request = /* @__PURE__ */ getInst("Request");
if (isSupported && withKeepAlive && request) {
isSupported = _hasProperty(request, "keepalive");
}
} catch (e) {
}
return isSupported;
}
function useXDomainRequest() {
if (_useXDomainRequest === null) {
_useXDomainRequest = typeof XDomainRequest !== strShimUndefined;
if (_useXDomainRequest && isXhrSupported()) {
_useXDomainRequest = _useXDomainRequest && !_hasProperty(/* @__PURE__ */ getInst(strXMLHttpRequest), "withCredentials");
}
}
return _useXDomainRequest;
}
function isXhrSupported() {
var isSupported = false;
try {
var xmlHttpRequest = /* @__PURE__ */ getInst(strXMLHttpRequest);
isSupported = !!xmlHttpRequest;
} catch (e) {
}
return isSupported;
}
var UInt32Mask = 4294967296;
var MaxUInt32 = 4294967295;
var SEED1 = 123456789;
var SEED2 = 987654321;
var _mwcSeeded = false;
var _mwcW = SEED1;
var _mwcZ = SEED2;
function _mwcSeed(seedValue) {
if (seedValue < 0) {
seedValue >>>= 0;
}
_mwcW = SEED1 + seedValue & MaxUInt32;
_mwcZ = SEED2 - seedValue & MaxUInt32;
_mwcSeeded = true;
}
function _autoSeedMwc() {
try {
var now = /* @__PURE__ */ utcNow() & 2147483647;
_mwcSeed((Math.random() * UInt32Mask ^ now) + now);
} catch (e) {
}
}
function random32(signed) {
var value = 0;
var c = getCrypto() || getMsCrypto();
if (c && c.getRandomValues) {
value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
}
if (value === 0 && isIE()) {
if (!_mwcSeeded) {
_autoSeedMwc();
}
value = mwcRandom32() & MaxUInt32;
}
if (value === 0) {
value = mathFloor(UInt32Mask * Math.random() | 0);
}
if (!signed) {
value >>>= 0;
}
return value;
}
function mwcRandom32(signed) {
_mwcZ = 36969 * (_mwcZ & 65535) + (_mwcZ >> 16) & MaxUInt32;
_mwcW = 18e3 * (_mwcW & 65535) + (_mwcW >> 16) & MaxUInt32;
var value = (_mwcZ << 16) + (_mwcW & 65535) >>> 0 & MaxUInt32 | 0;
if (!signed) {
value >>>= 0;
}
return value;
}
function newId(maxLength) {
if (maxLength === void 0) {
maxLength = 22;
}
var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var number = random32() >>> 0;
var chars = 0;
var result = STR_EMPTY$3;
while (result[_DYN_LENGTH$2] < maxLength) {
chars++;
result += base64chars.charAt(number & 63);
number >>>= 6;
if (chars === 5) {
number = (random32() << 2 & 4294967295 | number & 3) >>> 0;
chars = 0;
}
}
return result;
}
var version = "3.3.10";
var instanceName = "." + newId(6);
var _dataUid = 0;
function _canAcceptData(target) {
return target.nodeType === 1 || target.nodeType === 9 || !+target.nodeType;
}
function _getCache(data, target) {
var theCache = target[data.id];
if (!theCache) {
theCache = {};
try {
if (_canAcceptData(target)) {
objDefine(target, data.id, {
e: false,
v: theCache
});
}
} catch (e) {
}
}
return theCache;
}
function createUniqueNamespace(name, includeVersion) {
if (includeVersion === void 0) {
includeVersion = false;
}
return normalizeJsName(name + _dataUid++ + (includeVersion ? "." + version : STR_EMPTY$3) + instanceName);
}
function createElmNodeData(name) {
var data = {
id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$3) + "." + version),
accept: function(target) {
return _canAcceptData(target);
},
get: function(target, name2, defValue, addDefault) {
var theCache = target[data.id];
if (!theCache) {
if (addDefault) {
theCache = _getCache(data, target);
theCache[normalizeJsName(name2)] = defValue;
}
return defValue;
}
return theCache[normalizeJsName(name2)];
},
kill: function(target, name2) {
if (target && target[name2]) {
try {
delete target[name2];
} catch (e) {
}
}
}
};
return data;
}
function _isConfigDefaults(value) {
return value && /* @__PURE__ */ isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set);
}
function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
var defValue;
var isDefaultValid = cfgDefaults.dfVal || isDefined;
if (theConfig && cfgDefaults.fb) {
var fallbacks = cfgDefaults.fb;
if (!isArray(fallbacks)) {
fallbacks = [fallbacks];
}
for (var lp = 0; lp < fallbacks[_DYN_LENGTH$2]; lp++) {
var fallback = fallbacks[lp];
var fbValue = theConfig[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
} else if (dynamicHandler) {
fbValue = dynamicHandler.cfg[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
}
dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
}
if (isDefaultValid(defValue)) {
break;
}
}
}
if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
defValue = cfgDefaults.v;
}
return defValue;
}
function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
var theValue = cfgDefaults;
if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
}
if (theValue) {
if (_isConfigDefaults(theValue)) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
}
var newValue_1;
if (isArray(theValue)) {
newValue_1 = [];
newValue_1[_DYN_LENGTH$2] = theValue[_DYN_LENGTH$2];
} else if (/* @__PURE__ */ isPlainObject(theValue)) {
newValue_1 = {};
}
if (newValue_1) {
objForEachKey(theValue, function(key, value) {
if (value && _isConfigDefaults(value)) {
value = _resolveDefaultValue(dynamicHandler, theConfig, value);
}
newValue_1[key] = value;
});
theValue = newValue_1;
}
}
return theValue;
}
function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
var isValid;
var setFn;
var defValue;
var cfgDefaults = defaultValue;
var mergeDf;
var reference;
var readOnly;
var blkDynamicValue;
if (_isConfigDefaults(cfgDefaults)) {
isValid = cfgDefaults.isVal;
setFn = cfgDefaults.set;
readOnly = cfgDefaults.rdOnly;
blkDynamicValue = cfgDefaults.blkVal;
mergeDf = cfgDefaults.mrg;
reference = cfgDefaults.ref;
if (!reference && /* @__PURE__ */ isUndefined(reference)) {
reference = !!mergeDf;
}
defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
} else {
defValue = defaultValue;
}
if (blkDynamicValue) {
dynamicHandler.blkVal(theConfig, name);
}
var theValue;
var usingDefault = true;
var cfgValue = theConfig[name];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
theValue = cfgValue;
usingDefault = false;
if (isValid && theValue !== defValue && !isValid(theValue)) {
theValue = defValue;
usingDefault = true;
}
if (setFn) {
theValue = setFn(theValue, defValue, theConfig);
usingDefault = theValue === defValue;
}
}
if (!usingDefault) {
if (/* @__PURE__ */ isPlainObject(theValue) || isArray(defValue)) {
if (mergeDf && defValue && (/* @__PURE__ */ isPlainObject(defValue) || isArray(defValue))) {
objForEachKey(defValue, function(dfName, dfValue) {
_applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
});
}
}
} else if (defValue) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
} else {
theValue = defValue;
}
dynamicHandler.set(theConfig, name, theValue);
if (reference) {
dynamicHandler.ref(theConfig, name);
}
if (readOnly) {
dynamicHandler.rdOnly(theConfig, name);
}
}
var CFG_HANDLER_LINK = /* @__PURE__ */ symbolFor("[[ai_dynCfg_1]]");
var BLOCK_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_blkDynCfg_1]]");
var FORCE_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_frcDynCfg_1]]");
function _cfgDeepCopy(source) {
if (source) {
var target_1;
if (isArray(source)) {
target_1 = [];
target_1[_DYN_LENGTH$2] = source[_DYN_LENGTH$2];
} else if (/* @__PURE__ */ isPlainObject(source)) {
target_1 = {};
}
if (target_1) {
objForEachKey(source, function(key, value) {
target_1[key] = _cfgDeepCopy(value);
});
return target_1;
}
}
return source;
}
function getDynamicConfigHandler(value) {
if (value) {
var handler = value[CFG_HANDLER_LINK] || value;
if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler;
}
}
return null;
}
function blockDynamicConversion(value) {
if (value && (/* @__PURE__ */ isPlainObject(value) || isArray(value))) {
try {
value[BLOCK_DYNAMIC] = true;
} catch (e) {
}
}
return value;
}
function _canMakeDynamic(getFunc, state, value) {
var result = false;
if (value && !getFunc[state.blkVal]) {
result = value[FORCE_DYNAMIC];
if (!result && !value[BLOCK_DYNAMIC]) {
result = /* @__PURE__ */ isPlainObject(value) || isArray(value);
}
}
return result;
}
function throwInvalidAccess(message) {
throwTypeError("InvalidAccess:" + message);
}
var arrayMethodsToPatch = [
"push",
"pop",
"shift",
"unshift",
"splice"
];
var _throwDynamicError = function(logger2, name, desc, e) {
logger2 && logger2[_DYN_THROW_INTERNAL](3, 108, "".concat(desc, " [").concat(name, "] failed - ") + /* @__PURE__ */ dumpObj(e));
};
function _patchArray(state, target, name) {
if (isArray(target)) {
arrForEach(arrayMethodsToPatch, function(method) {
var orgMethod = target[method];
target[method] = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var result = orgMethod[_DYN_APPLY](this, args);
_makeDynamicObject(state, target, name, "Patching");
return result;
};
});
}
}
function _getOwnPropGetter(target, name) {
var propDesc = objGetOwnPropertyDescriptor(target, name);
return propDesc && propDesc.get;
}
function _createDynamicProperty(state, theConfig, name, value) {
var detail = {
n: name,
h: [],
trk: function(handler) {
if (handler && handler.fn) {
if (arrIndexOf(detail.h, handler) === -1) {
detail.h[_DYN_PUSH$1](handler);
}
state.trk(handler, detail);
}
},
clr: function(handler) {
var idx = arrIndexOf(detail.h, handler);
if (idx !== -1) {
detail.h[_DYN_SPLICE](idx, 1);
}
}
};
var checkDynamic = true;
var isObjectOrArray = false;
function _getProperty() {
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
value = _makeDynamicObject(state, value, name, "Converting");
}
checkDynamic = false;
}
var activeHandler = state.act;
if (activeHandler) {
detail.trk(activeHandler);
}
return value;
}
_getProperty[state.prop] = {
chng: function() {
state.add(detail);
}
};
function _setProperty(newValue) {
if (value !== newValue) {
if (!!_getProperty[state.ro] && !state.upd) {
throwInvalidAccess("[" + name + "] is read-only:" + /* @__PURE__ */ dumpObj(theConfig));
}
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
checkDynamic = false;
}
var isReferenced = isObjectOrArray && _getProperty[state.rf];
if (isObjectOrArray) {
if (isReferenced) {
objForEachKey(value, function(key) {
value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
});
try {
objForEachKey(newValue, function(key, theValue) {
_setDynamicProperty(state, value, key, theValue);
});
newValue = value;
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Assigning", e);
isObjectOrArray = false;
}
} else if (value && value[CFG_HANDLER_LINK]) {
objForEachKey(value, function(key) {
var getter = _getOwnPropGetter(value, key);
if (getter) {
var valueState = getter[state.prop];
valueState && valueState.chng();
}
});
}
}
if (newValue !== value) {
var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
if (!isReferenced && newIsObjectOrArray) {
newValue = _makeDynamicObject(state, newValue, name, "Converting");
}
value = newValue;
isObjectOrArray = newIsObjectOrArray;
}
state.add(detail);
}
}
objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
}
function _setDynamicProperty(state, target, name, value) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
if (!isDynamic) {
_createDynamicProperty(state, target, name, value);
} else {
target[name] = value;
}
}
return target;
}
function _setDynamicPropertyState(state, target, name, flags) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
var inPlace = flags && flags[0];
var rdOnly = flags && flags[1];
var blkProp = flags && flags[2];
if (!isDynamic) {
if (blkProp) {
try {
blockDynamicConversion(target);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Blocking", e);
}
}
try {
_setDynamicProperty(state, target, name, target[name]);
getter = _getOwnPropGetter(target, name);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "State", e);
}
}
if (inPlace) {
getter[state.rf] = inPlace;
}
if (rdOnly) {
getter[state.ro] = rdOnly;
}
if (blkProp) {
getter[state.blkVal] = true;
}
}
return target;
}
function _makeDynamicObject(state, target, name, desc) {
try {
objForEachKey(target, function(key, value) {
_setDynamicProperty(state, target, key, value);
});
if (!target[CFG_HANDLER_LINK]) {
objDefineProp(target, CFG_HANDLER_LINK, {
get: function() {
return state.hdlr;
}
});
_patchArray(state, target, name);
}
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, desc, e);
}
return target;
}
var symPrefix = "[[ai_";
var symPostfix = "]]";
function _createState(cfgHandler) {
var dynamicPropertySymbol = /* @__PURE__ */ newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
var dynamicPropertyReadOnly = /* @__PURE__ */ newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
var dynamicPropertyReferenced = /* @__PURE__ */ newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
var dynamicPropertyBlockValue = /* @__PURE__ */ newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
var dynamicPropertyDetail = /* @__PURE__ */ newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
var _waitingHandlers = null;
var _watcherTimer = null;
var theState;
function _useHandler(activeHandler, callback) {
var prevWatcher = theState.act;
try {
theState.act = activeHandler;
if (activeHandler && activeHandler[dynamicPropertyDetail]) {
arrForEach(activeHandler[dynamicPropertyDetail], function(detail) {
detail.clr(activeHandler);
});
activeHandler[dynamicPropertyDetail] = [];
}
callback({
cfg: cfgHandler.cfg,
set: cfgHandler.set.bind(cfgHandler),
setDf: cfgHandler.setDf.bind(cfgHandler),
ref: cfgHandler.ref.bind(cfgHandler),
rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
});
} catch (e) {
var logger2 = cfgHandler[_DYN_LOGGER];
if (logger2) {
logger2[_DYN_THROW_INTERNAL](1, 107, /* @__PURE__ */ dumpObj(e));
}
throw e;
} finally {
theState.act = prevWatcher || null;
}
}
function _notifyWatchers() {
if (_waitingHandlers) {
var notifyHandlers = _waitingHandlers;
_waitingHandlers = null;
_watcherTimer && _watcherTimer[_DYN_CANCEL]();
_watcherTimer = null;
var watcherFailures_1 = [];
arrForEach(notifyHandlers, function(handler) {
if (handler) {
if (handler[dynamicPropertyDetail]) {
arrForEach(handler[dynamicPropertyDetail], function(detail) {
detail.clr(handler);
});
handler[dynamicPropertyDetail] = null;
}
if (handler.fn) {
try {
_useHandler(handler, handler.fn);
} catch (e) {
watcherFailures_1[_DYN_PUSH$1](e);
}
}
}
});
if (_waitingHandlers) {
try {
_notifyWatchers();
} catch (e) {
watcherFailures_1[_DYN_PUSH$1](e);
}
}
if (watcherFailures_1[_DYN_LENGTH$2] > 0) {
throwAggregationError("Watcher error(s): ", watcherFailures_1);
}
}
}
function _addWatcher(detail) {
if (detail && detail.h[_DYN_LENGTH$2] > 0) {
if (!_waitingHandlers) {
_waitingHandlers = [];
}
if (!_watcherTimer) {
_watcherTimer = scheduleTimeout(function() {
_watcherTimer = null;
_notifyWatchers();
}, 0);
}
for (var idx = 0; idx < detail.h[_DYN_LENGTH$2]; idx++) {
var handler = detail.h[idx];
if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
_waitingHandlers[_DYN_PUSH$1](handler);
}
}
}
}
function _trackHandler(handler, detail) {
if (handler) {
var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
if (arrIndexOf(details, detail) === -1) {
details[_DYN_PUSH$1](detail);
}
}
}
theState = {
prop: dynamicPropertySymbol,
ro: dynamicPropertyReadOnly,
rf: dynamicPropertyReferenced,
blkVal: dynamicPropertyBlockValue,
hdlr: cfgHandler,
add: _addWatcher,
notify: _notifyWatchers,
use: _useHandler,
trk: _trackHandler
};
return theState;
}
function _createAndUseHandler(state, configHandler) {
var handler = {
fn: configHandler,
rm: function() {
handler.fn = null;
state = null;
configHandler = null;
}
};
objDefine(handler, "toJSON", { v: function() {
return "WatcherHandler" + (handler.fn ? "" : "[X]");
} });
state.use(handler, configHandler);
return handler;
}
function _createDynamicHandler(logger2, target, inPlace) {
var dynamicHandler = getDynamicConfigHandler(target);
if (dynamicHandler) {
return dynamicHandler;
}
var uid = createUniqueNamespace("dyncfg", true);
var newTarget = target && inPlace !== false ? target : _cfgDeepCopy(target);
var theState;
function _notifyWatchers() {
theState.notify();
}
function _setValue(target2, name, value) {
try {
target2 = _setDynamicProperty(theState, target2, name, value);
} catch (e) {
_throwDynamicError(logger2, name, "Setting value", e);
}
return target2[name];
}
function _watch(configHandler) {
return _createAndUseHandler(theState, configHandler);
}
function _block(configHandler, allowUpdate) {
theState.use(null, function(details) {
var prevUpd = theState.upd;
try {
if (!/* @__PURE__ */ isUndefined(allowUpdate)) {
theState.upd = allowUpdate;
}
configHandler(details);
} finally {
theState.upd = prevUpd;
}
});
}
function _ref(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[0] = true, _a2))[name];
}
function _rdOnly(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[1] = true, _a2))[name];
}
function _blkPropValue(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[2] = true, _a2))[name];
}
function _applyDefaults(theConfig, defaultValues2) {
if (defaultValues2) {
objForEachKey(defaultValues2, function(name, value) {
_applyDefaultValue(cfgHandler, theConfig, name, value);
});
}
return theConfig;
}
var cfgHandler = {
uid: null,
cfg: newTarget,
logger: logger2,
notify: _notifyWatchers,
set: _setValue,
setDf: _applyDefaults,
watch: _watch,
ref: _ref,
rdOnly: _rdOnly,
blkVal: _blkPropValue,
_block
};
objDefine(cfgHandler, "uid", {
c: false,
e: false,
w: false,
v: uid
});
theState = _createState(cfgHandler);
_makeDynamicObject(theState, newTarget, "config", "Creating");
return cfgHandler;
}
function _logInvalidAccess(logger2, message) {
if (logger2) {
logger2[_DYN_WARN_TO_CONSOLE](message);
logger2[_DYN_THROW_INTERNAL](2, 108, message);
} else {
throwInvalidAccess(message);
}
}
function createDynamicConfig(config, defaultConfig, logger2, inPlace) {
var dynamicHandler = _createDynamicHandler(logger2, config || {}, inPlace);
if (defaultConfig) {
dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
}
return dynamicHandler;
}
function onConfigChange(config, configHandler, logger2) {
var handler = config[CFG_HANDLER_LINK] || config;
if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler[_DYN_WATCH](configHandler);
}
_logInvalidAccess(logger2, STR_NOT_DYNAMIC_ERROR + /* @__PURE__ */ dumpObj(config));
return createDynamicConfig(config, null, logger2)[_DYN_WATCH](configHandler);
}
var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var _aiNamespace = null;
function _getExtensionNamespace() {
var target = /* @__PURE__ */ getInst("Microsoft");
if (target) {
_aiNamespace = target["ApplicationInsights"];
}
return _aiNamespace;
}
function getDebugExt(config) {
var ns = _aiNamespace;
if (!ns && config.disableDbgExt !== true) {
ns = _aiNamespace || _getExtensionNamespace();
}
return ns ? ns["ChromeDbgExt"] : null;
}
var _a$3;
var STR_WARN_TO_CONSOLE = "warnToConsole";
var AiNonUserActionablePrefix = "AI (Internal): ";
var AiUserActionablePrefix = "AI: ";
var AIInternalMessagePrefix = "AITR_";
var defaultValues$1 = {
loggingLevelConsole: 0,
loggingLevelTelemetry: 1,
maxMessageLimit: 25,
enableDebug: false
};
var _logFuncs = (_a$3 = {}, _a$3[0] = null, _a$3[1] = "errorToConsole", _a$3[2] = STR_WARN_TO_CONSOLE, _a$3[3] = "debugToConsole", _a$3);
function _sanitizeDiagnosticText(text) {
if (text) {
return '"' + text[_DYN_REPLACE](/\"/g, STR_EMPTY$3) + '"';
}
return STR_EMPTY$3;
}
function _logToConsole(func, message) {
var theConsole = getConsole();
if (!!theConsole) {
var logFunc = "log";
if (theConsole[func]) {
logFunc = func;
}
if (isFunction(theConsole[logFunc])) {
theConsole[logFunc](message);
}
}
}
var _InternalLogMessage = (
/** @class */
(function() {
function _InternalLogMessage2(msgId, msg, isUserAct, properties) {
if (isUserAct === void 0) {
isUserAct = false;
}
var _self = this;
_self[_DYN_MESSAGE_ID] = msgId;
_self[_DYN_MESSAGE] = (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) + msgId;
var strProps = STR_EMPTY$3;
if (hasJSON()) {
strProps = getJSON().stringify(properties);
}
var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$3) + (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$3);
_self[_DYN_MESSAGE] += diagnosticText;
}
_InternalLogMessage2.dataType = "MessageData";
return _InternalLogMessage2;
})()
);
function safeGetLogger(core, config) {
return (core || {})[_DYN_LOGGER] || new DiagnosticLogger(config);
}
var DiagnosticLogger = (
/** @class */
(function() {
function DiagnosticLogger2(config) {
this.identifier = "DiagnosticLogger";
this.queue = [];
var _messageCount = 0;
var _messageLogged = {};
var _loggingLevelConsole;
var _loggingLevelTelemetry;
var _maxInternalMessageLimit;
var _enableDebug;
var _unloadHandler;
dynamicProto(DiagnosticLogger2, this, function(_self) {
_unloadHandler = _setDefaultsFromConfig(config || {});
_self.consoleLoggingLevel = function() {
return _loggingLevelConsole;
};
_self[_DYN_THROW_INTERNAL] = function(severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
if (_enableDebug) {
throw /* @__PURE__ */ dumpObj(message);
} else {
var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
if (!/* @__PURE__ */ isUndefined(message[_DYN_MESSAGE])) {
if (isUserAct) {
var messageKey = +message[_DYN_MESSAGE_ID];
if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE]);
_messageLogged[messageKey] = true;
}
} else {
if (_loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE]);
}
}
_logInternalMessage(severity, message);
} else {
_debugExtMsg("throw" + (severity === 1 ? "Critical" : "Warning"), message);
}
}
};
_self.debugToConsole = function(message) {
_logToConsole("debug", message);
_debugExtMsg("warning", message);
};
_self[_DYN_WARN_TO_CONSOLE] = function(message) {
_logToConsole("warn", message);
_debugExtMsg("warning", message);
};
_self.errorToConsole = function(message) {
_logToConsole("error", message);
_debugExtMsg("error", message);
};
_self.resetInternalMessageCount = function() {
_messageCount = 0;
_messageLogged = {};
};
_self.logInternalMessage = _logInternalMessage;
_self[_DYN_UNLOAD] = function(isAsync) {
_unloadHandler && _unloadHandler.rm();
_unloadHandler = null;
};
function _logInternalMessage(severity, message) {
if (_areInternalMessagesThrottled()) {
return;
}
var logMessage = true;
var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID];
if (_messageLogged[messageKey]) {
logMessage = false;
} else {
_messageLogged[messageKey] = true;
}
if (logMessage) {
if (severity <= _loggingLevelTelemetry) {
_self.queue[_DYN_PUSH$1](message);
_messageCount++;
_debugExtMsg(severity === 1 ? "error" : "warn", message);
}
if (_messageCount === _maxInternalMessageLimit) {
var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
var throttleMessage = new _InternalLogMessage(23, throttleLimitMessage, false);
_self.queue[_DYN_PUSH$1](throttleMessage);
if (severity === 1) {
_self.errorToConsole(throttleLimitMessage);
} else {
_self[_DYN_WARN_TO_CONSOLE](throttleLimitMessage);
}
}
}
}
function _setDefaultsFromConfig(config2) {
return onConfigChange(createDynamicConfig(config2, defaultValues$1, _self).cfg, function(details) {
var config3 = details.cfg;
_loggingLevelConsole = config3[_DYN_LOGGING_LEVEL_CONSOL4];
_loggingLevelTelemetry = config3.loggingLevelTelemetry;
_maxInternalMessageLimit = config3.maxMessageLimit;
_enableDebug = config3.enableDebug;
});
}
function _areInternalMessagesThrottled() {
return _messageCount >= _maxInternalMessageLimit;
}
function _debugExtMsg(name, data) {
var dbgExt = getDebugExt(config || {});
if (dbgExt && dbgExt[_DYN_DIAG_LOG]) {
dbgExt[_DYN_DIAG_LOG](name, data);
}
}
});
}
DiagnosticLogger2.__ieDyn = 1;
return DiagnosticLogger2;
})()
);
function _getLogger(logger2) {
return logger2 || new DiagnosticLogger();
}
function _throwInternal(logger2, severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
_getLogger(logger2)[_DYN_THROW_INTERNAL](severity, msgId, msg, properties, isUserAct);
}
function _warnToConsole(logger2, message) {
_getLogger(logger2)[_DYN_WARN_TO_CONSOLE](message);
}
var strExecutionContextKey = "ctx";
var strParentContextKey = "ParentContextKey";
var strChildrenContextKey = "ChildrenContextKey";
var PerfEvent = (
/** @class */
(function() {
function PerfEvent2(name, payloadDetails, isAsync) {
var _self = this;
_self.start = /* @__PURE__ */ utcNow();
_self[_DYN_NAME] = name;
_self.isAsync = isAsync;
_self[_DYN_IS_CHILD_EVT] = function() {
return false;
};
if (isFunction(payloadDetails)) {
var theDetails_1;
objDefine(_self, "payload", {
g: function() {
if (!theDetails_1 && isFunction(payloadDetails)) {
theDetails_1 = payloadDetails();
payloadDetails = null;
}
return theDetails_1;
}
});
}
_self[_DYN_GET_CTX] = function(key) {
if (key) {
if (key === PerfEvent2[strParentContextKey] || key === PerfEvent2[strChildrenContextKey]) {
return _self[key];
}
return (_self[strExecutionContextKey] || {})[key];
}
return null;
};
_self[_DYN_SET_CTX] = function(key, value) {
if (key) {
if (key === PerfEvent2[strParentContextKey]) {
if (!_self[key]) {
_self[_DYN_IS_CHILD_EVT] = function() {
return true;
};
}
_self[key] = value;
} else if (key === PerfEvent2[strChildrenContextKey]) {
_self[key] = value;
} else {
var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
ctx[key] = value;
}
}
};
_self.complete = function() {
var childTime = 0;
var childEvts = _self[_DYN_GET_CTX](PerfEvent2[strChildrenContextKey]);
if (isArray(childEvts)) {
for (var lp = 0; lp < childEvts[_DYN_LENGTH$2]; lp++) {
var childEvt = childEvts[lp];
if (childEvt) {
childTime += childEvt.time;
}
}
}
_self.time = /* @__PURE__ */ utcNow() - _self.start;
_self.exTime = _self.time - childTime;
_self.complete = function() {
};
};
}
PerfEvent2.ParentContextKey = "parent";
PerfEvent2.ChildrenContextKey = "childEvts";
return PerfEvent2;
})()
);
var doPerfActiveKey = "CoreUtils.doPerf";
function doPerf(mgrSource, getSource, func, details, isAsync) {
if (mgrSource) {
var perfMgr = mgrSource;
if (perfMgr[STR_GET_PERF_MGR]) {
perfMgr = perfMgr[STR_GET_PERF_MGR]();
}
if (perfMgr) {
var perfEvt = void 0;
var currentActive = perfMgr[_DYN_GET_CTX](doPerfActiveKey);
try {
perfEvt = perfMgr.create(getSource(), details, isAsync);
if (perfEvt) {
if (currentActive && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX](PerfEvent[strParentContextKey], currentActive);
if (currentActive[_DYN_GET_CTX] && currentActive[_DYN_SET_CTX]) {
var children = currentActive[_DYN_GET_CTX](PerfEvent[strChildrenContextKey]);
if (!children) {
children = [];
currentActive[_DYN_SET_CTX](PerfEvent[strChildrenContextKey], children);
}
children[_DYN_PUSH$1](perfEvt);
}
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, perfEvt);
return func(perfEvt);
}
} catch (ex) {
if (perfEvt && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX]("exception", ex);
}
} finally {
if (perfEvt) {
perfMgr.fire(perfEvt);
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, currentActive);
}
}
}
return func();
}
var pluginStateData = createElmNodeData("plugin");
function _getPluginState(plugin) {
return pluginStateData.get(plugin, "state", {}, true);
}
var strTelemetryPluginChain = "TelemetryPluginChain";
var strHasRunFlags = "_hasRun";
var strGetTelCtx = "_getTelCtx";
var _chainId = 0;
function _getNextProxyStart(proxy, core, startAt) {
while (proxy) {
if (proxy[_DYN_GET_PLUGIN]() === startAt) {
return proxy;
}
proxy = proxy[_DYN_GET_NEXT]();
}
return createTelemetryProxyChain([startAt], core.config || {}, core);
}
function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
var _nextProxy = null;
var _onComplete = [];
if (!dynamicHandler) {
dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER]);
}
if (startAt !== null) {
_nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
}
var context = {
_next: _moveNext,
ctx: {
core: function() {
return core;
},
diagLog: function() {
return safeGetLogger(core, dynamicHandler.cfg);
},
getCfg: function() {
return dynamicHandler.cfg;
},
getExtCfg: _resolveExtCfg,
getConfig: _getConfig,
hasNext: function() {
return !!_nextProxy;
},
getNext: function() {
return _nextProxy;
},
setNext: function(nextPlugin) {
_nextProxy = nextPlugin;
},
iterate: _iterateChain,
onComplete: _addOnComplete
}
};
function _addOnComplete(onComplete, that) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
if (onComplete) {
_onComplete[_DYN_PUSH$1]({
func: onComplete,
self: !/* @__PURE__ */ isUndefined(that) ? that : context.ctx,
args
});
}
}
function _moveNext() {
var nextProxy = _nextProxy;
_nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT]() : null;
if (!nextProxy) {
var onComplete = _onComplete;
if (onComplete && onComplete[_DYN_LENGTH$2] > 0) {
arrForEach(onComplete, function(completeDetails) {
try {
completeDetails.func.call(completeDetails.self, completeDetails.args);
} catch (e) {
_throwInternal(core[_DYN_LOGGER], 2, 73, "Unexpected Exception during onComplete - " + /* @__PURE__ */ dumpObj(e));
}
});
_onComplete = [];
}
}
return nextProxy;
}
function _getExtCfg(identifier, createIfMissing) {
var idCfg = null;
var cfg = dynamicHandler.cfg;
if (cfg && identifier) {
var extCfg = cfg[STR_EXTENSION_CONFIG];
if (!extCfg && createIfMissing) {
extCfg = {};
}
cfg[STR_EXTENSION_CONFIG] = extCfg;
extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
if (extCfg) {
idCfg = extCfg[identifier];
if (!idCfg && createIfMissing) {
idCfg = {};
}
extCfg[identifier] = idCfg;
idCfg = dynamicHandler.ref(extCfg, identifier);
}
}
return idCfg;
}
function _resolveExtCfg(identifier, defaultValues2) {
var newConfig = _getExtCfg(identifier, true);
if (defaultValues2) {
objForEachKey(defaultValues2, function(field, defaultValue) {
if (/* @__PURE__ */ isNullOrUndefined(newConfig[field])) {
var cfgValue = dynamicHandler.cfg[field];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
newConfig[field] = cfgValue;
}
}
_applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
});
}
return dynamicHandler.setDf(newConfig, defaultValues2);
}
function _getConfig(identifier, field, defaultValue) {
if (defaultValue === void 0) {
defaultValue = false;
}
var theValue;
var extConfig = _getExtCfg(identifier, false);
var rootConfig = dynamicHandler.cfg;
if (extConfig && (extConfig[field] || !/* @__PURE__ */ isNullOrUndefined(extConfig[field]))) {
theValue = extConfig[field];
} else if (rootConfig[field] || !/* @__PURE__ */ isNullOrUndefined(rootConfig[field])) {
theValue = rootConfig[field];
}
return theValue || !/* @__PURE__ */ isNullOrUndefined(theValue) ? theValue : defaultValue;
}
function _iterateChain(cb) {
var nextPlugin;
while (!!(nextPlugin = context._next())) {
var plugin = nextPlugin[_DYN_GET_PLUGIN]();
if (plugin) {
cb(plugin);
}
}
}
return context;
}
function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
var config = createDynamicConfig(cfg);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(env2) {
var nextPlugin = internalContext._next();
if (nextPlugin) {
nextPlugin[STR_PROCESS_TELEMETRY](env2, context);
}
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT](), config.cfg, core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(unloadState) {
var nextPlugin = internalContext._next();
nextPlugin && nextPlugin[_DYN_UNLOAD](context, unloadState);
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(updateState) {
return context.iterate(function(plugin) {
if (isFunction(plugin[_DYN_UPDATE])) {
plugin[_DYN_UPDATE](context, updateState);
}
});
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createTelemetryProxyChain(plugins, config, core, startAt) {
var firstProxy = null;
var add = startAt ? false : true;
if (isArray(plugins) && plugins[_DYN_LENGTH$2] > 0) {
var lastProxy_1 = null;
arrForEach(plugins, function(thePlugin) {
if (!add && startAt === thePlugin) {
add = true;
}
if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY])) {
var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
if (!firstProxy) {
firstProxy = newProxy;
}
if (lastProxy_1) {
lastProxy_1._setNext(newProxy);
}
lastProxy_1 = newProxy;
}
});
}
if (startAt && !firstProxy) {
return createTelemetryProxyChain([startAt], config, core);
}
return firstProxy;
}
function createTelemetryPluginProxy(plugin, config, core) {
var nextProxy = null;
var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY]);
var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN]);
var chainId;
if (plugin) {
chainId = plugin[_DYN_IDENTIFIER$1] + "-" + plugin[STR_PRIORITY] + "-" + _chainId++;
} else {
chainId = "Unknown-0-" + _chainId++;
}
var proxyChain = {
getPlugin: function() {
return plugin;
},
getNext: function() {
return nextProxy;
},
processTelemetry: _processTelemetry,
unload: _unloadPlugin,
update: _updatePlugin,
_id: chainId,
_setNext: function(nextPlugin) {
nextProxy = nextPlugin;
}
};
function _getTelCtx() {
var itemCtx;
if (plugin && isFunction(plugin[strGetTelCtx])) {
itemCtx = plugin[strGetTelCtx]();
}
if (!itemCtx) {
itemCtx = createProcessTelemetryContext(proxyChain, config, core);
}
return itemCtx;
}
function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
var hasRun = false;
var identifier = plugin ? plugin[_DYN_IDENTIFIER$1] : strTelemetryPluginChain;
var hasRunContext = itemCtx[strHasRunFlags];
if (!hasRunContext) {
hasRunContext = itemCtx[strHasRunFlags] = {};
}
itemCtx.setNext(nextProxy);
if (plugin) {
doPerf(itemCtx[STR_CORE](), function() {
return identifier + ":" + name;
}, function() {
hasRunContext[chainId] = true;
try {
var nextId = nextProxy ? nextProxy._id : STR_EMPTY$3;
if (nextId) {
hasRunContext[nextId] = false;
}
hasRun = processPluginFn(itemCtx);
} catch (error) {
var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
if (hasNextRun) {
hasRun = true;
}
if (!nextProxy || !hasNextRun) {
_throwInternal(itemCtx[_DYN_DIAG_LOG](), 1, 73, "Plugin [" + identifier + "] failed during " + name + " - " + /* @__PURE__ */ dumpObj(error) + ", run flags: " + /* @__PURE__ */ dumpObj(hasRunContext));
}
}
}, details, isAsync);
}
return hasRun;
}
function _processTelemetry(env2, itemCtx) {
itemCtx = itemCtx || _getTelCtx();
function _callProcessTelemetry(itemCtx2) {
if (!plugin || !hasProcessTelemetry) {
return false;
}
var pluginState = _getPluginState(plugin);
if (pluginState[_DYN_TEARDOWN] || pluginState[STR_DISABLED]) {
return false;
}
if (hasSetNext) {
plugin[_DYN_SET_NEXT_PLUGIN](nextProxy);
}
plugin[STR_PROCESS_TELEMETRY](env2, itemCtx2);
return true;
}
if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function() {
return { item: env2 };
}, !env2.sync)) {
itemCtx[_DYN_PROCESS_NEXT](env2);
}
}
function _unloadPlugin(unloadCtx, unloadState) {
function _callTeardown() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
pluginState[STR_CORE] = null;
pluginState[_DYN_TEARDOWN] = true;
pluginState[_DYN_IS_INITIALIZED] = false;
if (plugin[_DYN_TEARDOWN] && plugin[_DYN_TEARDOWN](unloadCtx, unloadState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(unloadCtx, _callTeardown, "unload", function() {
}, unloadState.isAsync)) {
unloadCtx[_DYN_PROCESS_NEXT](unloadState);
}
}
function _updatePlugin(updateCtx, updateState) {
function _callUpdate() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
if (plugin[_DYN_UPDATE] && plugin[_DYN_UPDATE](updateCtx, updateState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(updateCtx, _callUpdate, "update", function() {
}, false)) {
updateCtx[_DYN_PROCESS_NEXT](updateState);
}
}
return objFreeze(proxyChain);
}
function createUnloadHandlerContainer() {
var handlers = [];
function _addHandler(handler) {
if (handler) {
handlers[_DYN_PUSH$1](handler);
}
}
function _runHandlers(unloadCtx, unloadState) {
arrForEach(handlers, function(handler) {
try {
handler(unloadCtx, unloadState);
} catch (e) {
_throwInternal(unloadCtx[_DYN_DIAG_LOG](), 2, 73, "Unexpected error calling unload handler - " + /* @__PURE__ */ dumpObj(e));
}
});
handlers = [];
}
return {
add: _addHandler,
run: _runHandlers
};
}
function createUnloadHookContainer() {
var _hooks = [];
function _doUnload(logger2) {
var oldHooks = _hooks;
_hooks = [];
arrForEach(oldHooks, function(fn) {
try {
(fn.rm || fn.remove).call(fn);
} catch (e) {
_throwInternal(logger2, 2, 73, "Unloading:" + /* @__PURE__ */ dumpObj(e));
}
});
}
function _addHook(hooks) {
if (hooks) {
arrAppend(_hooks, hooks);
}
}
return {
run: _doUnload,
add: _addHook
};
}
var _a$2;
var strGetPlugin = "getPlugin";
var defaultValues = (_a$2 = {}, _a$2[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} }, _a$2);
var BaseTelemetryPlugin = (
/** @class */
(function() {
function BaseTelemetryPlugin2() {
var _self = this;
var _isinitialized;
var _rootCtx;
var _nextPlugin;
var _unloadHandlerContainer;
var _hookContainer;
_initDefaults();
dynamicProto(BaseTelemetryPlugin2, _self, function(_self2) {
_self2[_DYN_INITIALIZE$1] = function(config, core, extensions3, pluginChain) {
_setDefaults(config, core, pluginChain);
_isinitialized = true;
};
_self2[_DYN_TEARDOWN] = function(unloadCtx, unloadState) {
var core = _self2[STR_CORE];
if (!core || unloadCtx && core !== unloadCtx[STR_CORE]()) {
return;
}
var result;
var unloadDone = false;
var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUnloadState = unloadState || {
reason: 0,
isAsync: false
};
function _unloadCallback() {
if (!unloadDone) {
unloadDone = true;
_unloadHandlerContainer.run(theUnloadCtx, unloadState);
_hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG]());
if (result === true) {
theUnloadCtx[_DYN_PROCESS_NEXT](theUnloadState);
}
_initDefaults();
}
}
if (!_self2[_DYN__DO_TEARDOWN] || _self2[_DYN__DO_TEARDOWN](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
_unloadCallback();
} else {
result = true;
}
return result;
};
_self2[_DYN_UPDATE] = function(updateCtx, updateState) {
var core = _self2[STR_CORE];
if (!core || updateCtx && core !== updateCtx[STR_CORE]()) {
return;
}
var result;
var updateDone = false;
var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUpdateState = updateState || {
reason: 0
};
function _updateCallback() {
if (!updateDone) {
updateDone = true;
_setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT]());
}
}
if (!_self2._doUpdate || _self2._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
_updateCallback();
} else {
result = true;
}
return result;
};
proxyFunctionAs(_self2, "_addUnloadCb", function() {
return _unloadHandlerContainer;
}, "add");
proxyFunctionAs(_self2, "_addHook", function() {
return _hookContainer;
}, "add");
objDefine(_self2, "_unloadHooks", { g: function() {
return _hookContainer;
} });
});
_self[_DYN_DIAG_LOG] = function(itemCtx) {
return _getTelCtx(itemCtx)[_DYN_DIAG_LOG]();
};
_self[_DYN_IS_INITIALIZED] = function() {
return _isinitialized;
};
_self.setInitialized = function(isInitialized) {
_isinitialized = isInitialized;
};
_self[_DYN_SET_NEXT_PLUGIN] = function(next) {
_nextPlugin = next;
};
_self[_DYN_PROCESS_NEXT] = function(env2, itemCtx) {
if (itemCtx) {
itemCtx[_DYN_PROCESS_NEXT](env2);
} else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY])) {
_nextPlugin[STR_PROCESS_TELEMETRY](env2, null);
}
};
_self._getTelCtx = _getTelCtx;
function _getTelCtx(currentCtx) {
if (currentCtx === void 0) {
currentCtx = null;
}
var itemCtx = currentCtx;
if (!itemCtx) {
var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE]);
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin[strGetPlugin]);
} else {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin);
}
}
return itemCtx;
}
function _setDefaults(config, core, pluginChain) {
createDynamicConfig(config, defaultValues, safeGetLogger(core));
if (!pluginChain && core) {
pluginChain = core[_DYN_GET_PROCESS_TEL_CONT2]()[_DYN_GET_NEXT]();
}
var nextPlugin = _nextPlugin;
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
nextPlugin = _nextPlugin[strGetPlugin]();
}
_self[STR_CORE] = core;
_rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
}
function _initDefaults() {
_isinitialized = false;
_self[STR_CORE] = null;
_rootCtx = null;
_nextPlugin = null;
_hookContainer = createUnloadHookContainer();
_unloadHandlerContainer = createUnloadHandlerContainer();
}
}
BaseTelemetryPlugin2.__ieDyn = 1;
return BaseTelemetryPlugin2;
})()
);
var STR_EMPTY$2 = "";
var STR_NO_RESPONSE_BODY$1 = "NoResponseBody";
var _noResponseQs$1 = "&" + STR_NO_RESPONSE_BODY$1 + "=true";
var STR_POST_METHOD = "POST";
var SenderPostManager = (
/** @class */
(function() {
function SenderPostManager2() {
var _syncFetchPayload = 0;
var _enableSendPromise;
var _isInitialized;
var _diagLog;
var _isOneDs;
var _onCompleteFuncs;
var _disableCredentials;
var _fetchCredentials;
var _fallbackInst;
var _disableXhr;
var _disableBeacon;
var _disableBeaconSync;
var _disableFetchKeepAlive;
var _addNoResponse;
var _timeoutWrapper;
dynamicProto(SenderPostManager2, this, function(_self, _base) {
var _sendCredentials = true;
_initDefaults();
_self[_DYN_INITIALIZE$1] = function(config, diagLog) {
_diagLog = diagLog;
if (_isInitialized) {
_throwInternal(_diagLog, 1, 28, "Sender is already initialized");
}
_self.SetConfig(config);
_isInitialized = true;
};
_self["_getDbgPlgTargets"] = function() {
return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
};
_self.SetConfig = function(config) {
try {
_onCompleteFuncs = config.senderOnCompleteCallBack || {};
_disableCredentials = !!config.disableCredentials;
_fetchCredentials = config.fetchCredentials;
_isOneDs = !!config.isOneDs;
_enableSendPromise = !!config.enableSendPromise;
_disableXhr = !!config.disableXhr;
_disableBeacon = !!config.disableBeacon;
_disableBeaconSync = !!config.disableBeaconSync;
_timeoutWrapper = config.timeWrapper;
_addNoResponse = !!config.addNoResponse;
_disableFetchKeepAlive = !!config.disableFetchKeepAlive;
_fallbackInst = { sendPOST: _xhrSender };
if (!_isOneDs) {
_sendCredentials = false;
}
if (_disableCredentials) {
var location_1 = getLocation();
if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE$1]() === "file:") {
_sendCredentials = false;
}
}
return true;
} catch (e) {
}
return false;
};
_self.getSyncFetchPayload = function() {
return _syncFetchPayload;
};
_self.getSenderInst = function(transports, sync) {
if (transports && transports[_DYN_LENGTH$2]) {
return _getSenderInterface(transports, sync);
}
return null;
};
_self.getFallbackInst = function() {
return _fallbackInst;
};
_self[_DYN__DO_TEARDOWN] = function(unloadCtx, unloadState) {
_initDefaults();
};
_self.preparePayload = function(callback, zipPayload, payload, isSync) {
if (!zipPayload || isSync || !payload[_DYN_DATA]) {
callback(payload);
return;
}
try {
var csStream = /* @__PURE__ */ getInst("CompressionStream");
if (!isFunction(csStream)) {
callback(payload);
return;
}
var body = new ReadableStream({
start: function(controller) {
controller.enqueue(isString(payload[_DYN_DATA]) ? new TextEncoder().encode(payload[_DYN_DATA]) : payload[_DYN_DATA]);
controller.close();
}
});
var compressedStream = body.pipeThrough(new csStream("gzip"));
var reader_1 = compressedStream.getReader();
var chunks_1 = [];
var totalLength_1 = 0;
var callbackCalled_1 = false;
doAwaitResponse(reader_1.read(), function processChunk(response) {
if (!callbackCalled_1 && !response.rejected) {
var result = response[_DYN_VALUE$1];
if (!result.done) {
chunks_1[_DYN_PUSH$1](result[_DYN_VALUE$1]);
totalLength_1 += result.value[_DYN_LENGTH$2];
return doAwaitResponse(reader_1.read(), processChunk);
}
var combined = new Uint8Array(totalLength_1);
var offset = 0;
for (var _i = 0, chunks_2 = chunks_1; _i < chunks_2.length; _i++) {
var chunk = chunks_2[_i];
combined.set(chunk, offset);
offset += chunk[_DYN_LENGTH$2];
}
payload[_DYN_DATA] = combined;
payload[_DYN_HEADERS$1]["Content-Encoding"] = "gzip";
payload._chunkCount = chunks_1[_DYN_LENGTH$2];
}
if (!callbackCalled_1) {
callbackCalled_1 = true;
callback(payload);
}
});
return reader_1;
} catch (error) {
callback(payload);
return;
}
};
function _onSuccess(res, onComplete) {
_doOnComplete(onComplete, 200, {}, res);
}
function _onError(message, onComplete) {
_throwInternal(_diagLog, 2, 26, "Failed to send telemetry.", { message });
_doOnComplete(onComplete, 400, {});
}
function _onNoPayloadUrl(onComplete) {
_onError("No endpoint url is provided for the batch", onComplete);
}
function _getSenderInterface(transports, syncSupport) {
var transportType = 0;
var sendPostFunc = null;
var lp = 0;
while (sendPostFunc == null && lp < transports[_DYN_LENGTH$2]) {
transportType = transports[lp];
if (!_disableXhr && transportType === 1) {
if (useXDomainRequest()) {
sendPostFunc = _xdrSender;
} else if (isXhrSupported()) {
sendPostFunc = _xhrSender;
}
} else if (transportType === 2 && isFetchSupported(syncSupport) && (!syncSupport || !_disableFetchKeepAlive)) {
sendPostFunc = _doFetchSender;
} else if (transportType === 3 && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
sendPostFunc = _beaconSender;
}
lp++;
}
if (sendPostFunc) {
return {
_transport: transportType,
_isSync: syncSupport,
sendPOST: sendPostFunc
};
}
return null;
}
function _doOnComplete(oncomplete, status, headers, response) {
try {
oncomplete && oncomplete(status, headers, response);
} catch (e) {
}
}
function _doBeaconSend(payload, oncomplete) {
var nav = getNavigator();
var url = payload[_DYN_URL_STRING];
if (!url) {
_onNoPayloadUrl(oncomplete);
return true;
}
url = payload[_DYN_URL_STRING] + (_addNoResponse ? _noResponseQs$1 : STR_EMPTY$2);
var data = payload[_DYN_DATA];
var plainTextBatch = _isOneDs ? data : new Blob([data], { type: "text/plain;charset=UTF-8" });
var queued = nav.sendBeacon(url, plainTextBatch);
return queued;
}
function _beaconSender(payload, oncomplete, sync) {
var data = payload[_DYN_DATA];
try {
if (data) {
if (!_doBeaconSend(payload, oncomplete)) {
var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
if (onRetry && isFunction(onRetry)) {
onRetry(payload, oncomplete, _doBeaconSend);
} else {
_fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
_throwInternal(_diagLog, 2, 40, ". Failed to send telemetry with Beacon API, retried with normal sender.");
}
} else {
_onSuccess(STR_EMPTY$2, oncomplete);
}
}
} catch (e) {
_isOneDs && _warnToConsole(_diagLog, "Failed to send telemetry using sendBeacon API. Ex:" + /* @__PURE__ */ dumpObj(e));
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, STR_EMPTY$2);
}
return;
}
function _xhrSender(payload, oncomplete, sync) {
var thePromise;
var resolveFunc;
var rejectFunc;
var headers = payload[_DYN_HEADERS$1] || {};
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (_isOneDs && sync && payload.disableXhrSync) {
sync = false;
}
var endPointUrl = payload[_DYN_URL_STRING];
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
var xhr = openXhr(STR_POST_METHOD, endPointUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT]);
if (!_isOneDs) {
xhr.setRequestHeader("Content-type", "application/json");
}
arrForEach(objKeys(headers), function(headerName) {
xhr.setRequestHeader(headerName, headers[headerName]);
});
xhr.onreadystatechange = function() {
if (!_isOneDs) {
_doOnReadyFunc(xhr);
if (xhr.readyState === 4) {
resolveFunc && resolveFunc(true);
}
}
};
xhr.onload = function() {
if (_isOneDs) {
_doOnReadyFunc(xhr);
}
};
function _doOnReadyFunc(xhr2) {
var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
if (onReadyFuncExist) {
onReadyFunc(xhr2, oncomplete, payload);
} else {
var response = getResponseText(xhr2);
_doOnComplete(oncomplete, xhr2[_DYN_STATUS], _getAllResponseHeaders(xhr2, _isOneDs), response);
}
}
xhr.onerror = function(event) {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 400, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$2 : formatErrorMessageXhr(xhr));
rejectFunc && rejectFunc(event);
};
xhr.ontimeout = function() {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 500, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$2 : formatErrorMessageXhr(xhr));
resolveFunc && resolveFunc(false);
};
xhr.send(payload[_DYN_DATA]);
return thePromise;
}
function _doFetchSender(payload, oncomplete, sync) {
var _a2;
var endPointUrl = payload[_DYN_URL_STRING];
var batch = payload[_DYN_DATA];
var plainTextBatch = _isOneDs ? batch : new Blob([batch], { type: "application/json" });
var thePromise;
var resolveFunc;
var rejectFunc;
var requestHeaders = new Headers();
var batchLength = batch[_DYN_LENGTH$2];
var ignoreResponse = false;
var responseHandled = false;
var headers = payload[_DYN_HEADERS$1] || {};
var init = (_a2 = {
method: STR_POST_METHOD,
body: plainTextBatch
}, _a2[DisabledPropertyName] = true, _a2);
if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH$2] > 0) {
arrForEach(objKeys(headers), function(headerName) {
requestHeaders.append(headerName, headers[headerName]);
});
init[_DYN_HEADERS$1] = requestHeaders;
}
if (_fetchCredentials) {
init.credentials = _fetchCredentials;
} else if (_sendCredentials && _isOneDs) {
init.credentials = "include";
}
if (sync) {
init.keepalive = true;
_syncFetchPayload += batchLength;
if (_isOneDs) {
if (payload["_sendReason"] === 2) {
ignoreResponse = true;
if (_addNoResponse) {
endPointUrl += _noResponseQs$1;
}
}
} else {
ignoreResponse = true;
}
}
var request = new Request(endPointUrl, init);
try {
request[DisabledPropertyName] = true;
} catch (e) {
}
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
function _handleError(res, statusCode) {
if (statusCode) {
_doOnComplete(oncomplete, _isOneDs ? 0 : statusCode, {}, _isOneDs ? STR_EMPTY$2 : res);
} else {
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, _isOneDs ? STR_EMPTY$2 : res);
}
}
function _onFetchComplete(response, payload2, value) {
var status = response[_DYN_STATUS];
var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
if (onCompleteFunc && isFunction(onCompleteFunc)) {
onCompleteFunc(response, oncomplete, value || STR_EMPTY$2, payload2);
} else {
_doOnComplete(oncomplete, status, {}, value || STR_EMPTY$2);
}
}
try {
doAwaitResponse(fetch(_isOneDs ? endPointUrl : request, _isOneDs ? init : null), function(result) {
if (sync) {
_syncFetchPayload -= batchLength;
batchLength = 0;
}
if (!responseHandled) {
responseHandled = true;
if (!result.rejected) {
var response_1 = result[_DYN_VALUE$1];
try {
if (!_isOneDs && !response_1.ok) {
if (response_1[_DYN_STATUS]) {
_handleError(response_1.statusText, response_1[_DYN_STATUS]);
} else {
_handleError(response_1.statusText, 499);
}
resolveFunc && resolveFunc(false);
} else {
if (_isOneDs && !response_1.body) {
_onFetchComplete(response_1, null, STR_EMPTY$2);
resolveFunc && resolveFunc(true);
} else {
doAwaitResponse(response_1.text(), function(resp) {
_onFetchComplete(response_1, payload, resp[_DYN_VALUE$1]);
resolveFunc && resolveFunc(true);
});
}
}
} catch (e) {
if (response_1 && response_1[_DYN_STATUS]) {
_handleError(/* @__PURE__ */ dumpObj(e), response_1[_DYN_STATUS]);
} else {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
}
rejectFunc && rejectFunc(e);
}
} else {
_handleError(result.reason && result.reason[_DYN_MESSAGE], 499);
rejectFunc && rejectFunc(result.reason);
}
}
});
} catch (e) {
if (!responseHandled) {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
rejectFunc && rejectFunc(e);
}
}
if (ignoreResponse && !responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 200, {});
resolveFunc && resolveFunc(true);
}
if (_isOneDs && !responseHandled && payload[_DYN_TIMEOUT] > 0) {
_timeoutWrapper && _timeoutWrapper.set(function() {
if (!responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 500, {});
resolveFunc && resolveFunc(true);
}
}, payload[_DYN_TIMEOUT]);
}
return thePromise;
}
function _xdrSender(payload, oncomplete, sync) {
var _window = getWindow();
var xdr = new XDomainRequest();
var data = payload[_DYN_DATA];
xdr.onload = function() {
var response = getResponseText(xdr);
var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
if (onloadFunc && isFunction(onloadFunc)) {
onloadFunc(xdr, oncomplete, payload);
} else {
_doOnComplete(oncomplete, 200, {}, response);
}
};
xdr.onerror = function() {
_doOnComplete(oncomplete, 400, {}, _isOneDs ? STR_EMPTY$2 : formatErrorMessageXdr(xdr));
};
xdr.ontimeout = function() {
_doOnComplete(oncomplete, 500, {});
};
xdr.onprogress = function() {
};
var hostingProtocol = _window && _window.location && _window.location.protocol || "";
var endpoint = payload[_DYN_URL_STRING];
if (!endpoint) {
_onNoPayloadUrl(oncomplete);
return;
}
if (!_isOneDs && endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
_throwInternal(_diagLog, 2, 40, ". " + msg);
_onError(msg, oncomplete);
return;
}
var endpointUrl = _isOneDs ? endpoint : endpoint[_DYN_REPLACE](/^(https?:)/, "");
xdr.open(STR_POST_METHOD, endpointUrl);
if (payload[_DYN_TIMEOUT]) {
xdr[_DYN_TIMEOUT] = payload[_DYN_TIMEOUT];
}
xdr.send(data);
if (_isOneDs && sync) {
_timeoutWrapper && _timeoutWrapper.set(function() {
xdr.send(data);
}, 0);
} else {
xdr.send(data);
}
}
function _initDefaults() {
_syncFetchPayload = 0;
_isInitialized = false;
_enableSendPromise = false;
_diagLog = null;
_isOneDs = null;
_onCompleteFuncs = null;
_disableCredentials = null;
_fetchCredentials = null;
_fallbackInst = null;
_disableXhr = false;
_disableBeacon = false;
_disableBeaconSync = false;
_disableFetchKeepAlive = false;
_addNoResponse = false;
_timeoutWrapper = null;
}
});
}
SenderPostManager2.__ieDyn = 1;
return SenderPostManager2;
})()
);
var strOnPrefix = "on";
var strAttachEvent = "attachEvent";
var strAddEventHelper = "addEventListener";
var strDetachEvent = "detachEvent";
var strRemoveEventListener = "removeEventListener";
var strEvents = "events";
var strVisibilityChangeEvt = "visibilitychange";
var strPageHide = "pagehide";
var strPageShow = "pageshow";
var strUnload = "unload";
var strBeforeUnload = "beforeunload";
var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
var rRemoveEmptyNs = /\.[\.]+/g;
var rRemoveTrailingEmptyNs = /[\.]+$/;
var _guid = 1;
var elmNodeData = createElmNodeData("events");
var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
function _normalizeNamespace(name) {
if (name && name[_DYN_REPLACE]) {
return name[_DYN_REPLACE](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$3);
}
return name;
}
function _getEvtNamespace(eventName, evtNamespace) {
if (evtNamespace) {
var theNamespace_1 = STR_EMPTY$3;
if (isArray(evtNamespace)) {
theNamespace_1 = STR_EMPTY$3;
arrForEach(evtNamespace, function(name) {
name = _normalizeNamespace(name);
if (name) {
if (name[0] !== ".") {
name = "." + name;
}
theNamespace_1 += name;
}
});
} else {
theNamespace_1 = _normalizeNamespace(evtNamespace);
}
if (theNamespace_1) {
if (theNamespace_1[0] !== ".") {
theNamespace_1 = "." + theNamespace_1;
}
eventName = (eventName || STR_EMPTY$3) + theNamespace_1;
}
}
var parsedEvent = eventNamespace.exec(eventName || STR_EMPTY$3) || [];
return {
type: parsedEvent[1],
ns: (parsedEvent[2] || STR_EMPTY$3).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$3)[_DYN_SPLIT$1](".").sort().join(".")
};
}
function _getRegisteredEvents(target, evtName, addDefault) {
if (addDefault === void 0) {
addDefault = true;
}
var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
var registeredEvents = aiEvts[evtName];
if (!registeredEvents) {
registeredEvents = aiEvts[evtName] = [];
}
return registeredEvents;
}
function _doDetach(obj, evtName, handlerRef, useCapture) {
if (obj && evtName && evtName[_DYN_TYPE]) {
if (obj[strRemoveEventListener]) {
obj[strRemoveEventListener](evtName[_DYN_TYPE], handlerRef, useCapture);
} else if (obj[strDetachEvent]) {
obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
}
}
}
function _doAttach(obj, evtName, handlerRef, useCapture) {
var result = false;
if (obj && evtName && evtName[_DYN_TYPE] && handlerRef) {
if (obj[strAddEventHelper]) {
obj[strAddEventHelper](evtName[_DYN_TYPE], handlerRef, useCapture);
result = true;
} else if (obj[strAttachEvent]) {
obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
result = true;
}
}
return result;
}
function _doUnregister(target, events, evtName, unRegFn) {
var idx = events[_DYN_LENGTH$2];
while (idx--) {
var theEvent = events[idx];
if (theEvent) {
if (!evtName.ns || evtName.ns === theEvent[_DYN_EVT_NAME].ns) {
if (!unRegFn || unRegFn(theEvent)) {
_doDetach(target, theEvent[_DYN_EVT_NAME], theEvent.handler, theEvent.capture);
events[_DYN_SPLICE](idx, 1);
}
}
}
}
}
function _unregisterEvents(target, evtName, unRegFn) {
if (evtName[_DYN_TYPE]) {
_doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE]), evtName, unRegFn);
} else {
var eventCache = elmNodeData.get(target, strEvents, {});
objForEachKey(eventCache, function(evtType, events) {
_doUnregister(target, events, evtName, unRegFn);
});
if (objKeys(eventCache)[_DYN_LENGTH$2] === 0) {
elmNodeData.kill(target, strEvents);
}
}
}
function mergeEvtNamespace(theNamespace, namespaces) {
var newNamespaces;
if (namespaces) {
if (isArray(namespaces)) {
newNamespaces = [theNamespace].concat(namespaces);
} else {
newNamespaces = [theNamespace, namespaces];
}
newNamespaces = _getEvtNamespace("xx", newNamespaces).ns[_DYN_SPLIT$1](".");
} else {
newNamespaces = theNamespace;
}
return newNamespaces;
}
function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
var result = false;
if (target) {
try {
var evtName = _getEvtNamespace(eventName, evtNamespace);
result = _doAttach(target, evtName, handlerRef, useCapture);
if (result && elmNodeData.accept(target)) {
var registeredEvent = {
guid: _guid++,
evtName,
handler: handlerRef,
capture: useCapture
};
_getRegisteredEvents(target, evtName.type)[_DYN_PUSH$1](registeredEvent);
}
} catch (e) {
}
}
return result;
}
function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
if (target) {
try {
var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
var found_1 = false;
_unregisterEvents(target, evtName_1, function(regEvent) {
if (evtName_1.ns && !handlerRef || regEvent.handler === handlerRef) {
found_1 = true;
return true;
}
return false;
});
if (!found_1) {
_doDetach(target, evtName_1, handlerRef, useCapture);
}
} catch (e) {
}
}
}
function addEventHandler(eventName, callback, evtNamespace) {
var result = false;
var w = getWindow();
if (w) {
result = eventOn(w, eventName, callback, evtNamespace);
result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
}
var doc = getDocument();
if (doc) {
result = eventOn(doc, eventName, callback, evtNamespace) || result;
}
return result;
}
function removeEventHandler(eventName, callback, evtNamespace) {
var w = getWindow();
if (w) {
eventOff(w, eventName, callback, evtNamespace);
eventOff(w["body"], eventName, callback, evtNamespace);
}
var doc = getDocument();
if (doc) {
eventOff(doc, eventName, callback, evtNamespace);
}
}
function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
var added = false;
if (listener && events && events[_DYN_LENGTH$2] > 0) {
arrForEach(events, function(name) {
if (name) {
if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
added = addEventHandler(name, listener, evtNamespace) || added;
}
}
});
}
return added;
}
function addEventListeners(events, listener, excludeEvents, evtNamespace) {
var added = false;
if (listener && events && isArray(events)) {
added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
if (!added && excludeEvents && excludeEvents[_DYN_LENGTH$2] > 0) {
added = _addEventListeners(events, listener, null, evtNamespace);
}
}
return added;
}
function removeEventListeners(events, listener, evtNamespace) {
if (events && isArray(events)) {
arrForEach(events, function(name) {
if (name) {
removeEventHandler(name, listener, evtNamespace);
}
});
}
}
function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
}
function removePageUnloadEventListener(listener, evtNamespace) {
removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
}
function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
function _handlePageVisibility(evt) {
var doc = getDocument();
if (listener && doc && doc.visibilityState === "hidden") {
listener(evt);
}
}
var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
}
if (!pageUnloadAdded && excludeEvents) {
pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
}
return pageUnloadAdded;
}
function removePageHideEventListener(listener, evtNamespace) {
var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
removeEventListeners([strPageHide], listener, newNamespaces);
removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
}
function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
function _handlePageVisibility(evt) {
var doc = getDocument();
if (listener && doc && doc.visibilityState === "visible") {
listener(evt);
}
}
var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
if (!pageShowAdded && excludeEvents) {
pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
}
return pageShowAdded;
}
function removePageShowEventListener(listener, evtNamespace) {
var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
removeEventListeners([strPageShow], listener, newNamespaces);
removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
}
var STR_EMPTY$1 = "";
var _DYN_TIMINGS$1 = "timings";
var _DYN_VALUE = "value";
var _DYN_LENGTH$1 = "length";
var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
var _a$1;
var Version = "4.3.10";
var FullVersionString = "1DS-Web-JS-" + Version;
var ObjHasOwnProperty = ObjProto$1.hasOwnProperty;
var _fieldTypeEventPropMap = (_a$1 = {}, _a$1[0] = 0, _a$1[2] = 6, _a$1[1] = 1, _a$1[3] = 7, _a$1[4096 | 2] = 6, _a$1[4096 | 1] = 1, _a$1[4096 | 3] = 7, _a$1);
function isValueAssigned(value) {
return !(value === STR_EMPTY$1 || /* @__PURE__ */ isNullOrUndefined(value));
}
function getTenantId(apiKey) {
if (apiKey) {
var indexTenantId = strIndexOf(apiKey, "-");
if (indexTenantId > -1) {
return /* @__PURE__ */ strLeft(apiKey, indexTenantId);
}
}
return STR_EMPTY$1;
}
function sanitizeProperty(name, property, stringifyObjects) {
if (!property && !isValueAssigned(property) || typeof name !== "string") {
return null;
}
var propType = typeof property;
if (propType === "string" || propType === "number" || propType === "boolean" || isArray(property)) {
property = { value: property };
} else if (propType === "object" && !ObjHasOwnProperty.call(property, "value")) {
property = { value: stringifyObjects ? JSON.stringify(property) : property };
} else if (/* @__PURE__ */ isNullOrUndefined(property[_DYN_VALUE]) || property[_DYN_VALUE] === STR_EMPTY$1 || !isString(property[_DYN_VALUE]) && !isNumber(property[_DYN_VALUE]) && !isBoolean(property[_DYN_VALUE]) && !isArray(property[_DYN_VALUE])) {
return null;
}
if (isArray(property[_DYN_VALUE]) && !isArrayValid(property[_DYN_VALUE])) {
return null;
}
if (!/* @__PURE__ */ isNullOrUndefined(property.kind)) {
if (isArray(property[_DYN_VALUE]) || !isValueKind(property.kind)) {
return null;
}
property[_DYN_VALUE] = property[_DYN_VALUE].toString();
}
return property;
}
function getCommonSchemaMetaData(value, kind, type) {
var encodedTypeValue = -1;
if (!/* @__PURE__ */ isUndefined(value)) {
if (kind > 0) {
if (kind === 32) {
encodedTypeValue = 1 << 13;
} else if (kind <= 13) {
encodedTypeValue = kind << 5;
}
}
if (isDataType(type)) {
if (encodedTypeValue === -1) {
encodedTypeValue = 0;
}
encodedTypeValue |= type;
} else {
var propType = _fieldTypeEventPropMap[getFieldValueType(value)] || -1;
if (encodedTypeValue !== -1 && propType !== -1) {
encodedTypeValue |= propType;
} else if (propType === 6) {
encodedTypeValue = propType;
}
}
}
return encodedTypeValue;
}
function extend(obj, obj2, obj3, obj4, obj5) {
var extended = {};
var deep = false;
var i = 0;
var length = arguments[_DYN_LENGTH$1];
var theArgs = arguments;
if (isBoolean(theArgs[0])) {
deep = theArgs[0];
i++;
}
for (; i < length; i++) {
var obj = theArgs[i];
objForEachKey(obj, function(prop, value) {
if (deep && value && /* @__PURE__ */ isObject(value)) {
if (isArray(value)) {
extended[prop] = extended[prop] || [];
arrForEach(value, function(arrayValue, arrayIndex) {
if (arrayValue && /* @__PURE__ */ isObject(arrayValue)) {
extended[prop][arrayIndex] = extend(true, extended[prop][arrayIndex], arrayValue);
} else {
extended[prop][arrayIndex] = arrayValue;
}
});
} else {
extended[prop] = extend(true, extended[prop], value);
}
} else {
extended[prop] = value;
}
});
}
return extended;
}
var getTime = perfNow;
function isValueKind(value) {
if (value === 0 || (value > 0 && value <= 13 || value === 32)) {
return true;
}
return false;
}
function isDataType(value) {
if (value >= 0 && value <= 9) {
return true;
}
return false;
}
function isArrayValid(value) {
return value[_DYN_LENGTH$1] > 0;
}
function setProcessTelemetryTimings(event, identifier) {
var evt = event;
evt[_DYN_TIMINGS$1] = evt[_DYN_TIMINGS$1] || {};
evt[_DYN_TIMINGS$1][_DYN_PROCESS_TELEMETRY_ST0] = evt[_DYN_TIMINGS$1][_DYN_PROCESS_TELEMETRY_ST0] || {};
evt[_DYN_TIMINGS$1][_DYN_PROCESS_TELEMETRY_ST0][identifier] = getTime();
}
function getFieldValueType(value) {
var theType = 0;
if (value !== null && value !== void 0) {
var objType = typeof value;
if (objType === "string") {
theType = 1;
} else if (objType === "number") {
theType = 2;
} else if (objType === "boolean") {
theType = 3;
} else if (objType === strShimObject) {
theType = 4;
if (isArray(value)) {
theType = 4096;
if (value[_DYN_LENGTH$1] > 0) {
theType |= getFieldValueType(value[0]);
}
} else if (ObjHasOwnProperty.call(value, "value")) {
theType = 8192 | getFieldValueType(value[_DYN_VALUE]);
}
}
}
return theType;
}
function isChromium() {
return !!/* @__PURE__ */ getInst("chrome");
}
function isGreaterThanZero(value) {
return value > 0;
}
var STR_EMPTY = "";
var STR_DROPPED = "drop";
var STR_SENDING = "send";
var STR_REQUEUE = "requeue";
var STR_RESPONSE_FAIL = "rspFail";
var STR_OTHER = "oth";
var DEFAULT_CACHE_CONTROL = "no-cache, no-store";
var DEFAULT_CONTENT_TYPE = "application/x-json-stream";
var STR_CACHE_CONTROL = "cache-control";
var STR_CONTENT_TYPE_HEADER = "content-type";
var STR_KILL_TOKENS_HEADER = "kill-tokens";
var STR_KILL_DURATION_HEADER = "kill-duration";
var STR_TIME_DELTA_HEADER = "time-delta-millis";
var STR_CLIENT_VERSION = "client-version";
var STR_CLIENT_ID = "client-id";
var STR_TIME_DELTA_TO_APPLY = "time-delta-to-apply-millis";
var STR_UPLOAD_TIME = "upload-time";
var STR_API_KEY = "apikey";
var STR_MSA_DEVICE_TICKET = "AuthMsaDeviceTicket";
var STR_AUTH_WEB_TOKEN = "WebAuthToken";
var STR_AUTH_XTOKEN = "AuthXToken";
var STR_NO_RESPONSE_BODY = "NoResponseBody";
var STR_MSFPC = "msfpc";
var STR_TRACE = "trace";
var STR_USER = "user";
var _DYN_ALLOW_REQUEST_SENDIN0 = "allowRequestSending";
var _DYN_SHOULD_ADD_CLOCK_SKE1 = "shouldAddClockSkewHeaders";
var _DYN_GET_CLOCK_SKEW_HEADE2 = "getClockSkewHeaderValue";
var _DYN_SET_CLOCK_SKEW = "setClockSkew";
var _DYN_LENGTH = "length";
var _DYN_CONCAT = "concat";
var _DYN_I_KEY = "iKey";
var _DYN_COUNT = "count";
var _DYN_EVENTS = "events";
var _DYN_PUSH = "push";
var _DYN_SPLIT = "split";
var _DYN_TO_LOWER_CASE = "toLowerCase";
var _DYN_HDRS = "hdrs";
var _DYN_USE_HDRS = "useHdrs";
var _DYN_INITIALIZE = "initialize";
var _DYN_SET_TIMEOUT_OVERRIDE = "setTimeoutOverride";
var _DYN_CLEAR_TIMEOUT_OVERRI3 = "clearTimeoutOverride";
var _DYN_PAYLOAD_PREPROCESSOR = "payloadPreprocessor";
var _DYN_OVERRIDE_ENDPOINT_UR4 = "overrideEndpointUrl";
var _DYN_AVOID_OPTIONS = "avoidOptions";
var _DYN_DISABLE_EVENT_TIMING5 = "disableEventTimings";
var _DYN_ENABLE_COMPOUND_KEY = "enableCompoundKey";
var _DYN_DISABLE_XHR_SYNC = "disableXhrSync";
var _DYN_DISABLE_FETCH_KEEP_A6 = "disableFetchKeepAlive";
var _DYN_ADD_NO_RESPONSE = "addNoResponse";
var _DYN_USE_SEND_BEACON = "useSendBeacon";
var _DYN_FETCH_CREDENTIALS = "fetchCredentials";
var _DYN_ALWAYS_USE_XHR_OVERR7 = "alwaysUseXhrOverride";
var _DYN_SERIALIZE_OFFLINE_EV8 = "serializeOfflineEvt";
var _DYN_GET_OFFLINE_REQUEST_9 = "getOfflineRequestDetails";
var _DYN_CREATE_PAYLOAD = "createPayload";
var _DYN_CREATE_ONE_DSPAYLOAD = "createOneDSPayload";
var _DYN_PAYLOAD_BLOB = "payloadBlob";
var _DYN_HEADERS = "headers";
var _DYN__THE_PAYLOAD = "_thePayload";
var _DYN_BATCHES = "batches";
var _DYN_SEND_TYPE = "sendType";
var _DYN_CAN_SEND_REQUEST = "canSendRequest";
var _DYN_SEND_QUEUED_REQUESTS = "sendQueuedRequests";
var _DYN_SET_UNLOADING = "setUnloading";
var _DYN_IS_TENANT_KILLED = "isTenantKilled";
var _DYN_SEND_SYNCHRONOUS_BAT10 = "sendSynchronousBatch";
var _DYN__TRANSPORT = "_transport";
var _DYN_GET_WPARAM = "getWParam";
var _DYN_IS_BEACON = "isBeacon";
var _DYN_TIMINGS = "timings";
var _DYN_IS_TEARDOWN = "isTeardown";
var _DYN__SEND_REASON = "_sendReason";
var _DYN_SET_KILL_SWITCH_TENA11 = "setKillSwitchTenants";
var _DYN__BACK_OFF_TRANSMISSI12 = "_backOffTransmission";
var _DYN_IDENTIFIER = "identifier";
var _DYN_IGNORE_MC1_MS0_COOKI13 = "ignoreMc1Ms0CookieProcessing";
var _DYN_AUTO_FLUSH_EVENTS_LI14 = "autoFlushEventsLimit";
var _DYN_DISABLE_AUTO_BATCH_F15 = "disableAutoBatchFlushLimit";
var _DYN_OVERRIDE_INSTRUMENTA16 = "overrideInstrumentationKey";
var _DYN_SEND_ATTEMPT = "sendAttempt";
var _DYN_LATENCY = "latency";
var _DYN_SYNC = "sync";
function _getEventMsfpc(theEvent) {
var intWeb = (theEvent.ext || {})["intweb"];
if (intWeb && isValueAssigned(intWeb[STR_MSFPC])) {
return intWeb[STR_MSFPC];
}
return null;
}
function _getMsfpc(theEvents) {
var msfpc = null;
for (var lp = 0; msfpc === null && lp < theEvents[_DYN_LENGTH]; lp++) {
msfpc = _getEventMsfpc(theEvents[lp]);
}
return msfpc;
}
var EventBatch = (
/** @class */
(function() {
function EventBatch2(iKey, addEvents) {
var events = addEvents ? [][_DYN_CONCAT](addEvents) : [];
var _self = this;
var _msfpc = _getMsfpc(events);
_self[_DYN_I_KEY] = function() {
return iKey;
};
_self.Msfpc = function() {
return _msfpc || STR_EMPTY;
};
_self[_DYN_COUNT] = function() {
return events[_DYN_LENGTH];
};
_self[_DYN_EVENTS] = function() {
return events;
};
_self.addEvent = function(theEvent) {
if (theEvent) {
events[_DYN_PUSH](theEvent);
if (!_msfpc) {
_msfpc = _getEventMsfpc(theEvent);
}
return true;
}
return false;
};
_self[_DYN_SPLIT] = function(fromEvent, numEvents) {
var theEvents;
if (fromEvent < events[_DYN_LENGTH]) {
var cnt = events[_DYN_LENGTH] - fromEvent;
if (!/* @__PURE__ */ isNullOrUndefined(numEvents)) {
cnt = numEvents < cnt ? numEvents : cnt;
}
theEvents = events.splice(fromEvent, cnt);
_msfpc = _getMsfpc(events);
}
return new EventBatch2(iKey, theEvents);
};
}
EventBatch2.create = function(iKey, theEvents) {
return new EventBatch2(iKey, theEvents);
};
return EventBatch2;
})()
);
var ClockSkewManager = (
/** @class */
(function() {
function ClockSkewManager2() {
var _allowRequestSending = true;
var _shouldAddClockSkewHeaders = true;
var _isFirstRequest = true;
var _clockSkewHeaderValue = "use-collector-delta";
var _clockSkewSet = false;
dynamicProto(ClockSkewManager2, this, function(_self) {
_self[_DYN_ALLOW_REQUEST_SENDIN0] = function() {
return _allowRequestSending;
};
_self.firstRequestSent = function() {
if (_isFirstRequest) {
_isFirstRequest = false;
if (!_clockSkewSet) {
_allowRequestSending = false;
}
}
};
_self[_DYN_SHOULD_ADD_CLOCK_SKE1] = function() {
return _shouldAddClockSkewHeaders;
};
_self[_DYN_GET_CLOCK_SKEW_HEADE2] = function() {
return _clockSkewHeaderValue;
};
_self[_DYN_SET_CLOCK_SKEW] = function(timeDeltaInMillis) {
if (!_clockSkewSet) {
if (timeDeltaInMillis) {
_clockSkewHeaderValue = timeDeltaInMillis;
_shouldAddClockSkewHeaders = true;
_clockSkewSet = true;
} else {
_shouldAddClockSkewHeaders = false;
}
_allowRequestSending = true;
}
};
});
}
ClockSkewManager2.__ieDyn = 1;
return ClockSkewManager2;
})()
);
var SecToMsMultiplier = 1e3;
var KillSwitch = (
/** @class */
(function() {
function KillSwitch2() {
var _killedTokenDictionary = {};
function _normalizeTenants(values) {
var result = [];
if (values) {
arrForEach(values, function(value) {
result[_DYN_PUSH](strTrim(value));
});
}
return result;
}
dynamicProto(KillSwitch2, this, function(_self) {
_self[_DYN_SET_KILL_SWITCH_TENA11] = function(killTokens, killDuration) {
if (killTokens && killDuration) {
try {
var killedTokens = _normalizeTenants(killTokens[_DYN_SPLIT](","));
if (killDuration === "this-request-only") {
return killedTokens;
}
var durationMs = parseInt(killDuration, 10) * SecToMsMultiplier;
for (var i = 0; i < killedTokens[_DYN_LENGTH]; ++i) {
_killedTokenDictionary[killedTokens[i]] = /* @__PURE__ */ utcNow() + durationMs;
}
} catch (ex) {
return [];
}
}
return [];
};
_self[_DYN_IS_TENANT_KILLED] = function(tenantToken) {
var killDictionary = _killedTokenDictionary;
var name = strTrim(tenantToken);
if (killDictionary[name] !== void 0 && killDictionary[name] > /* @__PURE__ */ utcNow()) {
return true;
}
delete killDictionary[name];
return false;
};
});
}
KillSwitch2.__ieDyn = 1;
return KillSwitch2;
})()
);
var RandomizationLowerThreshold = 0.8;
var RandomizationUpperThreshold = 1.2;
var BaseBackoff = 3e3;
var MaxBackoff = 6e5;
function retryPolicyShouldRetryForStatus(httpStatusCode) {
return !(httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 429 || httpStatusCode == 501 || httpStatusCode == 505);
}
function retryPolicyGetMillisToBackoffForRetry(retriesSoFar) {
var waitDuration = 0;
var minBackoff = BaseBackoff * RandomizationLowerThreshold;
var maxBackoff = BaseBackoff * RandomizationUpperThreshold;
var randomBackoff = mathFloor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
return mathMin(waitDuration, MaxBackoff);
}
var _MAX_STRING_JOINS = 20;
var RequestSizeLimitBytes = 3145728;
var BeaconRequestSizeLimitBytes = 65e3;
var MaxRecordSize = 2e6;
var MaxBeaconRecordSize = mathMin(MaxRecordSize, BeaconRequestSizeLimitBytes);
var metadata = "metadata";
var f = "f";
var rCheckDot = /\./;
var Serializer = (
/** @class */
(function() {
function Serializer2(perfManager, valueSanitizer, stringifyObjects, enableCompoundKey, getEncodedTypeOverride, excludeCsMetaData, cfg) {
var strData = "data";
var strBaseData = "baseData";
var strExt = "ext";
var _checkForCompoundkey = !!enableCompoundKey;
var _processSubKeys = true;
var _theSanitizer = valueSanitizer;
var _isReservedCache = {};
var _excludeCsMetaData = !!excludeCsMetaData;
var _getEncodedType = getEncodedTypeOverride || getCommonSchemaMetaData;
var _sizeCfg = _getSizeLimtCfg(cfg);
var _requestSizeLimitBytes = _validateSizeLimit(_sizeCfg.requestLimit, RequestSizeLimitBytes, 0);
var _beaconRequestSizeLimitBytes = _validateSizeLimit(_sizeCfg.requestLimit, BeaconRequestSizeLimitBytes, 1);
var _maxRecordSize = _validateSizeLimit(_sizeCfg.recordLimit, MaxRecordSize, 0);
var _maxBeaconRecordSize = Math.min(_validateSizeLimit(_sizeCfg.recordLimit, MaxBeaconRecordSize, 1), _beaconRequestSizeLimitBytes);
dynamicProto(Serializer2, this, function(_self) {
_self.createPayload = function(retryCnt, isTeardown, isSync, isReducedPayload, sendReason, sendType) {
return {
apiKeys: [],
payloadBlob: STR_EMPTY,
overflow: null,
sizeExceed: [],
failedEvts: [],
batches: [],
numEvents: 0,
retryCnt,
isTeardown,
isSync,
isBeacon: isReducedPayload,
sendType,
sendReason
};
};
_self.appendPayload = function(payload, theBatch, maxEventsPerBatch) {
var canAddEvents = payload && theBatch && !payload.overflow;
if (canAddEvents) {
doPerf(perfManager, function() {
return "Serializer:appendPayload";
}, function() {
var theEvents = theBatch.events();
var payloadBlob = payload.payloadBlob;
var payloadEvents = payload.numEvents;
var eventsAdded = false;
var sizeExceeded = [];
var failedEvts = [];
var isBeaconPayload = payload.isBeacon;
var requestMaxSize = isBeaconPayload ? _beaconRequestSizeLimitBytes : _requestSizeLimitBytes;
var recordMaxSize = isBeaconPayload ? _maxBeaconRecordSize : _maxRecordSize;
var lp = 0;
var joinCount = 0;
while (lp < theEvents.length) {
var theEvent = theEvents[lp];
if (theEvent) {
if (payloadEvents >= maxEventsPerBatch) {
payload.overflow = theBatch.split(lp);
break;
}
var eventBlob = _self.getEventBlob(theEvent);
if (eventBlob && eventBlob.length <= recordMaxSize) {
var blobLength = eventBlob.length;
var currentSize = payloadBlob.length;
if (currentSize + blobLength > requestMaxSize) {
payload.overflow = theBatch.split(lp);
break;
}
if (payloadBlob) {
payloadBlob += "\n";
}
payloadBlob += eventBlob;
joinCount++;
if (joinCount > _MAX_STRING_JOINS) {
strSubstr(payloadBlob, 0, 1);
joinCount = 0;
}
eventsAdded = true;
payloadEvents++;
} else {
if (eventBlob) {
sizeExceeded.push(theEvent);
} else {
failedEvts.push(theEvent);
}
theEvents.splice(lp, 1);
lp--;
}
}
lp++;
}
if (sizeExceeded.length > 0) {
payload.sizeExceed.push(EventBatch.create(theBatch.iKey(), sizeExceeded));
}
if (failedEvts.length > 0) {
payload.failedEvts.push(EventBatch.create(theBatch.iKey(), failedEvts));
}
if (eventsAdded) {
payload.batches.push(theBatch);
payload.payloadBlob = payloadBlob;
payload.numEvents = payloadEvents;
var apiKey = theBatch.iKey();
if (arrIndexOf(payload.apiKeys, apiKey) === -1) {
payload.apiKeys.push(apiKey);
}
}
}, function() {
return { payload, theBatch: { iKey: theBatch.iKey(), evts: theBatch.events() }, max: maxEventsPerBatch };
});
}
return canAddEvents;
};
_self.getEventBlob = function(eventData) {
try {
return doPerf(perfManager, function() {
return "Serializer.getEventBlob";
}, function() {
var serializedEvent = {};
serializedEvent.name = eventData.name;
serializedEvent.time = eventData.time;
serializedEvent.ver = eventData.ver;
serializedEvent.iKey = "o:" + getTenantId(eventData.iKey);
var serializedExt = {};
var _addMetadataCallback;
if (!_excludeCsMetaData) {
_addMetadataCallback = function(pathKeys, key, value) {
_addJSONPropertyMetaData(_getEncodedType, serializedExt, pathKeys, key, value);
};
}
var eventExt = eventData[strExt];
if (eventExt) {
serializedEvent[strExt] = serializedExt;
objForEachKey(eventExt, function(key, value) {
var data = serializedExt[key] = {};
_processPathKeys(value, data, "ext." + key, true, null, null, true);
});
}
var serializedData = serializedEvent[strData] = {};
serializedData.baseType = eventData.baseType;
var serializedBaseData = serializedData[strBaseData] = {};
_processPathKeys(eventData.baseData, serializedBaseData, strBaseData, false, [strBaseData], _addMetadataCallback, _processSubKeys);
_processPathKeys(eventData.data, serializedData, strData, false, [], _addMetadataCallback, _processSubKeys);
return JSON.stringify(serializedEvent);
}, function() {
return { item: eventData };
});
} catch (e) {
return null;
}
};
function _isReservedField(path11, name) {
var result = _isReservedCache[path11];
if (result === void 0) {
if (path11.length >= 7) {
result = strStartsWith(path11, "ext.metadata") || strStartsWith(path11, "ext.web");
}
_isReservedCache[path11] = result;
}
return result;
}
function _processPathKeys(srcObj, target, thePath, checkReserved, metadataPathKeys, metadataCallback, processSubKeys) {
objForEachKey(srcObj, function(key, srcValue) {
var prop = null;
if (srcValue || isValueAssigned(srcValue)) {
var path11 = thePath;
var name_1 = key;
var theMetaPathKeys = metadataPathKeys;
var destObj = target;
if (_checkForCompoundkey && !checkReserved && rCheckDot.test(key)) {
var subKeys = key.split(".");
var keyLen = subKeys.length;
if (keyLen > 1) {
if (theMetaPathKeys) {
theMetaPathKeys = theMetaPathKeys.slice();
}
for (var lp = 0; lp < keyLen - 1; lp++) {
var subKey = subKeys[lp];
destObj = destObj[subKey] = destObj[subKey] || {};
path11 += "." + subKey;
if (theMetaPathKeys) {
theMetaPathKeys.push(subKey);
}
}
name_1 = subKeys[keyLen - 1];
}
}
var isReserved = checkReserved && _isReservedField(path11);
if (!isReserved && _theSanitizer && _theSanitizer.handleField(path11, name_1)) {
prop = _theSanitizer.value(path11, name_1, srcValue, stringifyObjects);
} else {
prop = sanitizeProperty(name_1, srcValue, stringifyObjects);
}
if (prop) {
var newValue = prop.value;
destObj[name_1] = newValue;
if (metadataCallback) {
metadataCallback(theMetaPathKeys, name_1, prop);
}
if (processSubKeys && typeof newValue === "object" && !isArray(newValue)) {
var newPath = theMetaPathKeys;
if (newPath) {
newPath = newPath.slice();
newPath.push(name_1);
}
_processPathKeys(srcValue, newValue, path11 + "." + name_1, checkReserved, newPath, metadataCallback, processSubKeys);
}
}
}
});
}
});
}
Serializer2.__ieDyn = 1;
return Serializer2;
})()
);
function _validateSizeLimit(cfgVal, defaultVal, idx) {
if (isArray(cfgVal)) {
var val = cfgVal[idx];
if (val > 0 && val <= defaultVal) {
return val;
}
}
return defaultVal;
}
function _getSizeLimtCfg(cfg) {
var defaultCfg = {};
if (cfg && cfg.requestLimit) {
return cfg.requestLimit;
}
return defaultCfg;
}
function _addJSONPropertyMetaData(getEncodedType, json, propKeys, name, propertyValue) {
if (propertyValue && json) {
var encodedTypeValue = getEncodedType(propertyValue.value, propertyValue.kind, propertyValue.propertyType);
if (encodedTypeValue > -1) {
var metaData = json[metadata];
if (!metaData) {
metaData = json[metadata] = { f: {} };
}
var metaTarget = metaData[f];
if (!metaTarget) {
metaTarget = metaData[f] = {};
}
if (propKeys) {
for (var lp = 0; lp < propKeys.length; lp++) {
var key = propKeys[lp];
if (!metaTarget[key]) {
metaTarget[key] = { f: {} };
}
var newTarget = metaTarget[key][f];
if (!newTarget) {
newTarget = metaTarget[key][f] = {};
}
metaTarget = newTarget;
}
}
metaTarget = metaTarget[name] = {};
if (isArray(propertyValue.value)) {
metaTarget["a"] = {
t: encodedTypeValue
};
} else {
metaTarget["t"] = encodedTypeValue;
}
}
}
}
function createTimeoutWrapper(argSetTimeout, argClearTimeout) {
return {
set: function(callback, ms) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
return scheduleTimeoutWith([argSetTimeout, argClearTimeout], callback, ms, args);
}
};
}
var _a;
var strSendAttempt = "sendAttempt";
var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
var UrlQueryString = "?cors=true&" + STR_CONTENT_TYPE_HEADER[_DYN_TO_LOWER_CASE]() + "=" + DEFAULT_CONTENT_TYPE;
var _eventActionMap = (_a = {}, _a[1] = STR_REQUEUE, _a[100] = STR_REQUEUE, _a[200] = "sent", _a[8004] = STR_DROPPED, _a[8003] = STR_DROPPED, _a);
var _collectorQsHeaders = {};
var _collectorHeaderToQs = {};
function _addCollectorHeaderQsMapping(qsName, headerName, allowQs) {
_collectorQsHeaders[qsName] = headerName;
if (allowQs !== false) {
_collectorHeaderToQs[headerName] = qsName;
}
}
_addCollectorHeaderQsMapping(STR_MSA_DEVICE_TICKET, STR_MSA_DEVICE_TICKET, false);
_addCollectorHeaderQsMapping(STR_CLIENT_VERSION, STR_CLIENT_VERSION);
_addCollectorHeaderQsMapping(STR_CLIENT_ID, "Client-Id");
_addCollectorHeaderQsMapping(STR_API_KEY, STR_API_KEY);
_addCollectorHeaderQsMapping(STR_TIME_DELTA_TO_APPLY, STR_TIME_DELTA_TO_APPLY);
_addCollectorHeaderQsMapping(STR_UPLOAD_TIME, STR_UPLOAD_TIME);
_addCollectorHeaderQsMapping(STR_AUTH_XTOKEN, STR_AUTH_XTOKEN);
function _hasHeader(headers, header) {
var hasHeader = false;
if (headers && header) {
var keys = objKeys(headers);
if (keys && keys[_DYN_LENGTH] > 0) {
var lowerHeader = header[_DYN_TO_LOWER_CASE]();
for (var lp = 0; lp < keys[_DYN_LENGTH]; lp++) {
var value = keys[lp];
if (value && /* @__PURE__ */ objHasOwnProperty(header, value) && value[_DYN_TO_LOWER_CASE]() === lowerHeader) {
hasHeader = true;
break;
}
}
}
}
return hasHeader;
}
function _addRequestDetails(details, name, value, useHeaders) {
if (name && value && value[_DYN_LENGTH] > 0) {
if (useHeaders && _collectorQsHeaders[name]) {
details[_DYN_HDRS][_collectorQsHeaders[name]] = value;
details[_DYN_USE_HDRS] = true;
} else {
details.url += "&" + name + "=" + value;
}
}
}
function _addQueryStringParameter(qsParams, name, value) {
for (var i = 0; i < qsParams[_DYN_LENGTH]; i++) {
if (qsParams[i].name === name) {
qsParams[i].value = value;
return;
}
}
qsParams[_DYN_PUSH]({ name, value });
}
function _removeQueryStringParameter(qsParams, name) {
for (var i = 0; i < qsParams[_DYN_LENGTH]; i++) {
if (qsParams[i].name === name) {
qsParams.splice(i, 1);
return;
}
}
}
var HttpManager = (
/** @class */
(function() {
function HttpManager2(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions) {
var _urlString;
var _killSwitch;
var _paused;
var _clockSkewManager;
var _useBeacons = false;
var _outstandingRequests;
var _postManager;
var _logger;
var _sendInterfaces;
var _core;
var _customHttpInterface;
var _queryStringParameters;
var _headers;
var _batchQueue;
var _serializer;
var _enableEventTimings;
var _cookieMgr;
var _isUnloading;
var _useHeaders;
var _xhrTimeout;
var _zipPayload;
var _disableXhrSync;
var _disableFetchKeepAlive;
var _canHaveReducedPayload;
var _addNoResponse;
var _unloadHooks;
var _sendHook;
var _sendListener;
var _responseHandlers;
var _isInitialized;
var _timeoutWrapper;
var _excludeCsMetaData;
var _sendPostMgr;
var _fetchCredentials;
var _maxEvtPerBatch = maxEventsPerBatch;
dynamicProto(HttpManager2, this, function(_self) {
_initDefaults();
var _sendCredentials = true;
_self[_DYN_INITIALIZE] = function(theConfig, core, postChannel) {
if (!_isInitialized) {
_core = core;
_cookieMgr = core.getCookieMgr();
_postManager = postChannel;
_logger = _postManager.diagLog();
arrAppend(_unloadHooks, onConfigChange(theConfig, function(details) {
var _a2;
var coreConfig = details.cfg;
var channelConfig = details.cfg.extensionConfig[postChannel.identifier];
_timeoutWrapper = createTimeoutWrapper(channelConfig[_DYN_SET_TIMEOUT_OVERRIDE], channelConfig[_DYN_CLEAR_TIMEOUT_OVERRI3]);
if (isValueAssigned(coreConfig.anonCookieName)) {
_addQueryStringParameter(_queryStringParameters, "anoncknm", coreConfig.anonCookieName);
} else {
_removeQueryStringParameter(_queryStringParameters, "anoncknm");
}
_sendHook = channelConfig[_DYN_PAYLOAD_PREPROCESSOR];
_sendListener = channelConfig.payloadListener;
var httpInterface = channelConfig.httpXHROverride;
var endpointUrl = channelConfig[_DYN_OVERRIDE_ENDPOINT_UR4] ? channelConfig[_DYN_OVERRIDE_ENDPOINT_UR4] : coreConfig.endpointUrl;
_urlString = endpointUrl + UrlQueryString;
_useHeaders = !/* @__PURE__ */ isUndefined(channelConfig[_DYN_AVOID_OPTIONS]) ? !channelConfig[_DYN_AVOID_OPTIONS] : true;
_enableEventTimings = !channelConfig[_DYN_DISABLE_EVENT_TIMING5];
var maxEvtCfg = channelConfig.maxEvtPerBatch;
_maxEvtPerBatch = maxEvtCfg && maxEvtCfg <= maxEventsPerBatch ? maxEvtCfg : maxEventsPerBatch;
var valueSanitizer = channelConfig.valueSanitizer;
var stringifyObjects = channelConfig.stringifyObjects;
var enableCompoundKey = !!coreConfig[_DYN_ENABLE_COMPOUND_KEY];
if (!/* @__PURE__ */ isUndefined(channelConfig[_DYN_ENABLE_COMPOUND_KEY])) {
enableCompoundKey = !!channelConfig[_DYN_ENABLE_COMPOUND_KEY];
}
_xhrTimeout = channelConfig.xhrTimeout;
var csStream = /* @__PURE__ */ getInst("CompressionStream");
_zipPayload = isFeatureEnabled("zipPayload", coreConfig, false);
if (!isFunction(csStream) || _sendHook) {
_zipPayload = false;
}
_disableXhrSync = !!channelConfig[_DYN_DISABLE_XHR_SYNC];
_disableFetchKeepAlive = !!channelConfig[_DYN_DISABLE_FETCH_KEEP_A6];
_addNoResponse = channelConfig[_DYN_ADD_NO_RESPONSE] !== false;
_excludeCsMetaData = !!channelConfig.excludeCsMetaData;
if (!!core.getPlugin("LocalStorage")) {
_disableFetchKeepAlive = true;
}
_useBeacons = !isReactNative();
_serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey, getCommonSchemaMetaData, _excludeCsMetaData, channelConfig);
if (!/* @__PURE__ */ isNullOrUndefined(channelConfig[_DYN_USE_SEND_BEACON])) {
_useBeacons = !!channelConfig[_DYN_USE_SEND_BEACON];
}
if (channelConfig[_DYN_FETCH_CREDENTIALS]) {
_fetchCredentials = channelConfig[_DYN_FETCH_CREDENTIALS];
}
var sendPostConfig = _getSendPostMgrConfig();
if (!_sendPostMgr) {
_sendPostMgr = new SenderPostManager();
_sendPostMgr[_DYN_INITIALIZE](sendPostConfig, _logger);
} else {
_sendPostMgr.SetConfig(sendPostConfig);
}
var syncHttpInterface = httpInterface;
var beaconHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7] ? httpInterface : null;
var fetchSyncHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7] ? httpInterface : null;
var beaconUnloadTransports = [3, 2];
if (!httpInterface) {
_customHttpInterface = false;
var theTransports = [];
if (isReactNative()) {
theTransports = [2, 1];
beaconUnloadTransports = [2, 1, 3];
} else {
theTransports = [1, 2, 3];
}
theTransports = prependTransports(theTransports, channelConfig.transports);
httpInterface = _getSenderInterface(theTransports, false);
if (!httpInterface) {
_warnToConsole(_logger, "No available transport to send events");
}
syncHttpInterface = _getSenderInterface(theTransports, true);
}
if (!beaconHttpInterface) {
beaconUnloadTransports = prependTransports(beaconUnloadTransports, channelConfig.unloadTransports);
beaconHttpInterface = _getSenderInterface(beaconUnloadTransports, true);
}
_canHaveReducedPayload = !_customHttpInterface && (_useBeacons && isBeaconsSupported() || !_disableFetchKeepAlive && isFetchSupported(true));
_sendInterfaces = (_a2 = {}, _a2[0] = httpInterface, _a2[1] = syncHttpInterface || _getSenderInterface([1, 2, 3], true), _a2[2] = beaconHttpInterface || syncHttpInterface || _getSenderInterface([1], true), _a2[3] = fetchSyncHttpInterface || _getSenderInterface([2, 3], true) || syncHttpInterface || _getSenderInterface([1], true), _a2);
}));
_isInitialized = true;
}
};
_self.addResponseHandler = function(responseHandler) {
_responseHandlers[_DYN_PUSH](responseHandler);
return {
rm: function() {
var index = _responseHandlers.indexOf(responseHandler);
if (index >= 0) {
_responseHandlers.splice(index, 1);
}
}
};
};
_self[_DYN_SERIALIZE_OFFLINE_EV8] = function(evt) {
try {
if (_serializer) {
return _serializer.getEventBlob(evt);
}
} catch (e) {
}
return STR_EMPTY;
};
_self[_DYN_GET_OFFLINE_REQUEST_9] = function() {
try {
var payload = _serializer && _serializer[_DYN_CREATE_PAYLOAD](0, false, false, false, 1, 0);
return _buildRequestDetails(payload, _useHeaders);
} catch (e) {
}
return null;
};
_self[_DYN_CREATE_ONE_DSPAYLOAD] = function(evts, optimize) {
try {
var theBatches_1 = [];
arrForEach(evts, function(evt) {
if (optimize) {
evt = optimizeObject(evt);
}
var batch = EventBatch.create(evt[_DYN_I_KEY], [evt]);
theBatches_1[_DYN_PUSH](batch);
});
var thePayload = null;
while (theBatches_1[_DYN_LENGTH] > 0 && _serializer) {
var theBatch = theBatches_1.shift();
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
thePayload = thePayload || _serializer[_DYN_CREATE_PAYLOAD](0, false, false, false, 1, 0);
_serializer.appendPayload(thePayload, theBatch, _maxEvtPerBatch);
}
}
var requestDetails = _buildRequestDetails(thePayload, _useHeaders);
var payloadData = {
data: thePayload[_DYN_PAYLOAD_BLOB],
urlString: requestDetails.url,
headers: requestDetails[_DYN_HDRS],
timeout: _xhrTimeout,
disableXhrSync: _disableXhrSync,
disableFetchKeepAlive: _disableFetchKeepAlive
};
if (_useHeaders) {
if (!_hasHeader(payloadData[_DYN_HEADERS], STR_CACHE_CONTROL)) {
payloadData[_DYN_HEADERS][STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
}
if (!_hasHeader(payloadData[_DYN_HEADERS], STR_CONTENT_TYPE_HEADER)) {
payloadData[_DYN_HEADERS][STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
}
}
return payloadData;
} catch (e) {
}
return null;
};
function _getSenderInterface(transports, syncSupport) {
try {
return _sendPostMgr && _sendPostMgr.getSenderInst(transports, syncSupport);
} catch (e) {
}
return null;
}
_self["_getDbgPlgTargets"] = function() {
return [_sendInterfaces[0], _killSwitch, _serializer, _sendInterfaces, _getSendPostMgrConfig(), _urlString, _maxEvtPerBatch];
};
function _getSendPostMgrConfig() {
try {
var onCompleteFuncs = {
xdrOnComplete: _xdrOncomplete,
fetchOnComplete: _fetchOnComplete,
xhrOnComplete: _xhrOnComplete,
beaconOnRetry: _onBeaconRetry
};
var config = {
enableSendPromise: false,
isOneDs: true,
disableCredentials: !_sendCredentials,
fetchCredentials: _fetchCredentials,
disableXhr: false,
disableBeacon: !_useBeacons,
disableBeaconSync: !_useBeacons,
disableFetchKeepAlive: _disableFetchKeepAlive,
timeWrapper: _timeoutWrapper,
addNoResponse: _addNoResponse,
senderOnCompleteCallBack: onCompleteFuncs
};
return config;
} catch (e) {
}
return null;
}
function _xdrOncomplete(xdr, oncomplete, payload) {
var response = getResponseText(xdr);
_doOnComplete(oncomplete, 200, {}, response);
_handleCollectorResponse(response);
}
function _initDefaults() {
var undefValue2;
_urlString = null;
_killSwitch = new KillSwitch();
_paused = false;
_clockSkewManager = new ClockSkewManager();
_useBeacons = false;
_outstandingRequests = 0;
_postManager = null;
_logger = null;
_sendInterfaces = null;
_core = null;
_customHttpInterface = true;
_queryStringParameters = [];
_headers = {};
_batchQueue = [];
_serializer = null;
_enableEventTimings = false;
_cookieMgr = null;
_isUnloading = false;
_useHeaders = false;
_xhrTimeout = undefValue2;
_disableXhrSync = undefValue2;
_disableFetchKeepAlive = undefValue2;
_canHaveReducedPayload = undefValue2;
_addNoResponse = undefValue2;
_unloadHooks = [];
_sendHook = undefValue2;
_sendListener = undefValue2;
_responseHandlers = [];
_isInitialized = false;
_timeoutWrapper = createTimeoutWrapper();
_excludeCsMetaData = false;
_sendPostMgr = null;
_maxEvtPerBatch = null;
}
function _fetchOnComplete(response, onComplete, resValue, payload) {
var handleResponse = function(status, headerMap2, responseText) {
_doOnComplete(onComplete, status, headerMap2, responseText);
_handleCollectorResponse(responseText);
};
var headerMap = {};
var headers = response[_DYN_HEADERS];
if (headers) {
headers["forEach"](function(value, name) {
headerMap[name] = value;
});
}
handleResponse(response.status, headerMap, resValue || STR_EMPTY);
}
function _xhrOnComplete(request, oncomplete, payload) {
var response = getResponseText(request);
_doOnComplete(oncomplete, request.status, _getAllResponseHeaders(request, true), response);
_handleCollectorResponse(response);
}
function _doOnComplete(oncomplete, status, headers, response) {
try {
oncomplete(status, headers, response);
} catch (e) {
_throwInternal(_logger, 2, 518, /* @__PURE__ */ dumpObj(e));
}
}
function _onBeaconRetry(payload, onComplete, canSend) {
var internalPayloadData = payload;
var status = 200;
var thePayload = internalPayloadData[_DYN__THE_PAYLOAD];
var theUrl = payload.urlString + (_addNoResponse ? _noResponseQs : STR_EMPTY);
try {
var nav_1 = getNavigator();
if (thePayload) {
var persistStorage = !!_core.getPlugin("LocalStorage");
var droppedBatches_1 = [];
var sentBatches_1 = [];
arrForEach(thePayload[_DYN_BATCHES], function(theBatch) {
if (droppedBatches_1 && theBatch && theBatch[_DYN_COUNT]() > 0) {
var theEvents = theBatch[_DYN_EVENTS]();
for (var lp = 0; lp < theEvents[_DYN_LENGTH]; lp++) {
if (!nav_1.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
droppedBatches_1[_DYN_PUSH](theBatch[_DYN_SPLIT](lp));
break;
} else {
sentBatches_1[_DYN_PUSH](theBatch[lp]);
}
}
} else {
droppedBatches_1[_DYN_PUSH](theBatch[_DYN_SPLIT](0));
}
});
if (sentBatches_1[_DYN_LENGTH] > 0) {
thePayload.sentEvts = sentBatches_1;
}
if (!persistStorage) {
_sendBatchesNotification(droppedBatches_1, 8003, thePayload[_DYN_SEND_TYPE], true);
}
} else {
status = 0;
}
} catch (ex) {
_warnToConsole(_logger, "Failed to send telemetry using sendBeacon API. Ex:" + /* @__PURE__ */ dumpObj(ex));
status = 0;
} finally {
_doOnComplete(onComplete, status, {}, STR_EMPTY);
}
}
function _isBeaconPayload(sendType) {
return sendType === 2 || sendType === 3;
}
function _adjustSendType(sendType) {
if (_isUnloading && _isBeaconPayload(sendType)) {
sendType = 2;
}
return sendType;
}
_self.addHeader = function(name, value) {
_headers[name] = value;
};
_self.removeHeader = function(name) {
delete _headers[name];
};
_self[_DYN_CAN_SEND_REQUEST] = function() {
return _hasIdleConnection() && _clockSkewManager[_DYN_ALLOW_REQUEST_SENDIN0]();
};
_self[_DYN_SEND_QUEUED_REQUESTS] = function(sendType, sendReason) {
if (/* @__PURE__ */ isUndefined(sendType)) {
sendType = 0;
}
if (_isUnloading) {
sendType = _adjustSendType(sendType);
sendReason = 2;
}
if (_canSendPayload(_batchQueue, sendType, 0)) {
_sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0);
}
};
_self.isCompletelyIdle = function() {
return !_paused && _outstandingRequests === 0 && _batchQueue[_DYN_LENGTH] === 0;
};
_self[_DYN_SET_UNLOADING] = function(value) {
_isUnloading = value;
};
_self.addBatch = function(theBatch) {
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
if (_killSwitch.isTenantKilled(theBatch[_DYN_I_KEY]())) {
return false;
}
_batchQueue[_DYN_PUSH](theBatch);
}
return true;
};
_self.teardown = function() {
if (_batchQueue[_DYN_LENGTH] > 0) {
_sendBatches(_clearQueue(), 0, true, 2, 2);
}
arrForEach(_unloadHooks, function(hook) {
hook && hook.rm && hook.rm();
});
_unloadHooks = [];
};
_self.pause = function() {
_paused = true;
};
_self.resume = function() {
_paused = false;
_self[_DYN_SEND_QUEUED_REQUESTS](0, 4);
};
_self[_DYN_SEND_SYNCHRONOUS_BAT10] = function(batch, sendType, sendReason) {
if (batch && batch[_DYN_COUNT]() > 0) {
if (/* @__PURE__ */ isNullOrUndefined(sendType)) {
sendType = 1;
}
if (_isUnloading) {
sendType = _adjustSendType(sendType);
sendReason = 2;
}
_sendBatches([batch], 0, false, sendType, sendReason || 0);
}
};
function _hasIdleConnection() {
return !_paused && _outstandingRequests < maxConnections;
}
function _clearQueue() {
var theQueue = _batchQueue;
_batchQueue = [];
return theQueue;
}
function _canSendPayload(theBatches, sendType, retryCnt) {
var result = false;
if (theBatches && theBatches[_DYN_LENGTH] > 0 && !_paused && _sendInterfaces[sendType] && _serializer) {
result = sendType !== 0 || _hasIdleConnection() && (retryCnt > 0 || _clockSkewManager[_DYN_ALLOW_REQUEST_SENDIN0]());
}
return result;
}
function _createDebugBatches(theBatches) {
var values = {};
if (theBatches) {
arrForEach(theBatches, function(theBatch, idx) {
values[idx] = {
iKey: theBatch[_DYN_I_KEY](),
evts: theBatch[_DYN_EVENTS]()
};
});
}
return values;
}
function _sendBatches(theBatches, retryCount, isTeardown, sendType, sendReason) {
if (!theBatches || theBatches[_DYN_LENGTH] === 0) {
return;
}
if (_paused) {
_sendBatchesNotification(theBatches, 1, sendType);
return;
}
sendType = _adjustSendType(sendType);
try {
var orgBatches_1 = theBatches;
var isSynchronous_1 = sendType !== 0;
doPerf(_core, function() {
return "HttpManager:_sendBatches";
}, function(perfEvt) {
if (perfEvt) {
theBatches = theBatches.slice(0);
}
var droppedBatches = [];
var thePayload = null;
var serializationStart = getTime();
var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1] : _sendInterfaces[0]);
var sendTransport = sendInterface && sendInterface[_DYN__TRANSPORT];
var isReducedPayload = _canHaveReducedPayload && (_isUnloading || _isBeaconPayload(sendType) || (sendTransport === 3 || sendInterface._isSync && sendTransport === 2));
while (_canSendPayload(theBatches, sendType, retryCount)) {
var theBatch = theBatches.shift();
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
if (!_killSwitch.isTenantKilled(theBatch[_DYN_I_KEY]())) {
thePayload = thePayload || _serializer[_DYN_CREATE_PAYLOAD](retryCount, isTeardown, isSynchronous_1, isReducedPayload, sendReason, sendType);
if (!_serializer.appendPayload(thePayload, theBatch, _maxEvtPerBatch)) {
_doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
serializationStart = getTime();
theBatches = [theBatch][_DYN_CONCAT](theBatches);
thePayload = null;
} else if (thePayload.overflow !== null) {
theBatches = [thePayload.overflow][_DYN_CONCAT](theBatches);
thePayload.overflow = null;
_doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
serializationStart = getTime();
thePayload = null;
}
} else {
droppedBatches[_DYN_PUSH](theBatch);
}
}
}
if (thePayload) {
_doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
}
if (theBatches[_DYN_LENGTH] > 0) {
_batchQueue = theBatches[_DYN_CONCAT](_batchQueue);
}
_sendBatchesNotification(droppedBatches, 8004, sendType);
}, function() {
return { batches: _createDebugBatches(orgBatches_1), retryCount, isTeardown, isSynchronous: isSynchronous_1, sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType };
}, !isSynchronous_1);
} catch (ex) {
_throwInternal(_logger, 2, 48, "Unexpected Exception sending batch: " + /* @__PURE__ */ dumpObj(ex));
}
}
function _buildRequestDetails(thePayload, useHeaders) {
var requestDetails = {
url: _urlString,
hdrs: {},
useHdrs: false
};
if (!useHeaders) {
objForEachKey(_headers, function(name, value) {
if (_collectorHeaderToQs[name]) {
_addRequestDetails(requestDetails, _collectorHeaderToQs[name], value, false);
} else {
requestDetails[_DYN_HDRS][name] = value;
requestDetails[_DYN_USE_HDRS] = true;
}
});
} else {
requestDetails[_DYN_HDRS] = extend(requestDetails[_DYN_HDRS], _headers);
requestDetails.useHdrs = objKeys(requestDetails.hdrs)[_DYN_LENGTH] > 0;
}
_addRequestDetails(requestDetails, STR_CLIENT_ID, "NO_AUTH", useHeaders);
_addRequestDetails(requestDetails, STR_CLIENT_VERSION, FullVersionString, useHeaders);
var apiQsKeys = STR_EMPTY;
arrForEach(thePayload.apiKeys, function(apiKey) {
if (apiQsKeys[_DYN_LENGTH] > 0) {
apiQsKeys += ",";
}
apiQsKeys += apiKey;
});
_addRequestDetails(requestDetails, STR_API_KEY, apiQsKeys, useHeaders);
_addRequestDetails(requestDetails, STR_UPLOAD_TIME, (/* @__PURE__ */ utcNow()).toString(), useHeaders);
var msfpc = _getMsfpc2(thePayload);
if (isValueAssigned(msfpc)) {
requestDetails.url += "&ext.intweb.msfpc=" + msfpc;
}
if (_clockSkewManager[_DYN_SHOULD_ADD_CLOCK_SKE1]()) {
_addRequestDetails(requestDetails, STR_TIME_DELTA_TO_APPLY, _clockSkewManager[_DYN_GET_CLOCK_SKEW_HEADE2](), useHeaders);
}
if (_core[_DYN_GET_WPARAM]) {
var wParam = _core[_DYN_GET_WPARAM]();
if (wParam >= 0) {
requestDetails.url += "&w=" + wParam;
}
}
for (var i = 0; i < _queryStringParameters[_DYN_LENGTH]; i++) {
requestDetails.url += "&" + _queryStringParameters[i].name + "=" + _queryStringParameters[i].value;
}
return requestDetails;
}
function _setTimingValue(timings, name, value) {
timings[name] = timings[name] || {};
timings[name][_postManager.identifier] = value;
}
function _doPayloadSend(thePayload, serializationStart, serializationCompleted, sendReason) {
if (thePayload && thePayload.payloadBlob && thePayload.payloadBlob[_DYN_LENGTH] > 0) {
var useSendHook_1 = !!_sendHook;
var sendInterface_1 = _sendInterfaces[thePayload.sendType];
if (!_isBeaconPayload(thePayload[_DYN_SEND_TYPE]) && thePayload[_DYN_IS_BEACON] && thePayload.sendReason === 2) {
sendInterface_1 = _sendInterfaces[2] || _sendInterfaces[3] || sendInterface_1;
}
var useHeaders_1 = _useHeaders;
if (thePayload.isBeacon || sendInterface_1[_DYN__TRANSPORT] === 3) {
useHeaders_1 = false;
}
var requestDetails_1 = _buildRequestDetails(thePayload, useHeaders_1);
useHeaders_1 = useHeaders_1 || requestDetails_1[_DYN_USE_HDRS];
var sendEventStart_1 = getTime();
doPerf(_core, function() {
return "HttpManager:_doPayloadSend";
}, function() {
for (var batchLp = 0; batchLp < thePayload.batches[_DYN_LENGTH]; batchLp++) {
var theBatch = thePayload[_DYN_BATCHES][batchLp];
var theEvents = theBatch[_DYN_EVENTS]();
for (var evtLp = 0; evtLp < theEvents[_DYN_LENGTH]; evtLp++) {
var telemetryItem = theEvents[evtLp];
if (_enableEventTimings) {
var timings = telemetryItem[_DYN_TIMINGS] = telemetryItem[_DYN_TIMINGS] || {};
_setTimingValue(timings, "sendEventStart", sendEventStart_1);
_setTimingValue(timings, "serializationStart", serializationStart);
_setTimingValue(timings, "serializationCompleted", serializationCompleted);
}
telemetryItem[strSendAttempt] > 0 ? telemetryItem[strSendAttempt]++ : telemetryItem[strSendAttempt] = 1;
}
}
_sendBatchesNotification(thePayload[_DYN_BATCHES], 1e3 + (sendReason || 0), thePayload[_DYN_SEND_TYPE], true);
var orgPayloadData = {
data: thePayload[_DYN_PAYLOAD_BLOB],
urlString: requestDetails_1.url,
headers: requestDetails_1[_DYN_HDRS],
_thePayload: thePayload,
_sendReason: sendReason,
timeout: _xhrTimeout,
disableXhrSync: _disableXhrSync,
disableFetchKeepAlive: _disableFetchKeepAlive
};
if (useHeaders_1) {
if (!_hasHeader(orgPayloadData[_DYN_HEADERS], STR_CACHE_CONTROL)) {
orgPayloadData[_DYN_HEADERS][STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
}
if (!_hasHeader(orgPayloadData[_DYN_HEADERS], STR_CONTENT_TYPE_HEADER)) {
orgPayloadData[_DYN_HEADERS][STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
}
}
var sender = null;
if (sendInterface_1) {
sender = function(payload) {
_clockSkewManager.firstRequestSent();
var onComplete = function(status, headers) {
_retryRequestIfNeeded(status, headers, thePayload, sendReason);
};
var isSync = thePayload[_DYN_IS_TEARDOWN] || thePayload.isSync;
_sendPostMgr.preparePayload(function(processedPayload) {
try {
sendInterface_1.sendPOST(processedPayload, onComplete, isSync);
if (_sendListener) {
_sendListener(orgPayloadData, processedPayload, isSync, thePayload[_DYN_IS_BEACON]);
}
} catch (ex) {
_doOnComplete(onComplete, 0, {});
_warnToConsole(_logger, "Unexpected exception sending payload. Ex:" + /* @__PURE__ */ dumpObj(ex));
}
}, _zipPayload, payload, isSync);
};
}
doPerf(_core, function() {
return "HttpManager:_doPayloadSend.sender";
}, function() {
if (sender) {
if (thePayload[_DYN_SEND_TYPE] === 0) {
_outstandingRequests++;
}
if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1[_DYN__TRANSPORT] !== 3) {
var hookData_1 = {
data: orgPayloadData.data,
urlString: orgPayloadData.urlString,
headers: extend({}, orgPayloadData[_DYN_HEADERS]),
timeout: orgPayloadData.timeout,
disableXhrSync: orgPayloadData[_DYN_DISABLE_XHR_SYNC],
disableFetchKeepAlive: orgPayloadData[_DYN_DISABLE_FETCH_KEEP_A6]
};
var senderCalled_1 = false;
doPerf(_core, function() {
return "HttpManager:_doPayloadSend.sendHook";
}, function() {
try {
_sendHook(hookData_1, function(payload) {
senderCalled_1 = true;
if (!_customHttpInterface && !payload[_DYN__THE_PAYLOAD]) {
payload[_DYN__THE_PAYLOAD] = payload[_DYN__THE_PAYLOAD] || orgPayloadData[_DYN__THE_PAYLOAD];
payload[_DYN__SEND_REASON] = payload[_DYN__SEND_REASON] || orgPayloadData[_DYN__SEND_REASON];
}
sender(payload);
}, thePayload.isSync || thePayload[_DYN_IS_TEARDOWN]);
} catch (ex) {
if (!senderCalled_1) {
sender(orgPayloadData);
}
}
});
} else {
sender(orgPayloadData);
}
}
});
}, function() {
return { thePayload, serializationStart, serializationCompleted, sendReason };
}, thePayload.isSync);
}
if (thePayload.sizeExceed && thePayload.sizeExceed[_DYN_LENGTH] > 0) {
_sendBatchesNotification(thePayload.sizeExceed, 8003, thePayload[_DYN_SEND_TYPE]);
}
if (thePayload.failedEvts && thePayload.failedEvts[_DYN_LENGTH] > 0) {
_sendBatchesNotification(thePayload.failedEvts, 8002, thePayload[_DYN_SEND_TYPE]);
}
}
function _addEventCompletedTimings(theEvents, sendEventCompleted) {
if (_enableEventTimings) {
arrForEach(theEvents, function(theEvent) {
var timings = theEvent[_DYN_TIMINGS] = theEvent[_DYN_TIMINGS] || {};
_setTimingValue(timings, "sendEventCompleted", sendEventCompleted);
});
}
}
function _retryRequestIfNeeded(status, headers, thePayload, sendReason) {
var reason = 9e3;
var droppedBatches = null;
var isRetrying = false;
var backOffTrans = false;
try {
var shouldRetry = true;
if (typeof status !== strShimUndefined) {
if (headers) {
_clockSkewManager[_DYN_SET_CLOCK_SKEW](headers[STR_TIME_DELTA_HEADER]);
var killDuration = headers[STR_KILL_DURATION_HEADER] || headers["kill-duration-seconds"];
arrForEach(_killSwitch[_DYN_SET_KILL_SWITCH_TENA11](headers[STR_KILL_TOKENS_HEADER], killDuration), function(killToken) {
arrForEach(thePayload[_DYN_BATCHES], function(theBatch) {
if (theBatch[_DYN_I_KEY]() === killToken) {
droppedBatches = droppedBatches || [];
var removedEvents = theBatch[_DYN_SPLIT](0);
thePayload.numEvents -= removedEvents[_DYN_COUNT]();
droppedBatches[_DYN_PUSH](removedEvents);
}
});
});
}
if (status == 200 || status == 204) {
reason = 200;
return;
}
if (!retryPolicyShouldRetryForStatus(status) || thePayload.numEvents <= 0) {
shouldRetry = false;
}
reason = 9e3 + status % 1e3;
}
if (shouldRetry) {
reason = 100;
var retryCount_1 = thePayload.retryCnt;
if (thePayload[_DYN_SEND_TYPE] === 0) {
if (retryCount_1 < maxRequestRetriesBeforeBackoff) {
isRetrying = true;
_doAction(function() {
if (thePayload[_DYN_SEND_TYPE] === 0) {
_outstandingRequests--;
}
_sendBatches(thePayload[_DYN_BATCHES], retryCount_1 + 1, thePayload[_DYN_IS_TEARDOWN], _isUnloading ? 2 : thePayload[_DYN_SEND_TYPE], 5);
}, _isUnloading, retryPolicyGetMillisToBackoffForRetry(retryCount_1));
} else {
backOffTrans = true;
if (_isUnloading) {
reason = 8001;
}
}
}
}
} finally {
if (!isRetrying) {
_clockSkewManager[_DYN_SET_CLOCK_SKEW]();
_handleRequestFinished(thePayload, reason, sendReason, backOffTrans);
}
_sendBatchesNotification(droppedBatches, 8004, thePayload[_DYN_SEND_TYPE]);
}
}
function _handleRequestFinished(thePayload, batchReason, sendReason, backOffTrans) {
try {
if (backOffTrans) {
_postManager[_DYN__BACK_OFF_TRANSMISSI12]();
}
var theBatches = thePayload[_DYN_BATCHES];
if (batchReason === 200) {
theBatches = thePayload.sentEvts || thePayload[_DYN_BATCHES];
if (!backOffTrans && !thePayload.isSync) {
_postManager._clearBackOff();
}
_addCompleteTimings(theBatches);
}
_sendBatchesNotification(theBatches, batchReason, thePayload[_DYN_SEND_TYPE], true);
} finally {
if (thePayload[_DYN_SEND_TYPE] === 0) {
_outstandingRequests--;
if (sendReason !== 5) {
_self.sendQueuedRequests(thePayload[_DYN_SEND_TYPE], sendReason);
}
}
}
}
function _addCompleteTimings(theBatches) {
if (_enableEventTimings) {
var sendEventCompleted_1 = getTime();
arrForEach(theBatches, function(theBatch) {
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
_addEventCompletedTimings(theBatch[_DYN_EVENTS](), sendEventCompleted_1);
}
});
}
}
function _doAction(cb, isSync, interval) {
if (isSync) {
cb();
} else {
_timeoutWrapper.set(cb, interval);
}
}
function _getMsfpc2(thePayload) {
for (var lp = 0; lp < thePayload.batches[_DYN_LENGTH]; lp++) {
var msfpc = thePayload[_DYN_BATCHES][lp].Msfpc();
if (msfpc) {
return encodeURIComponent(msfpc);
}
}
return STR_EMPTY;
}
function _handleCollectorResponse(responseText) {
var responseHandlers = _responseHandlers;
try {
for (var i = 0; i < responseHandlers[_DYN_LENGTH]; i++) {
try {
responseHandlers[i](responseText);
} catch (e) {
_throwInternal(_logger, 1, 519, "Response handler failed: " + e);
}
}
if (responseText) {
var response = JSON.parse(responseText);
if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[STR_MSFPC])) {
_cookieMgr.set("MSFPC", response.webResult[STR_MSFPC], 365 * 86400);
}
}
} catch (ex) {
}
}
function _sendBatchesNotification(theBatches, batchReason, sendType, sendSync) {
if (theBatches && theBatches[_DYN_LENGTH] > 0 && actions) {
var theAction_1 = actions[_getNotificationAction(batchReason)];
if (theAction_1) {
var isSyncRequest_1 = sendType !== 0;
doPerf(_core, function() {
return "HttpManager:_sendBatchesNotification";
}, function() {
_doAction(function() {
try {
theAction_1.call(actions, theBatches, batchReason, isSyncRequest_1, sendType);
} catch (e) {
_throwInternal(_logger, 1, 74, "send request notification failed: " + e);
}
}, sendSync || isSyncRequest_1, 0);
}, function() {
return { batches: _createDebugBatches(theBatches), reason: batchReason, isSync: isSyncRequest_1, sendSync, sendType };
}, !isSyncRequest_1);
}
}
}
function _getNotificationAction(reason) {
var action = _eventActionMap[reason];
if (!isValueAssigned(action)) {
action = STR_OTHER;
if (reason >= 9e3 && reason <= 9999) {
action = STR_RESPONSE_FAIL;
} else if (reason >= 8e3 && reason <= 8999) {
action = STR_DROPPED;
} else if (reason >= 1e3 && reason <= 1999) {
action = STR_SENDING;
}
}
return action;
}
});
}
HttpManager2.__ieDyn = 1;
return HttpManager2;
})()
);
var FlushCheckTimer = 0.25;
var MaxNumberEventPerBatch = 500;
var EventsDroppedAtOneTime = 20;
var MaxSendAttempts = 6;
var MaxSyncUnloadSendAttempts = 2;
var MaxBackoffCount = 4;
var MaxConnections = 2;
var MaxRequestRetriesBeforeBackoff = 1;
var MaxEventsLimitInMem = 1e4;
var strEventsDiscarded = "eventsDiscarded";
var EMPTY_STR = "";
var undefValue = void 0;
var defaultPostChannelConfig = objDeepFreeze({
eventsLimitInMem: { isVal: isGreaterThanZero, v: MaxEventsLimitInMem },
immediateEventLimit: { isVal: isGreaterThanZero, v: 500 },
autoFlushEventsLimit: { isVal: isGreaterThanZero, v: 0 },
disableAutoBatchFlushLimit: false,
httpXHROverride: { isVal: isOverrideFn, v: undefValue },
overrideInstrumentationKey: undefValue,
overrideEndpointUrl: undefValue,
disableTelemetry: false,
ignoreMc1Ms0CookieProcessing: false,
setTimeoutOverride: undefValue,
clearTimeoutOverride: undefValue,
payloadPreprocessor: undefValue,
payloadListener: undefValue,
disableEventTimings: undefValue,
valueSanitizer: undefValue,
stringifyObjects: undefValue,
enableCompoundKey: undefValue,
disableOptimizeObj: false,
fetchCredentials: undefValue,
transports: undefValue,
unloadTransports: undefValue,
useSendBeacon: undefValue,
disableFetchKeepAlive: undefValue,
avoidOptions: false,
xhrTimeout: undefValue,
disableXhrSync: undefValue,
alwaysUseXhrOverride: false,
maxEventRetryAttempts: { isVal: isNumber, v: MaxSendAttempts },
maxUnloadEventRetryAttempts: { isVal: isNumber, v: MaxSyncUnloadSendAttempts },
addNoResponse: undefValue,
maxEvtPerBatch: { isVal: isNumber, v: MaxNumberEventPerBatch },
excludeCsMetaData: undefValue,
requestLimit: {}
});
function isOverrideFn(httpXHROverride) {
return httpXHROverride && httpXHROverride.sendPOST;
}
var PostChannel = (
/** @class */
(function(_super) {
__extendsFn(PostChannel2, _super);
function PostChannel2() {
var _this = _super.call(this) || this;
_this.identifier = "PostChannel";
_this.priority = 1011;
_this.version = "4.3.10";
var _postConfig;
var _isTeardownCalled = false;
var _flushCallbackQueue = [];
var _flushCallbackTimer;
var _paused = false;
var _immediateQueueSize = 0;
var _immediateQueueSizeLimit;
var _queueSize = 0;
var _queueSizeLimit;
var _profiles = {};
var _currentProfile = RT_PROFILE;
var _scheduledTimer;
var _immediateTimer;
var _currentBackoffCount;
var _timerCount;
var _httpManager;
var _batchQueues;
var _autoFlushEventsLimit;
var _autoFlushBatchLimit;
var _delayedBatchSendLatency;
var _delayedBatchReason;
var _optimizeObject;
var _isPageUnloadTriggered;
var _maxEventSendAttempts;
var _maxUnloadEventSendAttempts;
var _evtNamespace;
var _timeoutWrapper;
var _ignoreMc1Ms0CookieProcessing;
var _disableAutoBatchFlushLimit;
var _notificationManager;
var _unloadHandlersAdded;
var _overrideInstrumentationKey;
var _disableTelemetry;
var _maxEvtPerBatch;
dynamicProto(PostChannel2, _this, function(_self, _base) {
_initDefaults();
_self["_getDbgPlgTargets"] = function() {
return [_httpManager, _postConfig];
};
_self[_DYN_INITIALIZE] = function(theConfig, core, extensions3) {
doPerf(core, function() {
return "PostChannel:initialize";
}, function() {
_base[_DYN_INITIALIZE](theConfig, core, extensions3);
_notificationManager = core.getNotifyMgr();
try {
_evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self[_DYN_IDENTIFIER]), core.evtNamespace && core.evtNamespace());
_self._addHook(onConfigChange(theConfig, function(details) {
var coreConfig = details.cfg;
var ctx = createProcessTelemetryContext(null, coreConfig, core);
_postConfig = ctx.getExtCfg(_self[_DYN_IDENTIFIER], defaultPostChannelConfig);
_timeoutWrapper = createTimeoutWrapper(_postConfig[_DYN_SET_TIMEOUT_OVERRIDE], _postConfig[_DYN_CLEAR_TIMEOUT_OVERRI3]);
_optimizeObject = !_postConfig.disableOptimizeObj && isChromium();
_ignoreMc1Ms0CookieProcessing = _postConfig[_DYN_IGNORE_MC1_MS0_COOKI13];
_hookWParam(core);
_queueSizeLimit = _postConfig.eventsLimitInMem;
_immediateQueueSizeLimit = _postConfig.immediateEventLimit;
_autoFlushEventsLimit = _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI14];
_maxEventSendAttempts = _postConfig.maxEventRetryAttempts;
_maxUnloadEventSendAttempts = _postConfig.maxUnloadEventRetryAttempts;
_disableAutoBatchFlushLimit = _postConfig[_DYN_DISABLE_AUTO_BATCH_F15];
_maxEvtPerBatch = _postConfig.maxEvtPerBatch;
if (/* @__PURE__ */ isPromiseLike(coreConfig.endpointUrl)) {
_self.pause();
} else if (!!_paused) {
_self.resume();
}
_setAutoLimits();
_overrideInstrumentationKey = _postConfig[_DYN_OVERRIDE_INSTRUMENTA16];
_disableTelemetry = !!_postConfig.disableTelemetry;
if (_unloadHandlersAdded) {
_removeUnloadHandlers();
}
var excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
_unloadHandlersAdded = addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
_unloadHandlersAdded = addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace) || _unloadHandlersAdded;
_unloadHandlersAdded = addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace) || _unloadHandlersAdded;
}));
_httpManager[_DYN_INITIALIZE](theConfig, _self.core, _self);
} catch (e) {
_self.setInitialized(false);
throw e;
}
}, function() {
return { theConfig, core, extensions: extensions3 };
});
};
_self.processTelemetry = function(ev, itemCtx) {
setProcessTelemetryTimings(ev, _self[_DYN_IDENTIFIER]);
itemCtx = itemCtx || _self._getTelCtx(itemCtx);
var event = ev;
if (!_disableTelemetry && !_isTeardownCalled) {
if (_overrideInstrumentationKey) {
event[_DYN_I_KEY] = _overrideInstrumentationKey;
}
_addEventToQueues(event, true);
if (_isPageUnloadTriggered) {
_releaseAllQueues(2, 2);
} else {
_scheduleTimer();
}
}
_self.processNext(event, itemCtx);
};
_self.getOfflineSupport = function() {
try {
var details_1 = _httpManager && _httpManager[_DYN_GET_OFFLINE_REQUEST_9]();
if (_httpManager) {
return {
getUrl: function() {
if (details_1) {
return details_1.url;
}
return null;
},
serialize: _serialize,
batch: _batch,
shouldProcess: function(evt) {
return !_disableTelemetry;
},
createPayload: function(evt) {
return null;
},
createOneDSPayload: function(evts) {
if (_httpManager[_DYN_CREATE_ONE_DSPAYLOAD]) {
return _httpManager[_DYN_CREATE_ONE_DSPAYLOAD](evts, _optimizeObject);
}
}
};
}
} catch (e) {
}
return null;
};
_self._doTeardown = function(unloadCtx, unloadState) {
_releaseAllQueues(2, 2);
_isTeardownCalled = true;
_httpManager.teardown();
_removeUnloadHandlers();
_initDefaults();
};
function _removeUnloadHandlers() {
removePageUnloadEventListener(null, _evtNamespace);
removePageHideEventListener(null, _evtNamespace);
removePageShowEventListener(null, _evtNamespace);
}
function _hookWParam(core) {
var existingGetWParamMethod = core[_DYN_GET_WPARAM];
core[_DYN_GET_WPARAM] = function() {
var wparam = 0;
if (_ignoreMc1Ms0CookieProcessing) {
wparam = wparam | 2;
}
return wparam | existingGetWParamMethod.call(core);
};
}
function _batch(arr) {
var rlt = EMPTY_STR;
if (arr && arr[_DYN_LENGTH]) {
arrForEach(arr, function(item) {
if (rlt) {
rlt += "\n";
}
rlt += item;
});
}
return rlt;
}
function _serialize(event) {
var rlt = EMPTY_STR;
try {
_cleanEvent(event);
rlt = _httpManager[_DYN_SERIALIZE_OFFLINE_EV8](event);
} catch (e) {
}
return rlt;
}
function _handleUnloadEvents(evt) {
var theEvt = evt || getWindow().event;
if (theEvt.type !== "beforeunload") {
_isPageUnloadTriggered = true;
_httpManager[_DYN_SET_UNLOADING](_isPageUnloadTriggered);
}
_releaseAllQueues(2, 2);
}
function _handleShowEvents(evt) {
_isPageUnloadTriggered = false;
_httpManager[_DYN_SET_UNLOADING](_isPageUnloadTriggered);
}
function _cleanEvent(event) {
if (event.ext && event.ext[STR_TRACE]) {
delete event.ext[STR_TRACE];
}
if (event.ext && event.ext[STR_USER] && event.ext[STR_USER]["id"]) {
delete event.ext[STR_USER]["id"];
}
if (_optimizeObject) {
event.ext = optimizeObject(event.ext);
if (event.baseData) {
event.baseData = optimizeObject(event.baseData);
}
if (event.data) {
event.data = optimizeObject(event.data);
}
}
}
function _addEventToQueues(event, append) {
if (!event[_DYN_SEND_ATTEMPT]) {
event[_DYN_SEND_ATTEMPT] = 0;
}
if (!event[_DYN_LATENCY]) {
event[_DYN_LATENCY] = 1;
}
_cleanEvent(event);
if (event[_DYN_SYNC]) {
if (_currentBackoffCount || _paused) {
event[_DYN_LATENCY] = 3;
event[_DYN_SYNC] = false;
} else {
if (_httpManager) {
if (_optimizeObject) {
event = optimizeObject(event);
}
_httpManager[_DYN_SEND_SYNCHRONOUS_BAT10](EventBatch.create(event[_DYN_I_KEY], [event]), event[_DYN_SYNC] === true ? 1 : event[_DYN_SYNC], 3);
return;
}
}
}
var evtLatency = event[_DYN_LATENCY];
var queueSize = _queueSize;
var queueLimit = _queueSizeLimit;
if (evtLatency === 4) {
queueSize = _immediateQueueSize;
queueLimit = _immediateQueueSizeLimit;
}
var eventDropped = false;
if (queueSize < queueLimit) {
eventDropped = !_addEventToProperQueue(event, append);
} else {
var dropLatency = 1;
var dropNumber = EventsDroppedAtOneTime;
if (evtLatency === 4) {
dropLatency = 4;
dropNumber = 1;
}
eventDropped = true;
if (_dropEventWithLatencyOrLess(event[_DYN_I_KEY], event[_DYN_LATENCY], dropLatency, dropNumber)) {
eventDropped = !_addEventToProperQueue(event, append);
}
}
if (eventDropped) {
_notifyEvents(strEventsDiscarded, [event], EventsDiscardedReason.QueueFull);
}
}
_self.setEventQueueLimits = function(eventLimit, autoFlushLimit) {
_postConfig.eventsLimitInMem = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
_postConfig[_DYN_AUTO_FLUSH_EVENTS_LI14] = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
_setAutoLimits();
var doFlush = _queueSize > eventLimit;
if (!doFlush && _autoFlushBatchLimit > 0) {
for (var latency = 1; !doFlush && latency <= 3; latency++) {
var batchQueue = _batchQueues[latency];
if (batchQueue && batchQueue[_DYN_BATCHES]) {
arrForEach(batchQueue[_DYN_BATCHES], function(theBatch) {
if (theBatch && theBatch[_DYN_COUNT]() >= _autoFlushBatchLimit) {
doFlush = true;
}
});
}
}
}
_performAutoFlush(true, doFlush);
};
_self.pause = function() {
_clearScheduledTimer();
_paused = true;
_httpManager && _httpManager.pause();
};
_self.resume = function() {
_paused = false;
_httpManager && _httpManager.resume();
_scheduleTimer();
};
_self._loadTransmitProfiles = function(profiles) {
_resetTransmitProfiles();
objForEachKey(profiles, function(profileName, profileValue) {
var profLen = profileValue[_DYN_LENGTH];
if (profLen >= 2) {
var directValue = profLen > 2 ? profileValue[2] : 0;
profileValue.splice(0, profLen - 2);
if (profileValue[1] < 0) {
profileValue[0] = -1;
}
if (profileValue[1] > 0 && profileValue[0] > 0) {
var timerMultiplier = profileValue[0] / profileValue[1];
profileValue[0] = mathCeil(timerMultiplier) * profileValue[1];
}
if (directValue >= 0 && profileValue[1] >= 0 && directValue > profileValue[1]) {
directValue = profileValue[1];
}
profileValue[_DYN_PUSH](directValue);
_profiles[profileName] = profileValue;
}
});
};
_self.flush = function(isAsync, callback, sendReason) {
if (isAsync === void 0) {
isAsync = true;
}
var result;
if (!_paused) {
sendReason = sendReason || 1;
if (isAsync) {
if (!callback) {
result = createPromise(function(resolve3) {
callback = resolve3;
});
}
if (_flushCallbackTimer == null) {
_clearScheduledTimer();
_queueBatches(1, 0, sendReason);
_flushCallbackTimer = _createTimer(function() {
_flushCallbackTimer = null;
_flushImpl(callback, sendReason);
}, 0);
} else {
_flushCallbackQueue[_DYN_PUSH](callback);
}
} else {
var cleared = _clearScheduledTimer();
_sendEventsForLatencyAndAbove(1, 1, sendReason);
callback && callback();
if (cleared) {
_scheduleTimer();
}
}
}
return result;
};
_self.setMsaAuthTicket = function(ticket) {
_httpManager.addHeader(STR_MSA_DEVICE_TICKET, ticket);
};
_self.setAuthPluginHeader = function(token) {
_httpManager.addHeader(STR_AUTH_WEB_TOKEN, token);
};
_self.removeAuthPluginHeader = function() {
_httpManager.removeHeader(STR_AUTH_WEB_TOKEN);
};
_self.hasEvents = _hasEvents;
_self._setTransmitProfile = function(profileName) {
if (_currentProfile !== profileName && _profiles[profileName] !== void 0) {
_clearScheduledTimer();
_currentProfile = profileName;
_scheduleTimer();
}
};
proxyFunctions(_self, function() {
return _httpManager;
}, ["addResponseHandler"]);
function _sendEventsForLatencyAndAbove(latency, sendType, sendReason) {
var queued = _queueBatches(latency, sendType, sendReason);
_httpManager[_DYN_SEND_QUEUED_REQUESTS](sendType, sendReason);
return queued;
}
function _hasEvents() {
return _queueSize > 0;
}
function _scheduleTimer() {
if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0, _delayedBatchReason)) {
_httpManager[_DYN_SEND_QUEUED_REQUESTS](0, _delayedBatchReason);
}
if (_immediateQueueSize > 0 && !_immediateTimer && !_paused) {
var immediateTimeOut = _profiles[_currentProfile][2];
if (immediateTimeOut >= 0) {
_immediateTimer = _createTimer(function() {
_immediateTimer = null;
_sendEventsForLatencyAndAbove(4, 0, 1);
_scheduleTimer();
}, immediateTimeOut);
}
}
var timeOut = _profiles[_currentProfile][1];
if (!_scheduledTimer && !_flushCallbackTimer && timeOut >= 0 && !_paused) {
if (_hasEvents()) {
_scheduledTimer = _createTimer(function() {
_scheduledTimer = null;
_sendEventsForLatencyAndAbove(_timerCount === 0 ? 3 : 1, 0, 1);
_timerCount++;
_timerCount %= 2;
_scheduleTimer();
}, timeOut);
} else {
_timerCount = 0;
}
}
}
_self[_DYN__BACK_OFF_TRANSMISSI12] = function() {
if (_currentBackoffCount < MaxBackoffCount) {
_currentBackoffCount++;
_clearScheduledTimer();
_scheduleTimer();
}
};
_self._clearBackOff = function() {
if (_currentBackoffCount) {
_currentBackoffCount = 0;
_clearScheduledTimer();
_scheduleTimer();
}
};
function _initDefaults() {
_postConfig = null;
_isTeardownCalled = false;
_flushCallbackQueue = [];
_flushCallbackTimer = null;
_paused = false;
_immediateQueueSize = 0;
_immediateQueueSizeLimit = 500;
_queueSize = 0;
_queueSizeLimit = MaxEventsLimitInMem;
_profiles = {};
_currentProfile = RT_PROFILE;
_scheduledTimer = null;
_immediateTimer = null;
_currentBackoffCount = 0;
_timerCount = 0;
_batchQueues = {};
_autoFlushEventsLimit = 0;
_unloadHandlersAdded = false;
_autoFlushBatchLimit = 0;
_delayedBatchSendLatency = -1;
_delayedBatchReason = null;
_optimizeObject = true;
_isPageUnloadTriggered = false;
_maxEventSendAttempts = MaxSendAttempts;
_maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
_evtNamespace = null;
_overrideInstrumentationKey = null;
_maxEvtPerBatch = null;
_disableTelemetry = false;
_timeoutWrapper = createTimeoutWrapper();
_httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRequestRetriesBeforeBackoff, {
requeue: _requeueEvents,
send: _sendingEvent,
sent: _eventsSentEvent,
drop: _eventsDropped,
rspFail: _eventsResponseFail,
oth: _otherEvent
});
_initializeProfiles();
_clearQueues();
_setAutoLimits();
}
function _createTimer(theTimerFunc, timeOut) {
if (timeOut === 0 && _currentBackoffCount) {
timeOut = 1;
}
var timerMultiplier = 1e3;
if (_currentBackoffCount) {
timerMultiplier = retryPolicyGetMillisToBackoffForRetry(_currentBackoffCount - 1);
}
return _timeoutWrapper.set(theTimerFunc, timeOut * timerMultiplier);
}
function _clearScheduledTimer() {
if (_scheduledTimer !== null) {
_scheduledTimer.cancel();
_scheduledTimer = null;
_timerCount = 0;
return true;
}
return false;
}
function _releaseAllQueues(sendType, sendReason) {
_clearScheduledTimer();
if (_flushCallbackTimer) {
_flushCallbackTimer.cancel();
_flushCallbackTimer = null;
}
if (!_paused) {
_sendEventsForLatencyAndAbove(1, sendType, sendReason);
}
}
function _clearQueues() {
_batchQueues[4] = {
batches: [],
iKeyMap: {}
};
_batchQueues[3] = {
batches: [],
iKeyMap: {}
};
_batchQueues[2] = {
batches: [],
iKeyMap: {}
};
_batchQueues[1] = {
batches: [],
iKeyMap: {}
};
}
function _getEventBatch(iKey, latency, create) {
var batchQueue = _batchQueues[latency];
if (!batchQueue) {
latency = 1;
batchQueue = _batchQueues[latency];
}
var eventBatch = batchQueue.iKeyMap[iKey];
if (!eventBatch && create) {
eventBatch = EventBatch.create(iKey);
batchQueue.batches[_DYN_PUSH](eventBatch);
batchQueue.iKeyMap[iKey] = eventBatch;
}
return eventBatch;
}
function _performAutoFlush(isAsync, doFlush) {
if (_httpManager[_DYN_CAN_SEND_REQUEST]() && !_currentBackoffCount) {
if (_autoFlushEventsLimit > 0 && _queueSize > _autoFlushEventsLimit) {
doFlush = true;
}
if (doFlush && _flushCallbackTimer == null) {
_self.flush(isAsync, function() {
}, 20);
}
}
}
function _addEventToProperQueue(event, append) {
if (_optimizeObject) {
event = optimizeObject(event);
}
var latency = event[_DYN_LATENCY];
var eventBatch = _getEventBatch(event[_DYN_I_KEY], latency, true);
if (eventBatch.addEvent(event)) {
if (latency !== 4) {
_queueSize++;
if (append && event[_DYN_SEND_ATTEMPT] === 0) {
_performAutoFlush(!event.sync, _autoFlushBatchLimit > 0 && eventBatch[_DYN_COUNT]() >= _autoFlushBatchLimit);
}
} else {
_immediateQueueSize++;
}
return true;
}
return false;
}
function _dropEventWithLatencyOrLess(iKey, latency, currentLatency, dropNumber) {
while (currentLatency <= latency) {
var eventBatch = _getEventBatch(iKey, latency, true);
if (eventBatch && eventBatch[_DYN_COUNT]() > 0) {
var droppedEvents = eventBatch[_DYN_SPLIT](0, dropNumber);
var droppedCount = droppedEvents[_DYN_COUNT]();
if (droppedCount > 0) {
if (currentLatency === 4) {
_immediateQueueSize -= droppedCount;
} else {
_queueSize -= droppedCount;
}
_notifyBatchEvents(strEventsDiscarded, [droppedEvents], EventsDiscardedReason.QueueFull);
return true;
}
}
currentLatency++;
}
_resetQueueCounts();
return false;
}
function _resetQueueCounts() {
var immediateQueue = 0;
var normalQueue = 0;
var _loop_1 = function(latency2) {
var batchQueue = _batchQueues[latency2];
if (batchQueue && batchQueue[_DYN_BATCHES]) {
arrForEach(batchQueue[_DYN_BATCHES], function(theBatch) {
if (latency2 === 4) {
immediateQueue += theBatch[_DYN_COUNT]();
} else {
normalQueue += theBatch[_DYN_COUNT]();
}
});
}
};
for (var latency = 1; latency <= 4; latency++) {
_loop_1(latency);
}
_queueSize = normalQueue;
_immediateQueueSize = immediateQueue;
}
function _queueBatches(latency, sendType, sendReason) {
var eventsQueued = false;
var isAsync = sendType === 0;
if (!isAsync || _httpManager[_DYN_CAN_SEND_REQUEST]()) {
doPerf(_self.core, function() {
return "PostChannel._queueBatches";
}, function() {
var droppedEvents = [];
var latencyToProcess = 4;
while (latencyToProcess >= latency) {
var batchQueue = _batchQueues[latencyToProcess];
if (batchQueue && batchQueue.batches && batchQueue.batches[_DYN_LENGTH] > 0) {
arrForEach(batchQueue[_DYN_BATCHES], function(theBatch) {
if (!_httpManager.addBatch(theBatch)) {
droppedEvents = droppedEvents[_DYN_CONCAT](theBatch[_DYN_EVENTS]());
} else {
eventsQueued = eventsQueued || theBatch && theBatch[_DYN_COUNT]() > 0;
}
if (latencyToProcess === 4) {
_immediateQueueSize -= theBatch[_DYN_COUNT]();
} else {
_queueSize -= theBatch[_DYN_COUNT]();
}
});
batchQueue[_DYN_BATCHES] = [];
batchQueue.iKeyMap = {};
}
latencyToProcess--;
}
if (droppedEvents[_DYN_LENGTH] > 0) {
_notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.KillSwitch);
}
if (eventsQueued && _delayedBatchSendLatency >= latency) {
_delayedBatchSendLatency = -1;
_delayedBatchReason = 0;
}
}, function() {
return { latency, sendType, sendReason };
}, !isAsync);
} else {
_delayedBatchSendLatency = _delayedBatchSendLatency >= 0 ? mathMin(_delayedBatchSendLatency, latency) : latency;
_delayedBatchReason = mathMax(_delayedBatchReason, sendReason);
}
return eventsQueued;
}
function _flushImpl(callback, sendReason) {
_sendEventsForLatencyAndAbove(1, 0, sendReason);
_resetQueueCounts();
_waitForIdleManager(function() {
if (callback) {
callback();
}
if (_flushCallbackQueue[_DYN_LENGTH] > 0) {
_flushCallbackTimer = _createTimer(function() {
_flushCallbackTimer = null;
_flushImpl(_flushCallbackQueue.shift(), sendReason);
}, 0);
} else {
_flushCallbackTimer = null;
_scheduleTimer();
}
});
}
function _waitForIdleManager(callback) {
if (_httpManager.isCompletelyIdle()) {
callback();
} else {
_flushCallbackTimer = _createTimer(function() {
_flushCallbackTimer = null;
_waitForIdleManager(callback);
}, FlushCheckTimer);
}
}
function _resetTransmitProfiles() {
_clearScheduledTimer();
_initializeProfiles();
_currentProfile = RT_PROFILE;
_scheduleTimer();
}
function _initializeProfiles() {
_profiles = {};
_profiles[RT_PROFILE] = [2, 1, 0];
_profiles[NRT_PROFILE] = [6, 3, 0];
_profiles[BE_PROFILE] = [18, 9, 0];
}
function _requeueEvents(batches, reason) {
var droppedEvents = [];
var maxSendAttempts = _maxEventSendAttempts;
if (_isPageUnloadTriggered) {
maxSendAttempts = _maxUnloadEventSendAttempts;
}
arrForEach(batches, function(theBatch) {
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
arrForEach(theBatch[_DYN_EVENTS](), function(theEvent) {
if (theEvent) {
if (theEvent[_DYN_SYNC]) {
theEvent[_DYN_LATENCY] = 4;
theEvent[_DYN_SYNC] = false;
}
if (theEvent[_DYN_SEND_ATTEMPT] < maxSendAttempts) {
setProcessTelemetryTimings(theEvent, _self[_DYN_IDENTIFIER]);
_addEventToQueues(theEvent, false);
} else {
droppedEvents[_DYN_PUSH](theEvent);
}
}
});
}
});
if (droppedEvents[_DYN_LENGTH] > 0) {
_notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.NonRetryableStatus);
}
if (_isPageUnloadTriggered) {
_releaseAllQueues(2, 2);
}
}
function _callNotification(evtName, theArgs) {
var manager = _notificationManager || {};
var notifyFunc = manager[evtName];
if (notifyFunc) {
try {
notifyFunc.apply(manager, theArgs);
} catch (e) {
_throwInternal(_self.diagLog(), 1, 74, evtName + " notification failed: " + e);
}
}
}
function _notifyEvents(evtName, theEvents) {
var extraArgs = [];
for (var _i = 2; _i < arguments.length; _i++) {
extraArgs[_i - 2] = arguments[_i];
}
if (theEvents && theEvents[_DYN_LENGTH] > 0) {
_callNotification(evtName, [theEvents][_DYN_CONCAT](extraArgs));
}
}
function _notifyBatchEvents(evtName, batches) {
var extraArgs = [];
for (var _i = 2; _i < arguments.length; _i++) {
extraArgs[_i - 2] = arguments[_i];
}
if (batches && batches[_DYN_LENGTH] > 0) {
arrForEach(batches, function(theBatch) {
if (theBatch && theBatch[_DYN_COUNT]() > 0) {
_callNotification(evtName, [theBatch.events()][_DYN_CONCAT](extraArgs));
}
});
}
}
function _sendingEvent(batches, reason, isSyncRequest) {
if (batches && batches[_DYN_LENGTH] > 0) {
_callNotification("eventsSendRequest", [reason >= 1e3 && reason <= 1999 ? reason - 1e3 : 0, isSyncRequest !== true]);
}
}
function _eventsSentEvent(batches, reason) {
_notifyBatchEvents("eventsSent", batches, reason);
_scheduleTimer();
}
function _eventsDropped(batches, reason) {
_notifyBatchEvents(strEventsDiscarded, batches, reason >= 8e3 && reason <= 8999 ? reason - 8e3 : EventsDiscardedReason.Unknown);
}
function _eventsResponseFail(batches) {
_notifyBatchEvents(strEventsDiscarded, batches, EventsDiscardedReason.NonRetryableStatus);
_scheduleTimer();
}
function _otherEvent(batches, reason) {
_notifyBatchEvents(strEventsDiscarded, batches, EventsDiscardedReason.Unknown);
_scheduleTimer();
}
function _setAutoLimits() {
if (!_disableAutoBatchFlushLimit) {
_autoFlushBatchLimit = mathMax(_maxEvtPerBatch * (MaxConnections + 1), _queueSizeLimit / 6);
} else {
_autoFlushBatchLimit = 0;
}
}
});
return _this;
}
PostChannel2.__ieDyn = 1;
return PostChannel2;
})(BaseTelemetryPlugin)
);
exports3.BE_PROFILE = BE_PROFILE;
exports3.NRT_PROFILE = NRT_PROFILE;
exports3.PostChannel = PostChannel;
exports3.RT_PROFILE = RT_PROFILE;
}));
}
});
// node_modules/@vscode/extension-telemetry/dist/node/common/1dsClientFactory.js
var require_dsClientFactory = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/common/1dsClientFactory.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = exports2 && exports2.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.oneDataSystemClientFactory = void 0;
var getAICore = async (key, vscodeAPI, xhrOverride) => {
const oneDs = await Promise.resolve().then(() => __importStar(require_ms_core()));
const postPlugin = await Promise.resolve().then(() => __importStar(require_ms_post()));
const appInsightsCore = new oneDs.AppInsightsCore();
const collectorChannelPlugin = new postPlugin.PostChannel();
const coreConfig = {
instrumentationKey: key,
endpointUrl: "https://mobile.events.data.microsoft.com/OneCollector/1.0",
loggingLevelTelemetry: 0,
loggingLevelConsole: 0,
disableCookiesUsage: true,
disableDbgExt: true,
disableInstrumentationKeyValidation: true,
channels: [[
collectorChannelPlugin
]]
};
if (xhrOverride) {
coreConfig.extensionConfig = {};
const channelConfig = {
alwaysUseXhrOverride: true,
httpXHROverride: xhrOverride
};
coreConfig.extensionConfig[collectorChannelPlugin.identifier] = channelConfig;
}
const config = vscodeAPI.workspace.getConfiguration("telemetry");
const internalTesting = config.get("internalTesting");
appInsightsCore.initialize(coreConfig, []);
appInsightsCore.addTelemetryInitializer((envelope) => {
envelope["ext"] = envelope["ext"] ?? {};
envelope["ext"]["web"] = envelope["ext"]["web"] ?? {};
envelope["ext"]["web"]["consentDetails"] = '{"GPC_DataSharingOptIn":false}';
if (!internalTesting) {
return;
}
envelope["ext"]["utc"] = envelope["ext"]["utc"] ?? {};
envelope["ext"]["utc"]["flags"] = 8462029;
});
return appInsightsCore;
};
var oneDataSystemClientFactory = async (key, vscodeAPI, xhrOverride) => {
let appInsightsCore = await getAICore(key, vscodeAPI, xhrOverride);
const flushOneDS = async () => {
try {
const flushPromise = new Promise((resolve3, reject) => {
if (!appInsightsCore) {
resolve3();
return;
}
appInsightsCore.flush(true, (completedFlush) => {
if (!completedFlush) {
reject("Failed to flush app 1DS!");
return;
}
});
});
return flushPromise;
} catch (e) {
throw new Error("Failed to flush 1DS!\n" + e.message);
}
};
const telemetryClient = {
logEvent: (eventName, data) => {
try {
appInsightsCore?.track({
name: eventName,
baseData: { name: eventName, properties: data?.properties, measurements: data?.measurements }
});
} catch (e) {
throw new Error("Failed to log event to app insights!\n" + e.message);
}
},
flush: flushOneDS,
dispose: async () => {
const disposePromise = new Promise((resolve3) => {
if (!appInsightsCore) {
resolve3();
return;
}
appInsightsCore.unload(false, () => {
resolve3();
appInsightsCore = void 0;
return;
}, 1e3);
});
return disposePromise;
}
};
return telemetryClient;
};
exports2.oneDataSystemClientFactory = oneDataSystemClientFactory;
}
});
// node_modules/@microsoft/applicationinsights-common/dist/es5/applicationinsights-common.js
var require_applicationinsights_common = __commonJS({
"node_modules/@microsoft/applicationinsights-common/dist/es5/applicationinsights-common.js"(exports2, module2) {
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory((global2.Microsoft = global2.Microsoft || {}, global2.Microsoft.ApplicationInsights = global2.Microsoft.ApplicationInsights || {})));
})(exports2, (function(exports3) {
"use strict";
// @__NO_SIDE_EFFECTS__
function _pureAssign(func1, func2) {
return func1 || func2;
}
// @__NO_SIDE_EFFECTS__
function _pureRef(value, name) {
return value[name];
}
var UNDEF_VALUE = void 0;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
var ObjClass$1 = /* @__PURE__ */ _pureAssign(Object);
var ObjProto$1 = /* @__PURE__ */ _pureRef(ObjClass$1, PROTOTYPE);
var StrCls = /* @__PURE__ */ _pureAssign(String);
var StrProto = /* @__PURE__ */ _pureRef(StrCls, PROTOTYPE);
var MathCls = /* @__PURE__ */ _pureAssign(Math);
var ArrCls = /* @__PURE__ */ _pureAssign(Array);
var ArrProto = /* @__PURE__ */ _pureRef(ArrCls, PROTOTYPE);
var ArrSlice = /* @__PURE__ */ _pureRef(ArrProto, "slice");
var POLYFILL_TAG = "_polyfill";
var POLYFILL_TYPE_NAME = "__nw21$polytype__";
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
} catch (e) {
return { e };
}
}
// @__NO_SIDE_EFFECTS__
function _createIs(theType) {
return function(value) {
return typeof value === theType;
};
}
// @__NO_SIDE_EFFECTS__
function _createObjIs(theName) {
var theType = "[object " + theName + "]";
return function(value) {
return !!(value && /* @__PURE__ */ objToString(value) === theType);
};
}
// @__NO_SIDE_EFFECTS__
function objToString(value) {
return ObjProto$1[TO_STRING].call(value);
}
// @__NO_SIDE_EFFECTS__
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
// @__NO_SIDE_EFFECTS__
function isStrictUndefined(arg) {
return arg === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isNullOrUndefined(value) {
return value === NULL_VALUE || /* @__PURE__ */ isUndefined(value);
}
// @__NO_SIDE_EFFECTS__
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
var isString = /* @__PURE__ */ _createIs("string");
var isFunction = /* @__PURE__ */ _createIs(FUNCTION);
// @__NO_SIDE_EFFECTS__
function isObject(value) {
if (!value && /* @__PURE__ */ isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = /* @__PURE__ */ _pureRef(ArrCls, "isArray");
var isError = /* @__PURE__ */ _createObjIs("Error");
function _returnNothing() {
return;
}
var asString = /* @__PURE__ */ _pureAssign(StrCls);
var ERROR_TYPE = "[object Error]";
// @__NO_SIDE_EFFECTS__
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto$1[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? typeof format === "number" ? format : 4 : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
} catch (e) {
propertyValueDump = " - " + /* @__PURE__ */ dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwError(message) {
throw new Error(message);
}
function throwTypeError(message) {
throw new TypeError(message);
}
function _throwIfNullOrUndefined(obj) {
if (/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + /* @__PURE__ */ dumpObj(value) + "' is not a string");
}
}
// @__NO_SIDE_EFFECTS__
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto$1.hasOwnProperty[CALL](obj, prop);
}
var _objGetOwnPropertyDescriptor$2 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var objHasOwn = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "hasOwn"), polyObjHasOwn);
// @__NO_SIDE_EFFECTS__
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return /* @__PURE__ */ objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (/* @__PURE__ */ isObject(theObject) || isFunction(theObject))) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var _unwrapFunction = _unwrapFunctionWithPoly;
// @__NO_SIDE_EFFECTS__
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function(thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError('"' + asString(funcName) + '" not defined for ' + /* @__PURE__ */ dumpObj(thisArg));
};
}
var _objGetOwnPropertyDescriptor$1 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
// @__NO_SIDE_EFFECTS__
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function() {
return value.l.v;
};
var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = function(newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function(key, value2) {
prop[propMap[key]] = /* @__PURE__ */ isStrictUndefined(value2) ? prop[propMap[key]] : value2;
});
return prop;
}
var objDefineProp = /* @__PURE__ */ _pureRef(ObjClass$1, "defineProperty");
var objDefineProperties = /* @__PURE__ */ _pureRef(ObjClass$1, "defineProperties");
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, /* @__PURE__ */ _createProp(propDesc));
}
// @__NO_SIDE_EFFECTS__
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function(key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value,
enumerable: true,
writable: false
});
}
var _objFreeze = /* @__PURE__ */ _pureRef(ObjClass$1, "freeze");
function _doNothing(value) {
return value;
}
// @__NO_SIDE_EFFECTS__
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = /* @__PURE__ */ _pureRef(ObjClass$1, "assign");
var objKeys = /* @__PURE__ */ _pureRef(ObjClass$1, "keys");
var objFreeze = /* @__PURE__ */ _pureAssign(_objFreeze, _doNothing);
var objGetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "getPrototypeOf"), _getProto);
// @__NO_SIDE_EFFECTS__
function createEnum(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 1, 0, objFreeze);
}
// @__NO_SIDE_EFFECTS__
function createSimpleMap(values) {
var mapClass = {};
objForEachKey(values, function(key, value) {
_assignMapValue(mapClass, key, value[1]);
_assignMapValue(mapClass, value[0], value[1]);
});
return objFreeze(mapClass);
}
// @__NO_SIDE_EFFECTS__
function createTypeMap(values) {
return /* @__PURE__ */ createSimpleMap(values);
}
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
// @__NO_SIDE_EFFECTS__
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var mathMin = /* @__PURE__ */ _pureRef(MathCls, "min");
var mathMax = /* @__PURE__ */ _pureRef(MathCls, "max");
var strSlice = /* @__PURE__ */ _unwrapFunction("slice", StrProto);
var strSubstring = /* @__PURE__ */ _unwrapFunction("substring", StrProto);
var strSubstr = /* @__PURE__ */ _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
// @__NO_SIDE_EFFECTS__
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(value);
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (/* @__PURE__ */ isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
// @__NO_SIDE_EFFECTS__
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(function() {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
var objCreate = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "create"), polyObjCreate);
// @__NO_SIDE_EFFECTS__
function polyObjCreate(obj, properties) {
var newObj = null;
function tempFunc() {
}
if (!/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + /* @__PURE__ */ dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(function() {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
} else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
// @__NO_SIDE_EFFECTS__
function utcNow() {
return (Date.now || polyUtcNow)();
}
// @__NO_SIDE_EFFECTS__
function polyUtcNow() {
return (/* @__PURE__ */ new Date()).getTime();
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = /* @__PURE__ */ _getGlobalConfig();
}
// @__NO_SIDE_EFFECTS__
function getLazy(cb, argArray) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function() {
var result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
var mathRandom = /* @__PURE__ */ _pureRef(MathCls, "random");
var _uniqueInstanceId = /* @__PURE__ */ getLazy(function() {
var value = (/* @__PURE__ */ utcNow()).toString(36).slice(2);
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
});
var UNIQUE_REGISTRY_ID = "_urid";
var POLY_SYM = "$nw21sym";
var _polySymbols;
var _polyId = 0;
// @__NO_SIDE_EFFECTS__
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = /* @__PURE__ */ _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
// @__NO_SIDE_EFFECTS__
function polyNewSymbol(description) {
var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
var symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
var theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, function() {
return symString + POLY_SYM + uniqueId;
});
_setProp("valueOf", function() {
return theSymbol;
});
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
// @__NO_SIDE_EFFECTS__
function polySymbolFor(key) {
var registry = /* @__PURE__ */ _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = /* @__PURE__ */ polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function() {
return regId_1 + "_" + newSymbol_1[TO_STRING]();
};
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
// @__NO_SIDE_EFFECTS__
function createCachedValue(value) {
return objDefineProp({
toJSON: function() {
return value;
}
}, "v", { value });
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function() {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = /* @__PURE__ */ createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = /* @__PURE__ */ createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
// @__NO_SIDE_EFFECTS__
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
} else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
} catch (e) {
}
}
return NULL_VALUE;
}
var getDocument = /* @__PURE__ */ _getGlobalInstFn(getInst, ["document"]);
// @__NO_SIDE_EFFECTS__
function hasWindow() {
return !!/* @__PURE__ */ getWindow();
}
var getWindow = /* @__PURE__ */ _getGlobalInstFn(getInst, [WINDOW]);
// @__NO_SIDE_EFFECTS__
function hasNavigator() {
return !!/* @__PURE__ */ getNavigator();
}
var getNavigator = /* @__PURE__ */ _getGlobalInstFn(getInst, ["navigator"]);
var _symbol;
var _symbolFor;
// @__NO_SIDE_EFFECTS__
function _initSymbol() {
_symbol = /* @__PURE__ */ createCachedValue(safe(getInst, [SYMBOL]).v);
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return gblSym.v ? gblSym.v[key] : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v(description) : !noPoly ? /* @__PURE__ */ polyNewSymbol(description) : NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = (!_globalLazyTestHooks.lzy ? _symbolFor : 0) || /* @__PURE__ */ createCachedValue(safe(_getSymbolKey, ["for"]).v);
return (_symbolFor.v || polySymbolFor)(key);
}
var arrIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", ArrProto);
var arrMap = /* @__PURE__ */ _unwrapFunction("map", ArrProto);
var arrReduce = /* @__PURE__ */ _unwrapFunction("reduce", ArrProto);
var _isProtoArray;
var objSetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "setPrototypeOf"), _polyObjSetPrototypeOf);
function _polyObjSetPrototypeOf(obj, proto) {
var _a2;
!_isProtoArray && (_isProtoArray = /* @__PURE__ */ createCachedValue((_a2 = {}, _a2[__PROTO__] = [], _a2) instanceof Array));
_isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function(key, value) {
return obj[key] = value;
});
return obj;
}
// @__NO_SIDE_EFFECTS__
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
// @__NO_SIDE_EFFECTS__
function createCustomError(name, constructCb, errorBase) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return /* @__PURE__ */ _createCustomError(name, function() {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
} finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
// @__NO_SIDE_EFFECTS__
function _createTrimFn(exp) {
return function _doTrim(value) {
_throwIfNullOrUndefined(value);
if (value && value.replace) {
value = value.replace(exp, EMPTY);
}
return value;
};
}
var polyStrTrim = /* @__PURE__ */ _createTrimFn(/^\s+|(?=\s)\s+$/g);
var strTrim = /* @__PURE__ */ _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
var mathFloor = /* @__PURE__ */ _pureRef(MathCls, "floor");
var _fnToString;
var _objCtrFnString;
var _gblWindow;
// @__NO_SIDE_EFFECTS__
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = /* @__PURE__ */ hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass$1);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (/* @__PURE__ */ objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
} catch (ex) {
}
}
return result;
}
var _perf;
// @__NO_SIDE_EFFECTS__
function getPerformance() {
!_globalLazyTestHooks && _initTestHooks();
if (!_perf || _globalLazyTestHooks.lzy) {
_perf = /* @__PURE__ */ createCachedValue(safe(getInst, ["performance"]).v);
}
return _perf.v;
}
var mathRound = /* @__PURE__ */ _pureRef(MathCls, "round");
var objGetOwnPropertyDescriptor = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var strEndsWith = /* @__PURE__ */ _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith);
// @__NO_SIDE_EFFECTS__
function polyStrEndsWith(value, searchString, length) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var end = !/* @__PURE__ */ isUndefined(length) && length < value[LENGTH] ? length : value[LENGTH];
return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
}
var strIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", StrProto);
var REF = "ref";
var UNREF = "unref";
var HAS_REF = "hasRef";
var ENABLED = "enabled";
// @__NO_SIDE_EFFECTS__
function _createTimerHandler(startTimer, refreshFn, cancelFn) {
var ref = true;
var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
var theTimerHandler;
function _unref() {
ref = false;
timerId && timerId[UNREF] && timerId[UNREF]();
return theTimerHandler;
}
function _cancel() {
timerId && cancelFn(timerId);
timerId = NULL_VALUE;
}
function _refresh() {
timerId = refreshFn(timerId);
if (!ref) {
_unref();
}
return theTimerHandler;
}
function _setEnabled(value) {
!value && timerId && _cancel();
value && !timerId && _refresh();
}
theTimerHandler = {
cancel: _cancel,
refresh: _refresh
};
theTimerHandler[HAS_REF] = function() {
if (timerId && timerId[HAS_REF]) {
return timerId[HAS_REF]();
}
return ref;
};
theTimerHandler[REF] = function() {
ref = true;
timerId && timerId[REF] && timerId[REF]();
return theTimerHandler;
};
theTimerHandler[UNREF] = _unref;
theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
get: function() {
return !!timerId;
},
set: _setEnabled
});
return {
h: theTimerHandler,
dn: function() {
timerId = NULL_VALUE;
}
};
}
var _setTimeoutFn;
var _clearTimeoutFn;
function _resolveTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
result = globalOverrides[0];
}
}
return result || setTimeout;
}
function _resolveClearTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
result = globalOverrides[1];
}
}
return result || clearTimeout;
}
function _createTimeoutWith(startTimer, overrideFn, theArgs) {
var isArr = isArray(overrideFn);
var len = isArr ? overrideFn.length : 0;
var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : !isArr ? overrideFn : UNDEF_VALUE);
var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
var timerFn = theArgs[0];
theArgs[0] = function() {
handler.dn();
fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
};
var handler = /* @__PURE__ */ _createTimerHandler(startTimer, function(timerId) {
if (timerId) {
if (timerId.refresh) {
timerId.refresh();
return timerId;
}
fnApply(clearFn, UNDEF_VALUE, [timerId]);
}
return fnApply(setFn, UNDEF_VALUE, theArgs);
}, function(timerId) {
fnApply(clearFn, UNDEF_VALUE, [timerId]);
});
return handler.h;
}
function scheduleTimeout(callback, timeout) {
return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
var createEnumStyle = createEnum;
var createValueMap = createTypeMap;
var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
var _DYN_LENGTH$1 = "length";
var _DYN_WARN_TO_CONSOLE = "warnToConsole";
var _DYN_THROW_INTERNAL = "throwInternal";
var _DYN_WATCH = "watch";
var _DYN_APPLY = "apply";
var _DYN_PUSH = "push";
var _DYN_SPLICE = "splice";
var _DYN_LOGGER = "logger";
var _DYN_CANCEL = "cancel";
var _DYN_NAME$1 = "name";
var _DYN_UNLOAD = "unload";
var _DYN_VERSION = "version";
var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
var _DYN_MESSAGE_ID = "messageId";
var _DYN_MESSAGE$1 = "message";
var _DYN_DIAG_LOG = "diagLog";
var _DYN_USER_AGENT = "userAgent";
var _DYN_SPLIT$1 = "split";
var _DYN_REPLACE = "replace";
var _DYN_SUBSTRING = "substring";
var _DYN_INDEX_OF = "indexOf";
var _DYN_TYPE = "type";
var _DYN_EVT_NAME = "evtName";
var _DYN_TRACE_FLAGS = "traceFlags";
var _DYN_GET_ATTRIBUTE = "getAttribute";
var aggregationErrorType;
function throwAggregationError(message, sourceErrors) {
if (!aggregationErrorType) {
aggregationErrorType = /* @__PURE__ */ createCustomError("AggregationError", function(self2, args) {
if (args[_DYN_LENGTH$1] > 1) {
self2.errors = args[1];
}
});
}
var theMessage = message || "One or more errors occurred.";
arrForEach(sourceErrors, function(srcError, idx) {
theMessage += "\n".concat(idx, " > ").concat(/* @__PURE__ */ dumpObj(srcError));
});
throw new aggregationErrorType(theMessage, sourceErrors || []);
}
var strShimFunction = "function";
var strShimObject = "object";
var strShimUndefined = "undefined";
var strShimPrototype = "prototype";
var ObjClass = Object;
var ObjProto = ObjClass[strShimPrototype];
(getGlobal() || {})["Symbol"];
(getGlobal() || {})["Reflect"];
var strHasOwnProperty = "hasOwnProperty";
var __objAssignFnImpl = function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) {
if (ObjProto[strHasOwnProperty].call(s, p)) {
t[p] = s[p];
}
}
}
return t;
};
var __assignFn = objAssign || __objAssignFnImpl;
var extendStaticsFn = function(d, b) {
extendStaticsFn = ObjClass["setPrototypeOf"] || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) {
if (b2[strHasOwnProperty](p)) {
d2[p] = b2[p];
}
}
};
return extendStaticsFn(d, b);
};
function __extendsFn(d, b) {
if (typeof b !== strShimFunction && b !== null) {
throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
}
extendStaticsFn(d, b);
function __() {
this.constructor = d;
}
d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
}
var _a$1;
var Constructor = "constructor";
var Prototype = "prototype";
var strFunction = "function";
var DynInstFuncTable = "_dynInstFuncs";
var DynProxyTag = "_isDynProxy";
var DynClassName = "_dynClass";
var DynClassNamePrefix = "_dynCls$";
var DynInstChkTag = "_dynInstChk";
var DynAllowInstChkTag = DynInstChkTag;
var DynProtoDefaultOptions = "_dfOpts";
var UnknownValue = "_unknown_";
var str__Proto = "__proto__";
var DynProtoBaseProto = "_dyn" + str__Proto;
var DynProtoGlobalSettings = "__dynProto$Gbl";
var DynProtoCurrent = "_dynInstProto";
var strUseBaseInst = "useBaseInst";
var strSetInstFuncs = "setInstFuncs";
var Obj = Object;
var _objGetPrototypeOf = Obj["getPrototypeOf"];
var _objGetOwnProps = Obj["getOwnPropertyNames"];
var _gbl = getGlobal();
var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
o: (_a$1 = {}, _a$1[strSetInstFuncs] = true, _a$1[strUseBaseInst] = true, _a$1),
n: 1e3
});
function _isObjectOrArrayPrototype(target) {
return target && (target === Obj[Prototype] || target === Array[Prototype]);
}
function _isObjectArrayOrFunctionPrototype(target) {
return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
}
function _getObjProto(target) {
var newProto;
if (target) {
if (_objGetPrototypeOf) {
return _objGetPrototypeOf(target);
}
var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
newProto = target[DynProtoBaseProto] || curProto;
if (!/* @__PURE__ */ objHasOwnProperty(target, DynProtoBaseProto)) {
delete target[DynProtoCurrent];
newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
target[DynProtoCurrent] = curProto;
}
}
return newProto;
}
function _forEachProp(target, func) {
var props = [];
if (_objGetOwnProps) {
props = _objGetOwnProps(target);
} else {
for (var name_1 in target) {
if (typeof name_1 === "string" && /* @__PURE__ */ objHasOwnProperty(target, name_1)) {
props.push(name_1);
}
}
}
if (props && props.length > 0) {
for (var lp = 0; lp < props.length; lp++) {
func(props[lp]);
}
}
}
function _isDynamicCandidate(target, funcName, skipOwn) {
return funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || /* @__PURE__ */ objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype;
}
function _throwTypeError(message) {
throwTypeError("DynamicProto: " + message);
}
function _getInstanceFuncs(thisTarget) {
var instFuncs = objCreate(null);
_forEachProp(thisTarget, function(name) {
if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
instFuncs[name] = thisTarget[name];
}
});
return instFuncs;
}
function _hasVisited(values, value) {
for (var lp = values.length - 1; lp >= 0; lp--) {
if (values[lp] === value) {
return true;
}
}
return false;
}
function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
function _instFuncProxy(target, funcHost, funcName) {
var theFunc = funcHost[funcName];
if (theFunc[DynProxyTag] && useBaseInst) {
var instFuncTable = target[DynInstFuncTable] || {};
if (instFuncTable[DynAllowInstChkTag] !== false) {
theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
}
}
return function() {
return theFunc.apply(target, arguments);
};
}
var baseFuncs = objCreate(null);
_forEachProp(instFuncs, function(name) {
baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
});
var baseProto = _getObjProto(classProto);
var visited = [];
while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
_forEachProp(baseProto, function(name) {
if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
}
});
visited.push(baseProto);
baseProto = _getObjProto(baseProto);
}
return baseFuncs;
}
function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
var instFunc = null;
if (target && /* @__PURE__ */ objHasOwnProperty(proto, DynClassName)) {
var instFuncTable = target[DynInstFuncTable] || objCreate(null);
instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
if (!instFunc) {
_throwTypeError("Missing [" + funcName + "] " + strFunction);
}
if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
var canAddInst = !/* @__PURE__ */ objHasOwnProperty(target, funcName);
var objProto = _getObjProto(target);
var visited = [];
while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
var protoFunc = objProto[funcName];
if (protoFunc) {
canAddInst = protoFunc === currentDynProtoProxy;
break;
}
visited.push(objProto);
objProto = _getObjProto(objProto);
}
try {
if (canAddInst) {
target[funcName] = instFunc;
}
instFunc[DynInstChkTag] = 1;
} catch (e) {
instFuncTable[DynAllowInstChkTag] = false;
}
}
}
return instFunc;
}
function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
var protoFunc = proto[funcName];
if (protoFunc === currentDynProtoProxy) {
protoFunc = _getObjProto(proto)[funcName];
}
if (typeof protoFunc !== strFunction) {
_throwTypeError("[" + funcName + "] is not a " + strFunction);
}
return protoFunc;
}
function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
function _createDynamicPrototype(proto2, funcName) {
var dynProtoProxy = function() {
var instFunc = _getInstFunc(this, funcName, proto2, dynProtoProxy) || _getProtoFunc(funcName, proto2, dynProtoProxy);
return instFunc.apply(this, arguments);
};
dynProtoProxy[DynProxyTag] = 1;
return dynProtoProxy;
}
if (!_isObjectOrArrayPrototype(proto)) {
var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
if (!_isObjectOrArrayPrototype(instFuncTable)) {
var instFuncs_1 = instFuncTable[className] = instFuncTable[className] || objCreate(null);
if (instFuncTable[DynAllowInstChkTag] !== false) {
instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
}
if (!_isObjectOrArrayPrototype(instFuncs_1)) {
_forEachProp(target, function(name) {
if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
instFuncs_1[name] = target[name];
delete target[name];
if (!/* @__PURE__ */ objHasOwnProperty(proto, name) || proto[name] && !proto[name][DynProxyTag]) {
proto[name] = _createDynamicPrototype(proto, name);
}
}
});
}
}
}
}
function _checkPrototype(classProto, thisTarget) {
if (_objGetPrototypeOf) {
var visited = [];
var thisProto = _getObjProto(thisTarget);
while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
if (thisProto === classProto) {
return true;
}
visited.push(thisProto);
thisProto = _getObjProto(thisProto);
}
return false;
}
return true;
}
function _getObjName(target, unknownValue) {
if (/* @__PURE__ */ objHasOwnProperty(target, Prototype)) {
return target.name || unknownValue || UnknownValue;
}
return ((target || {})[Constructor] || {}).name || unknownValue || UnknownValue;
}
function dynamicProto(theClass, target, delegateFunc, options) {
if (!/* @__PURE__ */ objHasOwnProperty(theClass, Prototype)) {
_throwTypeError("theClass is an invalid class definition.");
}
var classProto = theClass[Prototype];
if (!_checkPrototype(classProto, target)) {
_throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
}
var className = null;
if (/* @__PURE__ */ objHasOwnProperty(classProto, DynClassName)) {
className = classProto[DynClassName];
} else {
className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
_gblInst.n++;
classProto[DynClassName] = className;
}
var perfOptions = dynamicProto[DynProtoDefaultOptions];
var useBaseInst = !!perfOptions[strUseBaseInst];
if (useBaseInst && options && options[strUseBaseInst] !== void 0) {
useBaseInst = !!options[strUseBaseInst];
}
var instFuncs = _getInstanceFuncs(target);
var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
delegateFunc(target, baseFuncs);
var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
if (setInstanceFunc && options) {
setInstanceFunc = !!options[strSetInstFuncs];
}
_populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
}
dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
var UNDEFINED_VALUE = void 0;
var STR_EMPTY = "";
var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
var STR_REDACTED = "REDACTED";
var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
var rCamelCase = /-([a-z])/g;
var rNormalizeInvalid = /([^\w\d_$])/g;
var rLeadingNumeric = /^(\d+[\w\d_$])/;
function isNotNullOrUndefined(value) {
return !/* @__PURE__ */ isNullOrUndefined(value);
}
function normalizeJsName(name) {
var value = name;
if (value && isString(value)) {
value = value[_DYN_REPLACE](rCamelCase, function(_all, letter) {
return letter.toUpperCase();
});
value = value[_DYN_REPLACE](rNormalizeInvalid, "_");
value = value[_DYN_REPLACE](rLeadingNumeric, function(_all, match) {
return "_" + match;
});
}
return value;
}
function strContains(value, search) {
if (value && search) {
return strIndexOf(value, search) !== -1;
}
return false;
}
function toISOString(date) {
return date && date.toISOString() || "";
}
function getExceptionName(object) {
if (isError(object)) {
return object[_DYN_NAME$1];
}
return STR_EMPTY;
}
function createClassFromInterface(defaults) {
return (
/** @class */
/* @__PURE__ */ (function() {
function class_1() {
var _this = this;
if (defaults) {
objForEachKey(defaults, function(field, value) {
_this[field] = value;
});
}
}
return class_1;
})()
);
}
var strConsole = "console";
var strJSON = "JSON";
var strCrypto = "crypto";
var strMsCrypto = "msCrypto";
var strMsie = "msie";
var strTrident = "trident/";
var _isTrident = null;
var _navUserAgentCheck = null;
var _beaconsSupported = null;
function getConsole() {
if (typeof console !== strShimUndefined) {
return console;
}
return /* @__PURE__ */ getInst(strConsole);
}
function hasJSON() {
return Boolean(typeof JSON === strShimObject && JSON || /* @__PURE__ */ getInst(strJSON) !== null);
}
function getJSON() {
if (hasJSON()) {
return JSON || /* @__PURE__ */ getInst(strJSON);
}
return null;
}
function getCrypto() {
return /* @__PURE__ */ getInst(strCrypto);
}
function getMsCrypto() {
return /* @__PURE__ */ getInst(strMsCrypto);
}
function isIE() {
var nav = getNavigator();
if (nav && (nav[_DYN_USER_AGENT] !== _navUserAgentCheck || _isTrident === null)) {
_navUserAgentCheck = nav[_DYN_USER_AGENT];
var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1]();
_isTrident = strContains(userAgent, strMsie) || strContains(userAgent, strTrident);
}
return _isTrident;
}
function isBeaconsSupported(useCached) {
if (_beaconsSupported === null || useCached === false) {
_beaconsSupported = /* @__PURE__ */ hasNavigator() && Boolean(getNavigator().sendBeacon);
}
return _beaconsSupported;
}
function _getNamedValue(values, name) {
if (values) {
for (var i = 0; i < values[_DYN_LENGTH$1]; i++) {
var value = values[i];
if (value[_DYN_NAME$1]) {
if (value[_DYN_NAME$1] === name) {
return value;
}
}
}
}
return {};
}
function findMetaTag(name) {
var doc = getDocument();
if (doc && name) {
return _getNamedValue(doc.querySelectorAll("meta"), name).content;
}
return null;
}
function findNamedServerTiming(name) {
var value;
var perf = /* @__PURE__ */ getPerformance();
if (perf) {
var navPerf = perf.getEntriesByType("navigation") || [];
value = _getNamedValue((navPerf[_DYN_LENGTH$1] > 0 ? navPerf[0] : {}).serverTiming, name).description;
}
return value;
}
function redactUserInfo(url) {
return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
}
function redactQueryParameters(url, config) {
var sensitiveParams;
var questionMarkIndex = strIndexOf(url, "?");
if (questionMarkIndex === -1) {
return url;
}
if (config && config.redactQueryParams) {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
} else {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
}
var baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
var queryString = strSubstring(url, questionMarkIndex + 1);
var fragment = STR_EMPTY;
var hashIndex = strIndexOf(queryString, "#");
if (hashIndex !== -1) {
fragment = strSubstring(queryString, hashIndex);
queryString = strSubstring(queryString, 0, hashIndex);
}
var hasPotentialSensitiveParam = false;
for (var i = 0; i < sensitiveParams[_DYN_LENGTH$1]; i++) {
var paramCheck = sensitiveParams[i] + "=";
if (strIndexOf(queryString, paramCheck) !== -1) {
hasPotentialSensitiveParam = true;
break;
}
}
if (!hasPotentialSensitiveParam) {
return url;
}
var resultParts = [];
var anyParamRedacted = false;
if (queryString && queryString[_DYN_LENGTH$1]) {
var pairs = queryString[_DYN_SPLIT$1]("&");
for (var i = 0; i < pairs[_DYN_LENGTH$1]; i++) {
var pair = pairs[i];
if (!pair) {
continue;
}
var equalsIndex = strIndexOf(pair, "=");
if (equalsIndex === -1) {
resultParts[_DYN_PUSH](pair);
} else {
var paramName = pair[_DYN_SUBSTRING](0, equalsIndex);
var paramValue = pair[_DYN_SUBSTRING](equalsIndex + 1);
if (paramValue === STR_EMPTY) {
resultParts[_DYN_PUSH](pair);
} else {
var shouldRedact = false;
for (var j = 0; j < sensitiveParams[_DYN_LENGTH$1]; j++) {
if (paramName === sensitiveParams[j]) {
shouldRedact = true;
anyParamRedacted = true;
break;
}
}
if (shouldRedact) {
resultParts[_DYN_PUSH](paramName + "=" + STR_REDACTED);
} else {
resultParts[_DYN_PUSH](pair);
}
}
}
}
}
if (!anyParamRedacted) {
return url;
}
return baseUrl + resultParts.join("&") + fragment;
}
function fieldRedaction(input, config) {
if (!input || input[_DYN_INDEX_OF](" ") !== -1) {
return input;
}
var isRedactionDisabled = config && config.redactUrls === false;
if (isRedactionDisabled) {
return input;
}
var hasCredentials = strIndexOf(input, "@") !== -1;
var hasQueryParams = strIndexOf(input, "?") !== -1;
if (!hasCredentials && !hasQueryParams) {
return input;
}
try {
var result = input;
if (hasCredentials) {
result = redactUserInfo(input);
}
if (hasQueryParams) {
result = redactQueryParameters(result, config);
}
return result;
} catch (e) {
return input;
}
}
var UInt32Mask = 4294967296;
var MaxUInt32 = 4294967295;
var SEED1 = 123456789;
var SEED2 = 987654321;
var _mwcSeeded = false;
var _mwcW = SEED1;
var _mwcZ = SEED2;
function _mwcSeed(seedValue) {
if (seedValue < 0) {
seedValue >>>= 0;
}
_mwcW = SEED1 + seedValue & MaxUInt32;
_mwcZ = SEED2 - seedValue & MaxUInt32;
_mwcSeeded = true;
}
function _autoSeedMwc() {
try {
var now = /* @__PURE__ */ utcNow() & 2147483647;
_mwcSeed((Math.random() * UInt32Mask ^ now) + now);
} catch (e) {
}
}
function randomValue(maxValue) {
if (maxValue > 0) {
return mathFloor(random32() / MaxUInt32 * (maxValue + 1)) >>> 0;
}
return 0;
}
function random32(signed) {
var value = 0;
var c = getCrypto() || getMsCrypto();
if (c && c.getRandomValues) {
value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
}
if (value === 0 && isIE()) {
if (!_mwcSeeded) {
_autoSeedMwc();
}
value = mwcRandom32() & MaxUInt32;
}
if (value === 0) {
value = mathFloor(UInt32Mask * Math.random() | 0);
}
if (!signed) {
value >>>= 0;
}
return value;
}
function mwcRandom32(signed) {
_mwcZ = 36969 * (_mwcZ & 65535) + (_mwcZ >> 16) & MaxUInt32;
_mwcW = 18e3 * (_mwcW & 65535) + (_mwcW >> 16) & MaxUInt32;
var value = (_mwcZ << 16) + (_mwcW & 65535) >>> 0 & MaxUInt32 | 0;
if (!signed) {
value >>>= 0;
}
return value;
}
function newId(maxLength) {
if (maxLength === void 0) {
maxLength = 22;
}
var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var number = random32() >>> 0;
var chars = 0;
var result = STR_EMPTY;
while (result[_DYN_LENGTH$1] < maxLength) {
chars++;
result += base64chars.charAt(number & 63);
number >>>= 6;
if (chars === 5) {
number = (random32() << 2 & 4294967295 | number & 3) >>> 0;
chars = 0;
}
}
return result;
}
var version = "3.3.10";
var instanceName = "." + newId(6);
var _dataUid = 0;
function _canAcceptData(target) {
return target.nodeType === 1 || target.nodeType === 9 || !+target.nodeType;
}
function _getCache(data, target) {
var theCache = target[data.id];
if (!theCache) {
theCache = {};
try {
if (_canAcceptData(target)) {
objDefine(target, data.id, {
e: false,
v: theCache
});
}
} catch (e) {
}
}
return theCache;
}
function createUniqueNamespace(name, includeVersion) {
if (includeVersion === void 0) {
includeVersion = false;
}
return normalizeJsName(name + _dataUid++ + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
}
function createElmNodeData(name) {
var data = {
id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
accept: function(target) {
return _canAcceptData(target);
},
get: function(target, name2, defValue, addDefault) {
var theCache = target[data.id];
if (!theCache) {
if (addDefault) {
theCache = _getCache(data, target);
theCache[normalizeJsName(name2)] = defValue;
}
return defValue;
}
return theCache[normalizeJsName(name2)];
},
kill: function(target, name2) {
if (target && target[name2]) {
try {
delete target[name2];
} catch (e) {
}
}
}
};
return data;
}
function _isConfigDefaults(value) {
return value && /* @__PURE__ */ isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set);
}
function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
var defValue;
var isDefaultValid = cfgDefaults.dfVal || isDefined;
if (theConfig && cfgDefaults.fb) {
var fallbacks = cfgDefaults.fb;
if (!isArray(fallbacks)) {
fallbacks = [fallbacks];
}
for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1]; lp++) {
var fallback = fallbacks[lp];
var fbValue = theConfig[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
} else if (dynamicHandler) {
fbValue = dynamicHandler.cfg[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
}
dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
}
if (isDefaultValid(defValue)) {
break;
}
}
}
if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
defValue = cfgDefaults.v;
}
return defValue;
}
function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
var theValue = cfgDefaults;
if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
}
if (theValue) {
if (_isConfigDefaults(theValue)) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
}
var newValue_1;
if (isArray(theValue)) {
newValue_1 = [];
newValue_1[_DYN_LENGTH$1] = theValue[_DYN_LENGTH$1];
} else if (/* @__PURE__ */ isPlainObject(theValue)) {
newValue_1 = {};
}
if (newValue_1) {
objForEachKey(theValue, function(key, value) {
if (value && _isConfigDefaults(value)) {
value = _resolveDefaultValue(dynamicHandler, theConfig, value);
}
newValue_1[key] = value;
});
theValue = newValue_1;
}
}
return theValue;
}
function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
var isValid;
var setFn;
var defValue;
var cfgDefaults = defaultValue;
var mergeDf;
var reference;
var readOnly;
var blkDynamicValue;
if (_isConfigDefaults(cfgDefaults)) {
isValid = cfgDefaults.isVal;
setFn = cfgDefaults.set;
readOnly = cfgDefaults.rdOnly;
blkDynamicValue = cfgDefaults.blkVal;
mergeDf = cfgDefaults.mrg;
reference = cfgDefaults.ref;
if (!reference && /* @__PURE__ */ isUndefined(reference)) {
reference = !!mergeDf;
}
defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
} else {
defValue = defaultValue;
}
if (blkDynamicValue) {
dynamicHandler.blkVal(theConfig, name);
}
var theValue;
var usingDefault = true;
var cfgValue = theConfig[name];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
theValue = cfgValue;
usingDefault = false;
if (isValid && theValue !== defValue && !isValid(theValue)) {
theValue = defValue;
usingDefault = true;
}
if (setFn) {
theValue = setFn(theValue, defValue, theConfig);
usingDefault = theValue === defValue;
}
}
if (!usingDefault) {
if (/* @__PURE__ */ isPlainObject(theValue) || isArray(defValue)) {
if (mergeDf && defValue && (/* @__PURE__ */ isPlainObject(defValue) || isArray(defValue))) {
objForEachKey(defValue, function(dfName, dfValue) {
_applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
});
}
}
} else if (defValue) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
} else {
theValue = defValue;
}
dynamicHandler.set(theConfig, name, theValue);
if (reference) {
dynamicHandler.ref(theConfig, name);
}
if (readOnly) {
dynamicHandler.rdOnly(theConfig, name);
}
}
var CFG_HANDLER_LINK = /* @__PURE__ */ symbolFor("[[ai_dynCfg_1]]");
var BLOCK_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_blkDynCfg_1]]");
var FORCE_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_frcDynCfg_1]]");
function _cfgDeepCopy(source) {
if (source) {
var target_1;
if (isArray(source)) {
target_1 = [];
target_1[_DYN_LENGTH$1] = source[_DYN_LENGTH$1];
} else if (/* @__PURE__ */ isPlainObject(source)) {
target_1 = {};
}
if (target_1) {
objForEachKey(source, function(key, value) {
target_1[key] = _cfgDeepCopy(value);
});
return target_1;
}
}
return source;
}
function getDynamicConfigHandler(value) {
if (value) {
var handler = value[CFG_HANDLER_LINK] || value;
if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler;
}
}
return null;
}
function blockDynamicConversion(value) {
if (value && (/* @__PURE__ */ isPlainObject(value) || isArray(value))) {
try {
value[BLOCK_DYNAMIC] = true;
} catch (e) {
}
}
return value;
}
function _canMakeDynamic(getFunc, state, value) {
var result = false;
if (value && !getFunc[state.blkVal]) {
result = value[FORCE_DYNAMIC];
if (!result && !value[BLOCK_DYNAMIC]) {
result = /* @__PURE__ */ isPlainObject(value) || isArray(value);
}
}
return result;
}
function throwInvalidAccess(message) {
throwTypeError("InvalidAccess:" + message);
}
var arrayMethodsToPatch = [
"push",
"pop",
"shift",
"unshift",
"splice"
];
var _throwDynamicError = function(logger2, name, desc, e) {
logger2 && logger2[_DYN_THROW_INTERNAL](3, 108, "".concat(desc, " [").concat(name, "] failed - ") + /* @__PURE__ */ dumpObj(e));
};
function _patchArray(state, target, name) {
if (isArray(target)) {
arrForEach(arrayMethodsToPatch, function(method) {
var orgMethod = target[method];
target[method] = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var result = orgMethod[_DYN_APPLY](this, args);
_makeDynamicObject(state, target, name, "Patching");
return result;
};
});
}
}
function _getOwnPropGetter(target, name) {
var propDesc = objGetOwnPropertyDescriptor(target, name);
return propDesc && propDesc.get;
}
function _createDynamicProperty(state, theConfig, name, value) {
var detail = {
n: name,
h: [],
trk: function(handler) {
if (handler && handler.fn) {
if (arrIndexOf(detail.h, handler) === -1) {
detail.h[_DYN_PUSH](handler);
}
state.trk(handler, detail);
}
},
clr: function(handler) {
var idx = arrIndexOf(detail.h, handler);
if (idx !== -1) {
detail.h[_DYN_SPLICE](idx, 1);
}
}
};
var checkDynamic = true;
var isObjectOrArray = false;
function _getProperty() {
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
value = _makeDynamicObject(state, value, name, "Converting");
}
checkDynamic = false;
}
var activeHandler = state.act;
if (activeHandler) {
detail.trk(activeHandler);
}
return value;
}
_getProperty[state.prop] = {
chng: function() {
state.add(detail);
}
};
function _setProperty(newValue) {
if (value !== newValue) {
if (!!_getProperty[state.ro] && !state.upd) {
throwInvalidAccess("[" + name + "] is read-only:" + /* @__PURE__ */ dumpObj(theConfig));
}
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
checkDynamic = false;
}
var isReferenced = isObjectOrArray && _getProperty[state.rf];
if (isObjectOrArray) {
if (isReferenced) {
objForEachKey(value, function(key) {
value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
});
try {
objForEachKey(newValue, function(key, theValue) {
_setDynamicProperty(state, value, key, theValue);
});
newValue = value;
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Assigning", e);
isObjectOrArray = false;
}
} else if (value && value[CFG_HANDLER_LINK]) {
objForEachKey(value, function(key) {
var getter = _getOwnPropGetter(value, key);
if (getter) {
var valueState = getter[state.prop];
valueState && valueState.chng();
}
});
}
}
if (newValue !== value) {
var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
if (!isReferenced && newIsObjectOrArray) {
newValue = _makeDynamicObject(state, newValue, name, "Converting");
}
value = newValue;
isObjectOrArray = newIsObjectOrArray;
}
state.add(detail);
}
}
objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
}
function _setDynamicProperty(state, target, name, value) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
if (!isDynamic) {
_createDynamicProperty(state, target, name, value);
} else {
target[name] = value;
}
}
return target;
}
function _setDynamicPropertyState(state, target, name, flags) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
var inPlace = flags && flags[0];
var rdOnly = flags && flags[1];
var blkProp = flags && flags[2];
if (!isDynamic) {
if (blkProp) {
try {
blockDynamicConversion(target);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Blocking", e);
}
}
try {
_setDynamicProperty(state, target, name, target[name]);
getter = _getOwnPropGetter(target, name);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "State", e);
}
}
if (inPlace) {
getter[state.rf] = inPlace;
}
if (rdOnly) {
getter[state.ro] = rdOnly;
}
if (blkProp) {
getter[state.blkVal] = true;
}
}
return target;
}
function _makeDynamicObject(state, target, name, desc) {
try {
objForEachKey(target, function(key, value) {
_setDynamicProperty(state, target, key, value);
});
if (!target[CFG_HANDLER_LINK]) {
objDefineProp(target, CFG_HANDLER_LINK, {
get: function() {
return state.hdlr;
}
});
_patchArray(state, target, name);
}
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, desc, e);
}
return target;
}
var symPrefix = "[[ai_";
var symPostfix = "]]";
function _createState(cfgHandler) {
var dynamicPropertySymbol = /* @__PURE__ */ newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
var dynamicPropertyReadOnly = /* @__PURE__ */ newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
var dynamicPropertyReferenced = /* @__PURE__ */ newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
var dynamicPropertyBlockValue = /* @__PURE__ */ newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
var dynamicPropertyDetail = /* @__PURE__ */ newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
var _waitingHandlers = null;
var _watcherTimer = null;
var theState;
function _useHandler(activeHandler, callback) {
var prevWatcher = theState.act;
try {
theState.act = activeHandler;
if (activeHandler && activeHandler[dynamicPropertyDetail]) {
arrForEach(activeHandler[dynamicPropertyDetail], function(detail) {
detail.clr(activeHandler);
});
activeHandler[dynamicPropertyDetail] = [];
}
callback({
cfg: cfgHandler.cfg,
set: cfgHandler.set.bind(cfgHandler),
setDf: cfgHandler.setDf.bind(cfgHandler),
ref: cfgHandler.ref.bind(cfgHandler),
rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
});
} catch (e) {
var logger2 = cfgHandler[_DYN_LOGGER];
if (logger2) {
logger2[_DYN_THROW_INTERNAL](1, 107, /* @__PURE__ */ dumpObj(e));
}
throw e;
} finally {
theState.act = prevWatcher || null;
}
}
function _notifyWatchers() {
if (_waitingHandlers) {
var notifyHandlers = _waitingHandlers;
_waitingHandlers = null;
_watcherTimer && _watcherTimer[_DYN_CANCEL]();
_watcherTimer = null;
var watcherFailures_1 = [];
arrForEach(notifyHandlers, function(handler) {
if (handler) {
if (handler[dynamicPropertyDetail]) {
arrForEach(handler[dynamicPropertyDetail], function(detail) {
detail.clr(handler);
});
handler[dynamicPropertyDetail] = null;
}
if (handler.fn) {
try {
_useHandler(handler, handler.fn);
} catch (e) {
watcherFailures_1[_DYN_PUSH](e);
}
}
}
});
if (_waitingHandlers) {
try {
_notifyWatchers();
} catch (e) {
watcherFailures_1[_DYN_PUSH](e);
}
}
if (watcherFailures_1[_DYN_LENGTH$1] > 0) {
throwAggregationError("Watcher error(s): ", watcherFailures_1);
}
}
}
function _addWatcher(detail) {
if (detail && detail.h[_DYN_LENGTH$1] > 0) {
if (!_waitingHandlers) {
_waitingHandlers = [];
}
if (!_watcherTimer) {
_watcherTimer = scheduleTimeout(function() {
_watcherTimer = null;
_notifyWatchers();
}, 0);
}
for (var idx = 0; idx < detail.h[_DYN_LENGTH$1]; idx++) {
var handler = detail.h[idx];
if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
_waitingHandlers[_DYN_PUSH](handler);
}
}
}
}
function _trackHandler(handler, detail) {
if (handler) {
var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
if (arrIndexOf(details, detail) === -1) {
details[_DYN_PUSH](detail);
}
}
}
theState = {
prop: dynamicPropertySymbol,
ro: dynamicPropertyReadOnly,
rf: dynamicPropertyReferenced,
blkVal: dynamicPropertyBlockValue,
hdlr: cfgHandler,
add: _addWatcher,
notify: _notifyWatchers,
use: _useHandler,
trk: _trackHandler
};
return theState;
}
function _createAndUseHandler(state, configHandler) {
var handler = {
fn: configHandler,
rm: function() {
handler.fn = null;
state = null;
configHandler = null;
}
};
objDefine(handler, "toJSON", { v: function() {
return "WatcherHandler" + (handler.fn ? "" : "[X]");
} });
state.use(handler, configHandler);
return handler;
}
function _createDynamicHandler(logger2, target, inPlace) {
var dynamicHandler = getDynamicConfigHandler(target);
if (dynamicHandler) {
return dynamicHandler;
}
var uid = createUniqueNamespace("dyncfg", true);
var newTarget = target && inPlace !== false ? target : _cfgDeepCopy(target);
var theState;
function _notifyWatchers() {
theState.notify();
}
function _setValue(target2, name, value) {
try {
target2 = _setDynamicProperty(theState, target2, name, value);
} catch (e) {
_throwDynamicError(logger2, name, "Setting value", e);
}
return target2[name];
}
function _watch(configHandler) {
return _createAndUseHandler(theState, configHandler);
}
function _block(configHandler, allowUpdate) {
theState.use(null, function(details) {
var prevUpd = theState.upd;
try {
if (!/* @__PURE__ */ isUndefined(allowUpdate)) {
theState.upd = allowUpdate;
}
configHandler(details);
} finally {
theState.upd = prevUpd;
}
});
}
function _ref(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[0] = true, _a2))[name];
}
function _rdOnly(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[1] = true, _a2))[name];
}
function _blkPropValue(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[2] = true, _a2))[name];
}
function _applyDefaults(theConfig, defaultValues2) {
if (defaultValues2) {
objForEachKey(defaultValues2, function(name, value) {
_applyDefaultValue(cfgHandler, theConfig, name, value);
});
}
return theConfig;
}
var cfgHandler = {
uid: null,
cfg: newTarget,
logger: logger2,
notify: _notifyWatchers,
set: _setValue,
setDf: _applyDefaults,
watch: _watch,
ref: _ref,
rdOnly: _rdOnly,
blkVal: _blkPropValue,
_block
};
objDefine(cfgHandler, "uid", {
c: false,
e: false,
w: false,
v: uid
});
theState = _createState(cfgHandler);
_makeDynamicObject(theState, newTarget, "config", "Creating");
return cfgHandler;
}
function _logInvalidAccess(logger2, message) {
if (logger2) {
logger2[_DYN_WARN_TO_CONSOLE](message);
logger2[_DYN_THROW_INTERNAL](2, 108, message);
} else {
throwInvalidAccess(message);
}
}
function createDynamicConfig(config, defaultConfig, logger2, inPlace) {
var dynamicHandler = _createDynamicHandler(logger2, config || {}, inPlace);
if (defaultConfig) {
dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
}
return dynamicHandler;
}
function onConfigChange(config, configHandler, logger2) {
var handler = config[CFG_HANDLER_LINK] || config;
if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler[_DYN_WATCH](configHandler);
}
_logInvalidAccess(logger2, STR_NOT_DYNAMIC_ERROR + /* @__PURE__ */ dumpObj(config));
return createDynamicConfig(config, null, logger2)[_DYN_WATCH](configHandler);
}
var _aiNamespace = null;
function _getExtensionNamespace() {
var target = /* @__PURE__ */ getInst("Microsoft");
if (target) {
_aiNamespace = target["ApplicationInsights"];
}
return _aiNamespace;
}
function getDebugExt(config) {
var ns = _aiNamespace;
if (!ns && config.disableDbgExt !== true) {
ns = _aiNamespace || _getExtensionNamespace();
}
return ns ? ns["ChromeDbgExt"] : null;
}
var _a;
var STR_WARN_TO_CONSOLE = "warnToConsole";
var AiNonUserActionablePrefix = "AI (Internal): ";
var AiUserActionablePrefix = "AI: ";
var AIInternalMessagePrefix = "AITR_";
var defaultValues = {
loggingLevelConsole: 0,
loggingLevelTelemetry: 1,
maxMessageLimit: 25,
enableDebug: false
};
var _logFuncs = (_a = {}, _a[0] = null, _a[1] = "errorToConsole", _a[2] = STR_WARN_TO_CONSOLE, _a[3] = "debugToConsole", _a);
function _sanitizeDiagnosticText(text) {
if (text) {
return '"' + text[_DYN_REPLACE](/\"/g, STR_EMPTY) + '"';
}
return STR_EMPTY;
}
function _logToConsole(func, message) {
var theConsole = getConsole();
if (!!theConsole) {
var logFunc = "log";
if (theConsole[func]) {
logFunc = func;
}
if (isFunction(theConsole[logFunc])) {
theConsole[logFunc](message);
}
}
}
var _InternalLogMessage = (
/** @class */
(function() {
function _InternalLogMessage2(msgId, msg, isUserAct, properties) {
if (isUserAct === void 0) {
isUserAct = false;
}
var _self = this;
_self[_DYN_MESSAGE_ID] = msgId;
_self[_DYN_MESSAGE$1] = (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) + msgId;
var strProps = STR_EMPTY;
if (hasJSON()) {
strProps = getJSON().stringify(properties);
}
var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) + (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
_self[_DYN_MESSAGE$1] += diagnosticText;
}
_InternalLogMessage2.dataType = "MessageData";
return _InternalLogMessage2;
})()
);
function safeGetLogger(core, config) {
return (core || {})[_DYN_LOGGER] || new DiagnosticLogger(config);
}
var DiagnosticLogger = (
/** @class */
(function() {
function DiagnosticLogger2(config) {
this.identifier = "DiagnosticLogger";
this.queue = [];
var _messageCount = 0;
var _messageLogged = {};
var _loggingLevelConsole;
var _loggingLevelTelemetry;
var _maxInternalMessageLimit;
var _enableDebug;
var _unloadHandler;
dynamicProto(DiagnosticLogger2, this, function(_self) {
_unloadHandler = _setDefaultsFromConfig(config || {});
_self.consoleLoggingLevel = function() {
return _loggingLevelConsole;
};
_self[_DYN_THROW_INTERNAL] = function(severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
if (_enableDebug) {
throw /* @__PURE__ */ dumpObj(message);
} else {
var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
if (!/* @__PURE__ */ isUndefined(message[_DYN_MESSAGE$1])) {
if (isUserAct) {
var messageKey = +message[_DYN_MESSAGE_ID];
if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE$1]);
_messageLogged[messageKey] = true;
}
} else {
if (_loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE$1]);
}
}
_logInternalMessage(severity, message);
} else {
_debugExtMsg("throw" + (severity === 1 ? "Critical" : "Warning"), message);
}
}
};
_self.debugToConsole = function(message) {
_logToConsole("debug", message);
_debugExtMsg("warning", message);
};
_self[_DYN_WARN_TO_CONSOLE] = function(message) {
_logToConsole("warn", message);
_debugExtMsg("warning", message);
};
_self.errorToConsole = function(message) {
_logToConsole("error", message);
_debugExtMsg("error", message);
};
_self.resetInternalMessageCount = function() {
_messageCount = 0;
_messageLogged = {};
};
_self.logInternalMessage = _logInternalMessage;
_self[_DYN_UNLOAD] = function(isAsync) {
_unloadHandler && _unloadHandler.rm();
_unloadHandler = null;
};
function _logInternalMessage(severity, message) {
if (_areInternalMessagesThrottled()) {
return;
}
var logMessage = true;
var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID];
if (_messageLogged[messageKey]) {
logMessage = false;
} else {
_messageLogged[messageKey] = true;
}
if (logMessage) {
if (severity <= _loggingLevelTelemetry) {
_self.queue[_DYN_PUSH](message);
_messageCount++;
_debugExtMsg(severity === 1 ? "error" : "warn", message);
}
if (_messageCount === _maxInternalMessageLimit) {
var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
var throttleMessage = new _InternalLogMessage(23, throttleLimitMessage, false);
_self.queue[_DYN_PUSH](throttleMessage);
if (severity === 1) {
_self.errorToConsole(throttleLimitMessage);
} else {
_self[_DYN_WARN_TO_CONSOLE](throttleLimitMessage);
}
}
}
}
function _setDefaultsFromConfig(config2) {
return onConfigChange(createDynamicConfig(config2, defaultValues, _self).cfg, function(details) {
var config3 = details.cfg;
_loggingLevelConsole = config3[_DYN_LOGGING_LEVEL_CONSOL4];
_loggingLevelTelemetry = config3.loggingLevelTelemetry;
_maxInternalMessageLimit = config3.maxMessageLimit;
_enableDebug = config3.enableDebug;
});
}
function _areInternalMessagesThrottled() {
return _messageCount >= _maxInternalMessageLimit;
}
function _debugExtMsg(name, data) {
var dbgExt = getDebugExt(config || {});
if (dbgExt && dbgExt[_DYN_DIAG_LOG]) {
dbgExt[_DYN_DIAG_LOG](name, data);
}
}
});
}
DiagnosticLogger2.__ieDyn = 1;
return DiagnosticLogger2;
})()
);
function _getLogger(logger2) {
return logger2 || new DiagnosticLogger();
}
function _throwInternal(logger2, severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
_getLogger(logger2)[_DYN_THROW_INTERNAL](severity, msgId, msg, properties, isUserAct);
}
function generateW3CId() {
var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
var oct = STR_EMPTY, tmp;
for (var a = 0; a < 4; a++) {
tmp = random32();
oct += hexValues[tmp & 15] + hexValues[tmp >> 4 & 15] + hexValues[tmp >> 8 & 15] + hexValues[tmp >> 12 & 15] + hexValues[tmp >> 16 & 15] + hexValues[tmp >> 20 & 15] + hexValues[tmp >> 24 & 15] + hexValues[tmp >> 28 & 15];
}
var clockSequenceHi = hexValues[8 + (random32() & 3) | 0];
return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
}
var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
var DEFAULT_VERSION = "00";
var INVALID_VERSION = "ff";
var INVALID_TRACE_ID = "00000000000000000000000000000000";
var INVALID_SPAN_ID = "0000000000000000";
var SAMPLED_FLAG = 1;
function _isValid(value, len, invalidValue) {
if (value && value[_DYN_LENGTH$1] === len && value !== invalidValue) {
return !!value.match(/^[\da-f]*$/i);
}
return false;
}
function _formatValue(value, len, defValue) {
if (_isValid(value, len)) {
return value;
}
return defValue;
}
function _formatFlags(value) {
if (isNaN(value) || value < 0 || value > 255) {
value = 1;
}
var result = value.toString(16);
while (result[_DYN_LENGTH$1] < 2) {
result = "0" + result;
}
return result;
}
function createTraceParent(traceId, spanId, flags, version2) {
return {
version: _isValid(version2, 2, INVALID_VERSION) ? version2 : DEFAULT_VERSION,
traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
spanId: isValidSpanId(spanId) ? spanId : /* @__PURE__ */ strLeft(generateW3CId(), 16),
traceFlags: flags >= 0 && flags <= 255 ? flags : 1
};
}
function parseTraceParent(value, selectIdx) {
if (!value) {
return null;
}
if (isArray(value)) {
value = value[0] || "";
}
if (!value || !isString(value) || value[_DYN_LENGTH$1] > 8192) {
return null;
}
if (value[_DYN_INDEX_OF](",") !== -1) {
var values = value[_DYN_SPLIT$1](",");
value = values[selectIdx > 0 && values[_DYN_LENGTH$1] > selectIdx ? selectIdx : 0];
}
var match = TRACE_PARENT_REGEX.exec(strTrim(value));
if (!match || match[1] === INVALID_VERSION || match[2] === INVALID_TRACE_ID || match[3] === INVALID_SPAN_ID) {
return null;
}
return {
version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1](),
traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1](),
spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1](),
traceFlags: parseInt(match[4], 16)
};
}
function isValidTraceId(value) {
return _isValid(value, 32, INVALID_TRACE_ID);
}
function isValidSpanId(value) {
return _isValid(value, 16, INVALID_SPAN_ID);
}
function isValidTraceParent(value) {
if (!value || !_isValid(value[_DYN_VERSION], 2, INVALID_VERSION) || !_isValid(value.traceId, 32, INVALID_TRACE_ID) || !_isValid(value.spanId, 16, INVALID_SPAN_ID) || !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS]), 2)) {
return false;
}
return true;
}
function isSampledFlag(value) {
if (isValidTraceParent(value)) {
return (value[_DYN_TRACE_FLAGS] & SAMPLED_FLAG) === SAMPLED_FLAG;
}
return false;
}
function formatTraceParent(value) {
if (value) {
var flags = _formatFlags(value[_DYN_TRACE_FLAGS]);
if (!_isValid(flags, 2)) {
flags = "01";
}
var version2 = value[_DYN_VERSION] || DEFAULT_VERSION;
if (version2 !== "00" && version2 !== "ff") {
version2 = DEFAULT_VERSION;
}
return "".concat(version2.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
}
return "";
}
function findW3cTraceParent(selectIdx) {
var name = "traceparent";
var traceParent = parseTraceParent(findMetaTag(name), selectIdx);
if (!traceParent) {
traceParent = parseTraceParent(findNamedServerTiming(name), selectIdx);
}
return traceParent;
}
function findAllScripts(doc) {
var scripts = doc.getElementsByTagName("script");
var result = [];
arrForEach(scripts, function(script) {
var src = script[_DYN_GET_ATTRIBUTE]("src");
if (src) {
var crossOrigin = script[_DYN_GET_ATTRIBUTE]("crossorigin");
var async = script.hasAttribute("async") === true;
var defer = script.hasAttribute("defer") === true;
var referrerPolicy = script[_DYN_GET_ATTRIBUTE]("referrerpolicy");
var info = { url: src };
if (crossOrigin) {
info.crossOrigin = crossOrigin;
}
if (async) {
info.async = async;
}
if (defer) {
info.defer = defer;
}
if (referrerPolicy) {
info.referrerPolicy = referrerPolicy;
}
result[_DYN_PUSH](info);
}
});
return result;
}
var strOnPrefix = "on";
var strAttachEvent = "attachEvent";
var strAddEventHelper = "addEventListener";
var strDetachEvent = "detachEvent";
var strRemoveEventListener = "removeEventListener";
var strEvents = "events";
createUniqueNamespace("aiEvtPageHide");
createUniqueNamespace("aiEvtPageShow");
var rRemoveEmptyNs = /\.[\.]+/g;
var rRemoveTrailingEmptyNs = /[\.]+$/;
var _guid = 1;
var elmNodeData = createElmNodeData("events");
var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
function _normalizeNamespace(name) {
if (name && name[_DYN_REPLACE]) {
return name[_DYN_REPLACE](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
}
return name;
}
function _getEvtNamespace(eventName, evtNamespace) {
if (evtNamespace) {
var theNamespace_1 = STR_EMPTY;
if (isArray(evtNamespace)) {
theNamespace_1 = STR_EMPTY;
arrForEach(evtNamespace, function(name) {
name = _normalizeNamespace(name);
if (name) {
if (name[0] !== ".") {
name = "." + name;
}
theNamespace_1 += name;
}
});
} else {
theNamespace_1 = _normalizeNamespace(evtNamespace);
}
if (theNamespace_1) {
if (theNamespace_1[0] !== ".") {
theNamespace_1 = "." + theNamespace_1;
}
eventName = (eventName || STR_EMPTY) + theNamespace_1;
}
}
var parsedEvent = eventNamespace.exec(eventName || STR_EMPTY) || [];
return {
type: parsedEvent[1],
ns: (parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1](".").sort().join(".")
};
}
function _getRegisteredEvents(target, evtName, addDefault) {
if (addDefault === void 0) {
addDefault = true;
}
var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
var registeredEvents = aiEvts[evtName];
if (!registeredEvents) {
registeredEvents = aiEvts[evtName] = [];
}
return registeredEvents;
}
function _doDetach(obj, evtName, handlerRef, useCapture) {
if (obj && evtName && evtName[_DYN_TYPE]) {
if (obj[strRemoveEventListener]) {
obj[strRemoveEventListener](evtName[_DYN_TYPE], handlerRef, useCapture);
} else if (obj[strDetachEvent]) {
obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
}
}
}
function _doAttach(obj, evtName, handlerRef, useCapture) {
var result = false;
if (obj && evtName && evtName[_DYN_TYPE] && handlerRef) {
if (obj[strAddEventHelper]) {
obj[strAddEventHelper](evtName[_DYN_TYPE], handlerRef, useCapture);
result = true;
} else if (obj[strAttachEvent]) {
obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
result = true;
}
}
return result;
}
function _doUnregister(target, events, evtName, unRegFn) {
var idx = events[_DYN_LENGTH$1];
while (idx--) {
var theEvent = events[idx];
if (theEvent) {
if (!evtName.ns || evtName.ns === theEvent[_DYN_EVT_NAME].ns) {
if (!unRegFn || unRegFn(theEvent)) {
_doDetach(target, theEvent[_DYN_EVT_NAME], theEvent.handler, theEvent.capture);
events[_DYN_SPLICE](idx, 1);
}
}
}
}
}
function _unregisterEvents(target, evtName, unRegFn) {
if (evtName[_DYN_TYPE]) {
_doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE]), evtName, unRegFn);
} else {
var eventCache = elmNodeData.get(target, strEvents, {});
objForEachKey(eventCache, function(evtType, events) {
_doUnregister(target, events, evtName, unRegFn);
});
if (objKeys(eventCache)[_DYN_LENGTH$1] === 0) {
elmNodeData.kill(target, strEvents);
}
}
}
function mergeEvtNamespace(theNamespace, namespaces) {
var newNamespaces;
if (namespaces) {
if (isArray(namespaces)) {
newNamespaces = [theNamespace].concat(namespaces);
} else {
newNamespaces = [theNamespace, namespaces];
}
newNamespaces = _getEvtNamespace("xx", newNamespaces).ns[_DYN_SPLIT$1](".");
} else {
newNamespaces = theNamespace;
}
return newNamespaces;
}
function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
var result = false;
if (target) {
try {
var evtName = _getEvtNamespace(eventName, evtNamespace);
result = _doAttach(target, evtName, handlerRef, useCapture);
if (result && elmNodeData.accept(target)) {
var registeredEvent = {
guid: _guid++,
evtName,
handler: handlerRef,
capture: useCapture
};
_getRegisteredEvents(target, evtName.type)[_DYN_PUSH](registeredEvent);
}
} catch (e) {
}
}
return result;
}
function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
if (target) {
try {
var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
var found_1 = false;
_unregisterEvents(target, evtName_1, function(regEvent) {
if (evtName_1.ns && !handlerRef || regEvent.handler === handlerRef) {
found_1 = true;
return true;
}
return false;
});
if (!found_1) {
_doDetach(target, evtName_1, handlerRef, useCapture);
}
} catch (e) {
}
}
}
var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var SampleRate = "sampleRate";
var ProcessLegacy = "ProcessLegacy";
var HttpMethod = "http.method";
var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
var DEFAULT_BREEZE_PATH = "/v2/track";
var strNotSpecified = "not_specified";
var strIkey = "iKey";
var RequestHeaders = /* @__PURE__ */ createValueMap({
requestContextHeader: [0, "Request-Context"],
requestContextTargetKey: [1, "appId"],
requestContextAppIdFormat: [2, "appId=cid-v1:"],
requestIdHeader: [3, "Request-Id"],
traceParentHeader: [4, "traceparent"],
traceStateHeader: [5, "tracestate"],
sdkContextHeader: [6, "Sdk-Context"],
sdkContextHeaderAppIdRequest: [7, "appId"],
requestContextHeaderLowerCase: [8, "request-context"]
});
var _DYN_SPLIT = "split";
var _DYN_LENGTH = "length";
var _DYN_TO_LOWER_CASE = "toLowerCase";
var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
var _DYN_TO_STRING = "toString";
var _DYN_REMOVE_ITEM = "removeItem";
var _DYN_MESSAGE = "message";
var _DYN_COUNT = "count";
var _DYN_PRE_TRIGGER_DATE = "preTriggerDate";
var _DYN_GET_UTCDATE = "getUTCDate";
var _DYN_STRINGIFY = "stringify";
var _DYN_PATHNAME = "pathname";
var _DYN_MATCH = "match";
var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
var _DYN_NAME = "name";
var _DYN_EXTENSION_CONFIG = "extensionConfig";
var _DYN_PROPERTIES = "properties";
var _DYN_MEASUREMENTS = "measurements";
var _DYN_SIZE_IN_BYTES = "sizeInBytes";
var _DYN_TYPE_NAME = "typeName";
var _DYN_EXCEPTIONS = "exceptions";
var _DYN_SEVERITY_LEVEL = "severityLevel";
var _DYN_PROBLEM_GROUP = "problemGroup";
var _DYN_PARSED_STACK = "parsedStack";
var _DYN_HAS_FULL_STACK = "hasFullStack";
var _DYN_ASSEMBLY = "assembly";
var _DYN_FILE_NAME = "fileName";
var _DYN_LINE = "line";
var _DYN_AI_DATA_CONTRACT = "aiDataContract";
var _DYN_DURATION = "duration";
function dataSanitizeKeyAndAddUniqueness(logger2, key, map) {
var origLength = key[_DYN_LENGTH];
var field = dataSanitizeKey(logger2, key);
if (field[_DYN_LENGTH] !== origLength) {
var i = 0;
var uniqueField = field;
while (map[uniqueField] !== void 0) {
i++;
uniqueField = strSubstring(field, 0, 150 - 3) + dsPadNumber(i);
}
field = uniqueField;
}
return field;
}
function dataSanitizeKey(logger2, name) {
var nameTrunc;
if (name) {
name = strTrim(asString(name));
if (name[_DYN_LENGTH] > 150) {
nameTrunc = strSubstring(name, 0, 150);
_throwInternal(logger2, 2, 57, "name is too long. It has been truncated to 150 characters.", { name }, true);
}
}
return nameTrunc || name;
}
function dataSanitizeString(logger2, value, maxLength) {
if (maxLength === void 0) {
maxLength = 1024;
}
var valueTrunc;
if (value) {
maxLength = maxLength ? maxLength : 1024;
value = strTrim(asString(value));
if (value[_DYN_LENGTH] > maxLength) {
valueTrunc = strSubstring(value, 0, maxLength);
_throwInternal(logger2, 2, 61, "string value is too long. It has been truncated to " + maxLength + " characters.", { value }, true);
}
}
return valueTrunc || value;
}
function dataSanitizeUrl(logger2, url, config) {
if (isString(url)) {
url = fieldRedaction(url, config);
}
return dataSanitizeInput(logger2, url, 2048, 66);
}
function dataSanitizeMessage(logger2, message) {
var messageTrunc;
if (message) {
if (message[_DYN_LENGTH] > 32768) {
messageTrunc = strSubstring(message, 0, 32768);
_throwInternal(logger2, 2, 56, "message is too long, it has been truncated to 32768 characters.", { message }, true);
}
}
return messageTrunc || message;
}
function dataSanitizeException(logger2, exception) {
var exceptionTrunc;
if (exception) {
var value = "" + exception;
if (value[_DYN_LENGTH] > 32768) {
exceptionTrunc = strSubstring(value, 0, 32768);
_throwInternal(logger2, 2, 52, "exception is too long, it has been truncated to 32768 characters.", { exception }, true);
}
}
return exceptionTrunc || exception;
}
function dataSanitizeProperties(logger2, properties) {
if (properties) {
var tempProps_1 = {};
objForEachKey(properties, function(prop, value) {
if (/* @__PURE__ */ isObject(value) && hasJSON()) {
try {
value = getJSON()[_DYN_STRINGIFY](value);
} catch (e) {
_throwInternal(logger2, 2, 49, "custom property is not valid", { exception: e }, true);
}
}
value = dataSanitizeString(logger2, value, 8192);
prop = dataSanitizeKeyAndAddUniqueness(logger2, prop, tempProps_1);
tempProps_1[prop] = value;
});
properties = tempProps_1;
}
return properties;
}
function dataSanitizeMeasurements(logger2, measurements) {
if (measurements) {
var tempMeasurements_1 = {};
objForEachKey(measurements, function(measure, value) {
measure = dataSanitizeKeyAndAddUniqueness(logger2, measure, tempMeasurements_1);
tempMeasurements_1[measure] = value;
});
measurements = tempMeasurements_1;
}
return measurements;
}
function dataSanitizeId(logger2, id) {
return id ? dataSanitizeInput(logger2, id, 128, 69)[_DYN_TO_STRING]() : id;
}
function dataSanitizeInput(logger2, input, maxLength, _msgId) {
var inputTrunc;
if (input) {
input = strTrim(asString(input));
if (input[_DYN_LENGTH] > maxLength) {
inputTrunc = strSubstring(input, 0, maxLength);
_throwInternal(logger2, 2, _msgId, "input is too long, it has been truncated to " + maxLength + " characters.", { data: input }, true);
}
}
return inputTrunc || input;
}
function dsPadNumber(num) {
var s = "00" + num;
return strSubstr(s, s[_DYN_LENGTH] - 3);
}
var _document = getDocument() || {};
var _htmlAnchorIdx = 0;
var _htmlAnchorElement = [null, null, null, null, null];
function urlParseUrl(url) {
var anchorIdx = _htmlAnchorIdx;
var anchorCache = _htmlAnchorElement;
var tempAnchor = anchorCache[anchorIdx];
if (!_document.createElement) {
tempAnchor = { host: urlParseHost(url, true) };
} else if (!anchorCache[anchorIdx]) {
tempAnchor = anchorCache[anchorIdx] = _document.createElement("a");
}
tempAnchor.href = url;
anchorIdx++;
if (anchorIdx >= anchorCache[_DYN_LENGTH]) {
anchorIdx = 0;
}
_htmlAnchorIdx = anchorIdx;
return tempAnchor;
}
function urlGetAbsoluteUrl(url) {
var result;
var a = urlParseUrl(url);
if (a) {
result = a.href;
}
return result;
}
function urlGetPathName(url) {
var result;
var a = urlParseUrl(url);
if (a) {
result = a[_DYN_PATHNAME];
}
return result;
}
function urlGetCompleteUrl(method, absoluteUrl) {
if (method) {
return method.toUpperCase() + " " + absoluteUrl;
}
return absoluteUrl;
}
function urlParseHost(url, inclPort) {
var fullHost = urlParseFullHost(url, inclPort) || "";
if (fullHost) {
var match = fullHost[_DYN_MATCH](/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
if (match != null && match[_DYN_LENGTH] > 3 && isString(match[2]) && match[2][_DYN_LENGTH] > 0) {
return match[2] + (match[3] || "");
}
}
return fullHost;
}
function urlParseFullHost(url, inclPort) {
var result = null;
if (url) {
var match = url[_DYN_MATCH](/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
if (match != null && match[_DYN_LENGTH] > 2 && isString(match[2]) && match[2][_DYN_LENGTH] > 0) {
result = match[2] || "";
if (inclPort && match[_DYN_LENGTH] > 2) {
var protocol = (match[1] || "")[_DYN_TO_LOWER_CASE]();
var port = match[3] || "";
if (protocol === "http" && port === ":80") {
port = "";
} else if (protocol === "https" && port === ":443") {
port = "";
}
result += port;
}
}
}
return result;
}
var _internalEndpoints = [
DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH,
"https://breeze.aimon.applicationinsights.io" + DEFAULT_BREEZE_PATH,
"https://dc-int.services.visualstudio.com" + DEFAULT_BREEZE_PATH
];
var _correlationIdPrefix = "cid-v1:";
function isInternalApplicationInsightsEndpoint(endpointUrl) {
return arrIndexOf(_internalEndpoints, endpointUrl[_DYN_TO_LOWER_CASE]()) !== -1;
}
function correlationIdSetPrefix(prefix) {
_correlationIdPrefix = prefix;
}
function correlationIdGetPrefix() {
return _correlationIdPrefix;
}
function correlationIdCanIncludeCorrelationHeader(config, requestUrl, currentHost) {
if (!requestUrl || config && config.disableCorrelationHeaders) {
return false;
}
if (config && config[_DYN_CORRELATION_HEADER_E0]) {
for (var i = 0; i < config.correlationHeaderExcludePatterns[_DYN_LENGTH]; i++) {
if (config[_DYN_CORRELATION_HEADER_E0][i].test(requestUrl)) {
return false;
}
}
}
var requestHost = urlParseUrl(requestUrl).host[_DYN_TO_LOWER_CASE]();
if (requestHost && (strIndexOf(requestHost, ":443") !== -1 || strIndexOf(requestHost, ":80") !== -1)) {
requestHost = (urlParseFullHost(requestUrl, true) || "")[_DYN_TO_LOWER_CASE]();
}
if ((!config || !config.enableCorsCorrelation) && (requestHost && requestHost !== currentHost)) {
return false;
}
var includedDomains = config && config.correlationHeaderDomains;
if (includedDomains) {
var matchExists_1;
arrForEach(includedDomains, function(domain) {
var regex2 = new RegExp(domain.toLowerCase().replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*"));
matchExists_1 = matchExists_1 || regex2.test(requestHost);
});
if (!matchExists_1) {
return false;
}
}
var excludedDomains = config && config.correlationHeaderExcludedDomains;
if (!excludedDomains || excludedDomains[_DYN_LENGTH] === 0) {
return true;
}
for (var i = 0; i < excludedDomains[_DYN_LENGTH]; i++) {
var regex = new RegExp(excludedDomains[i].toLowerCase().replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*"));
if (regex.test(requestHost)) {
return false;
}
}
return requestHost && requestHost[_DYN_LENGTH] > 0;
}
function correlationIdGetCorrelationContext(responseHeader) {
if (responseHeader) {
var correlationId = correlationIdGetCorrelationContextValue(responseHeader, RequestHeaders[1]);
if (correlationId && correlationId !== _correlationIdPrefix) {
return correlationId;
}
}
}
function correlationIdGetCorrelationContextValue(responseHeader, key) {
if (responseHeader) {
var keyValues = responseHeader[_DYN_SPLIT](",");
for (var i = 0; i < keyValues[_DYN_LENGTH]; ++i) {
var keyValue = keyValues[i][_DYN_SPLIT]("=");
if (keyValue[_DYN_LENGTH] === 2 && keyValue[0] === key) {
return keyValue[1];
}
}
}
}
function AjaxHelperParseDependencyPath(logger2, absoluteUrl, method, commandName) {
var target, name = commandName, data = commandName;
if (absoluteUrl && absoluteUrl[_DYN_LENGTH] > 0) {
var parsedUrl = urlParseUrl(absoluteUrl);
target = parsedUrl.host;
if (!name) {
if (parsedUrl[_DYN_PATHNAME] != null) {
var pathName = parsedUrl.pathname[_DYN_LENGTH] === 0 ? "/" : parsedUrl[_DYN_PATHNAME];
if (pathName.charAt(0) !== "/") {
pathName = "/" + pathName;
}
data = parsedUrl[_DYN_PATHNAME];
name = dataSanitizeString(logger2, method ? method + " " + pathName : pathName);
} else {
name = dataSanitizeString(logger2, absoluteUrl);
}
}
} else {
target = commandName;
name = commandName;
}
return {
target,
name,
data
};
}
function dateTimeUtilsNow() {
var perf = /* @__PURE__ */ getPerformance();
if (perf && perf.now && perf.timing) {
var now = perf.now() + perf.timing.navigationStart;
if (now > 0) {
return now;
}
}
return /* @__PURE__ */ utcNow();
}
function dateTimeUtilsDuration(start, end) {
var result = null;
if (start !== 0 && end !== 0 && !/* @__PURE__ */ isNullOrUndefined(start) && !/* @__PURE__ */ isNullOrUndefined(end)) {
result = end - start;
}
return result;
}
function createDistributedTraceContextFromTrace(telemetryTrace, parentCtx) {
var trace = telemetryTrace || {};
return {
getName: function() {
return trace[_DYN_NAME];
},
setName: function(newValue) {
parentCtx && parentCtx.setName(newValue);
trace[_DYN_NAME] = newValue;
},
getTraceId: function() {
return trace.traceID;
},
setTraceId: function(newValue) {
parentCtx && parentCtx.setTraceId(newValue);
if (isValidTraceId(newValue)) {
trace.traceID = newValue;
}
},
getSpanId: function() {
return trace.parentID;
},
setSpanId: function(newValue) {
parentCtx && parentCtx.setSpanId(newValue);
if (isValidSpanId(newValue)) {
trace.parentID = newValue;
}
},
getTraceFlags: function() {
return trace.traceFlags;
},
setTraceFlags: function(newTraceFlags) {
parentCtx && parentCtx.setTraceFlags(newTraceFlags);
trace.traceFlags = newTraceFlags;
}
};
}
var StorageType = /* @__PURE__ */ createEnumStyle({
LocalStorage: 0,
SessionStorage: 1
});
var DistributedTracingModes = /* @__PURE__ */ createEnumStyle({
AI: 0,
AI_AND_W3C: 1,
W3C: 2
});
var EventPersistence = /* @__PURE__ */ createEnumStyle({
Normal: 1,
Critical: 2
});
var _canUseLocalStorage = void 0;
var _canUseSessionStorage = void 0;
var _storagePrefix = "";
function _getLocalStorageObject() {
if (utlCanUseLocalStorage()) {
return _getVerifiedStorageObject(StorageType.LocalStorage);
}
return null;
}
function _getVerifiedStorageObject(storageType) {
try {
if (/* @__PURE__ */ isNullOrUndefined(getGlobal())) {
return null;
}
var uid = (/* @__PURE__ */ new Date())[_DYN_TO_STRING]();
var storage = /* @__PURE__ */ getInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
var name_1 = _storagePrefix + uid;
storage.setItem(name_1, uid);
var fail = storage.getItem(name_1) !== uid;
storage[_DYN_REMOVE_ITEM](name_1);
if (!fail) {
return storage;
}
} catch (exception) {
}
return null;
}
function _getSessionStorageObject() {
if (utlCanUseSessionStorage()) {
return _getVerifiedStorageObject(StorageType.SessionStorage);
}
return null;
}
function utlDisableStorage() {
_canUseLocalStorage = false;
_canUseSessionStorage = false;
}
function utlSetStoragePrefix(storagePrefix) {
_storagePrefix = storagePrefix || "";
}
function utlEnableStorage() {
_canUseLocalStorage = utlCanUseLocalStorage(true);
_canUseSessionStorage = utlCanUseSessionStorage(true);
}
function utlCanUseLocalStorage(reset) {
if (reset || _canUseLocalStorage === void 0) {
_canUseLocalStorage = !!_getVerifiedStorageObject(StorageType.LocalStorage);
}
return _canUseLocalStorage;
}
function utlGetLocalStorage(logger2, name) {
var storage = _getLocalStorageObject();
if (storage !== null) {
try {
return storage.getItem(name);
} catch (e) {
_canUseLocalStorage = false;
_throwInternal(logger2, 2, 1, "Browser failed read of local storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return null;
}
function utlSetLocalStorage(logger2, name, data) {
var storage = _getLocalStorageObject();
if (storage !== null) {
try {
storage.setItem(name, data);
return true;
} catch (e) {
_canUseLocalStorage = false;
_throwInternal(logger2, 2, 3, "Browser failed write to local storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
function utlRemoveStorage(logger2, name) {
var storage = _getLocalStorageObject();
if (storage !== null) {
try {
storage[_DYN_REMOVE_ITEM](name);
return true;
} catch (e) {
_canUseLocalStorage = false;
_throwInternal(logger2, 2, 5, "Browser failed removal of local storage item. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
function utlCanUseSessionStorage(reset) {
if (reset || _canUseSessionStorage === void 0) {
_canUseSessionStorage = !!_getVerifiedStorageObject(StorageType.SessionStorage);
}
return _canUseSessionStorage;
}
function utlGetSessionStorageKeys() {
var keys = [];
if (utlCanUseSessionStorage()) {
objForEachKey(/* @__PURE__ */ getInst("sessionStorage"), function(key) {
keys.push(key);
});
}
return keys;
}
function utlGetSessionStorage(logger2, name) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
return storage.getItem(name);
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 2, "Browser failed read of session storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return null;
}
function utlSetSessionStorage(logger2, name, data) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
storage.setItem(name, data);
return true;
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 4, "Browser failed write to session storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
function utlRemoveSessionStorage(logger2, name) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
storage[_DYN_REMOVE_ITEM](name);
return true;
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 6, "Browser failed removal of session storage item. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
var THROTTLE_STORAGE_PREFIX = "appInsightsThrottle";
var ThrottleMgr = (
/** @class */
/* @__PURE__ */ (function() {
function ThrottleMgr2(core, namePrefix) {
var _self = this;
var _canUseLocalStorage2;
var _logger;
var _config;
var _localStorageObj;
var _isTriggered;
var _namePrefix;
var _queue;
var _isReady = false;
var _isSpecificDaysGiven = false;
_initConfig();
_self["_getDbgPlgTargets"] = function() {
return [_queue];
};
_self.getConfig = function() {
return _config;
};
_self.canThrottle = function(msgId) {
var localObj = _getLocalStorageObjByKey(msgId);
var cfg = _getCfgByKey(msgId);
return _canThrottle(cfg, _canUseLocalStorage2, localObj);
};
_self.isTriggered = function(msgId) {
return _isTrigger(msgId);
};
_self.isReady = function() {
return _isReady;
};
_self.flush = function(msgId) {
try {
var queue = _getQueueByKey(msgId);
if (queue && queue[_DYN_LENGTH] > 0) {
var items = queue.slice(0);
_queue[msgId] = [];
arrForEach(items, function(item) {
_flushMessage(item.msgID, item[_DYN_MESSAGE], item.severity, false);
});
return true;
}
} catch (err) {
}
return false;
};
_self.flushAll = function() {
try {
if (_queue) {
var result_1 = true;
objForEachKey(_queue, function(key) {
var isFlushed = _self.flush(parseInt(key));
result_1 = result_1 && isFlushed;
});
return result_1;
}
} catch (err) {
}
return false;
};
_self.onReadyState = function(isReady, flushAll) {
if (flushAll === void 0) {
flushAll = true;
}
_isReady = /* @__PURE__ */ isNullOrUndefined(isReady) ? true : isReady;
if (_isReady && flushAll) {
return _self.flushAll();
}
return null;
};
_self.sendMessage = function(msgID, message, severity) {
return _flushMessage(msgID, message, severity, true);
};
function _flushMessage(msgID, message, severity, saveUnsentMsg) {
if (_isReady) {
var isSampledIn = _canSampledIn(msgID);
if (!isSampledIn) {
return;
}
var cfg = _getCfgByKey(msgID);
var localStorageObj = _getLocalStorageObjByKey(msgID);
var canThrottle = _canThrottle(cfg, _canUseLocalStorage2, localStorageObj);
var throttled = false;
var number = 0;
var isTriggered = _isTrigger(msgID);
try {
if (canThrottle && !isTriggered) {
number = mathMin(cfg.limit.maxSendNumber, localStorageObj[_DYN_COUNT] + 1);
localStorageObj[_DYN_COUNT] = 0;
throttled = true;
_isTriggered[msgID] = true;
localStorageObj[_DYN_PRE_TRIGGER_DATE] = /* @__PURE__ */ new Date();
} else {
_isTriggered[msgID] = canThrottle;
localStorageObj[_DYN_COUNT] += 1;
}
var localStorageName = _getLocalStorageName(msgID);
_resetLocalStorage(_logger, localStorageName, localStorageObj);
for (var i = 0; i < number; i++) {
_sendMessage(msgID, _logger, message, severity);
}
} catch (e) {
}
return {
isThrottled: throttled,
throttleNum: number
};
} else {
if (!!saveUnsentMsg) {
var queue = _getQueueByKey(msgID);
queue.push({
msgID,
message,
severity
});
}
}
return null;
}
function _initConfig() {
_logger = safeGetLogger(core);
_isTriggered = {};
_localStorageObj = {};
_queue = {};
_config = {};
_setCfgByKey(109);
_namePrefix = isNotNullOrUndefined(namePrefix) ? namePrefix : "";
core.addUnloadHook(onConfigChange(core.config, function(details) {
var coreConfig = details.cfg;
_canUseLocalStorage2 = utlCanUseLocalStorage();
var configMgr = coreConfig.throttleMgrCfg || {};
objForEachKey(configMgr, function(key, cfg) {
_setCfgByKey(parseInt(key), cfg);
});
}));
}
function _getCfgByKey(msgID) {
return _config[msgID] || _config[109];
}
function _setCfgByKey(msgID, config) {
var _a2, _b;
try {
var cfg = config || {};
var curCfg = {};
curCfg.disabled = !!cfg.disabled;
var configInterval = cfg.interval || {};
_isSpecificDaysGiven = (configInterval === null || configInterval === void 0 ? void 0 : configInterval.daysOfMonth) && (configInterval === null || configInterval === void 0 ? void 0 : configInterval.daysOfMonth[_DYN_LENGTH]) > 0;
curCfg.interval = _getIntervalConfig(configInterval);
var limit = {
samplingRate: ((_a2 = cfg.limit) === null || _a2 === void 0 ? void 0 : _a2.samplingRate) || 100,
maxSendNumber: ((_b = cfg.limit) === null || _b === void 0 ? void 0 : _b.maxSendNumber) || 1
};
curCfg.limit = limit;
_config[msgID] = curCfg;
} catch (e) {
}
}
function _getIntervalConfig(interval) {
interval = interval || {};
var monthInterval = interval === null || interval === void 0 ? void 0 : interval.monthInterval;
var dayInterval = interval === null || interval === void 0 ? void 0 : interval.dayInterval;
if (/* @__PURE__ */ isNullOrUndefined(monthInterval) && /* @__PURE__ */ isNullOrUndefined(dayInterval)) {
interval.monthInterval = 3;
if (!_isSpecificDaysGiven) {
interval.daysOfMonth = [28];
_isSpecificDaysGiven = true;
}
}
interval = {
monthInterval: interval === null || interval === void 0 ? void 0 : interval.monthInterval,
dayInterval: interval === null || interval === void 0 ? void 0 : interval.dayInterval,
daysOfMonth: interval === null || interval === void 0 ? void 0 : interval.daysOfMonth
};
return interval;
}
function _canThrottle(config, canUseLocalStorage, localStorageObj) {
if (config && !config.disabled && canUseLocalStorage && isNotNullOrUndefined(localStorageObj)) {
var curDate = _getThrottleDate();
var date = localStorageObj.date;
var interval = config.interval;
var monthCheck = 1;
if (interval === null || interval === void 0 ? void 0 : interval.monthInterval) {
var monthExpand = (curDate.getUTCFullYear() - date.getUTCFullYear()) * 12 + curDate.getUTCMonth() - date.getUTCMonth();
monthCheck = _checkInterval(interval.monthInterval, 0, monthExpand);
}
var dayCheck = 1;
if (_isSpecificDaysGiven) {
dayCheck = arrIndexOf(interval.daysOfMonth, curDate[_DYN_GET_UTCDATE]());
} else if (interval === null || interval === void 0 ? void 0 : interval.dayInterval) {
var daySpan = mathFloor((curDate.getTime() - date.getTime()) / 864e5);
dayCheck = _checkInterval(interval.dayInterval, 0, daySpan);
}
return monthCheck >= 0 && dayCheck >= 0;
}
return false;
}
function _getLocalStorageName(msgKey, prefix) {
var fix = isNotNullOrUndefined(prefix) ? prefix : "";
if (msgKey) {
return THROTTLE_STORAGE_PREFIX + fix + "-" + msgKey;
}
return null;
}
function _isTriggeredOnCurDate(preTriggerDate) {
try {
if (preTriggerDate) {
var curDate = /* @__PURE__ */ new Date();
return preTriggerDate.getUTCFullYear() === curDate.getUTCFullYear() && preTriggerDate.getUTCMonth() === curDate.getUTCMonth() && preTriggerDate[_DYN_GET_UTCDATE]() === curDate[_DYN_GET_UTCDATE]();
}
} catch (e) {
}
return false;
}
function _getLocalStorageObj(value, logger2, storageName) {
try {
var storageObj = {
date: _getThrottleDate(),
count: 0
};
if (value) {
var obj = JSON.parse(value);
var curObj = {
date: _getThrottleDate(obj.date) || storageObj.date,
count: obj[_DYN_COUNT] || storageObj[_DYN_COUNT],
preTriggerDate: obj.preTriggerDate ? _getThrottleDate(obj[_DYN_PRE_TRIGGER_DATE]) : void 0
};
return curObj;
} else {
_resetLocalStorage(logger2, storageName, storageObj);
return storageObj;
}
} catch (e) {
}
return null;
}
function _getThrottleDate(dateStr) {
try {
if (dateStr) {
var date = new Date(dateStr);
if (!isNaN(date.getDate())) {
return date;
}
} else {
return /* @__PURE__ */ new Date();
}
} catch (e) {
}
return null;
}
function _resetLocalStorage(logger2, storageName, obj) {
try {
return utlSetLocalStorage(logger2, storageName, strTrim(JSON[_DYN_STRINGIFY](obj)));
} catch (e) {
}
return false;
}
function _checkInterval(interval, start, current) {
if (interval <= 0) {
return 1;
}
return current >= start && (current - start) % interval == 0 ? mathFloor((current - start) / interval) + 1 : -1;
}
function _sendMessage(msgID, logger2, message, severity) {
_throwInternal(logger2, severity || 1, msgID, message);
}
function _canSampledIn(msgID) {
try {
var cfg = _getCfgByKey(msgID);
return randomValue(1e6) <= cfg.limit.samplingRate;
} catch (e) {
}
return false;
}
function _getLocalStorageObjByKey(key) {
try {
var curObj = _localStorageObj[key];
if (!curObj) {
var localStorageName = _getLocalStorageName(key, _namePrefix);
curObj = _getLocalStorageObj(utlGetLocalStorage(_logger, localStorageName), _logger, localStorageName);
_localStorageObj[key] = curObj;
}
return _localStorageObj[key];
} catch (e) {
}
return null;
}
function _isTrigger(key) {
var isTrigger = _isTriggered[key];
if (/* @__PURE__ */ isNullOrUndefined(isTrigger)) {
isTrigger = false;
var localStorageObj = _getLocalStorageObjByKey(key);
if (localStorageObj) {
isTrigger = _isTriggeredOnCurDate(localStorageObj[_DYN_PRE_TRIGGER_DATE]);
}
_isTriggered[key] = isTrigger;
}
return _isTriggered[key];
}
function _getQueueByKey(key) {
_queue = _queue || {};
if (/* @__PURE__ */ isNullOrUndefined(_queue[key])) {
_queue[key] = [];
}
return _queue[key];
}
}
return ThrottleMgr2;
})()
);
var _FIELDS_SEPARATOR = ";";
var _FIELD_KEY_VALUE_SEPARATOR = "=";
function parseConnectionString(connectionString) {
if (!connectionString) {
return {};
}
var kvPairs = connectionString[_DYN_SPLIT](_FIELDS_SEPARATOR);
var result = arrReduce(kvPairs, function(fields, kv) {
var kvParts = kv[_DYN_SPLIT](_FIELD_KEY_VALUE_SEPARATOR);
if (kvParts[_DYN_LENGTH] === 2) {
var key = kvParts[0][_DYN_TO_LOWER_CASE]();
var value = kvParts[1];
fields[key] = value;
}
return fields;
}, {});
if (objKeys(result)[_DYN_LENGTH] > 0) {
if (result.endpointsuffix) {
var locationPrefix = result.location ? result.location + "." : "";
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT] || "https://" + locationPrefix + "dc." + result.endpointsuffix;
}
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT] || DEFAULT_BREEZE_ENDPOINT;
if (strEndsWith(result[_DYN_INGESTIONENDPOINT], "/")) {
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT].slice(0, -1);
}
}
return result;
}
var ConnectionStringParser = {
parse: parseConnectionString
};
var Envelope = (
/** @class */
/* @__PURE__ */ (function() {
function Envelope2(logger2, data, name) {
var _this = this;
var _self = this;
_self.ver = 1;
_self.sampleRate = 100;
_self.tags = {};
_self[_DYN_NAME] = dataSanitizeString(logger2, name) || strNotSpecified;
_self.data = data;
_self.time = toISOString(/* @__PURE__ */ new Date());
_self[_DYN_AI_DATA_CONTRACT] = {
time: 1,
iKey: 1,
name: 1,
sampleRate: function() {
return _this.sampleRate === 100 ? 4 : 1;
},
tags: 1,
data: 1
};
}
return Envelope2;
})()
);
var Event$1 = (
/** @class */
(function() {
function Event2(logger2, name, properties, measurements) {
this.aiDataContract = {
ver: 1,
name: 1,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
_self[_DYN_NAME] = dataSanitizeString(logger2, name) || strNotSpecified;
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
}
Event2.envelopeType = "Microsoft.ApplicationInsights.{0}.Event";
Event2.dataType = "EventData";
return Event2;
})()
);
var STACKFRAME_BASE_SIZE = 58;
var IS_FRAME = /^\s{0,50}(from\s|at\s|Line\s{1,5}\d{1,10}\s{1,5}of|\w{1,50}@\w{1,80}|[^\(\s\n]+:[0-9\?]+(?::[0-9\?]+)?)/;
var FULL_STACK_FRAME_1 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+):([0-9\?]+)\)?$/;
var FULL_STACK_FRAME_2 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+)\)?$/;
var FULL_STACK_FRAME_3 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\)\]]+)\)?$/;
var EXTRACT_FILENAME = /(?:^|\(|\s{0,10}[\w\)]+\@)?([^\(\n\s\]\)]+)(?:\:([0-9]+)(?:\:([0-9]+))?)?\)?(?:,|$)/;
var PARSE_FILENAME_LINE_COL = /([^\(\s\n]+):([0-9]+):([0-9]+)$/;
var PARSE_FILENAME_LINE_ONLY = /([^\(\s\n]+):([0-9]+)$/;
var NoMethod = "<no_method>";
var strError = "error";
var strStack = "stack";
var strStackDetails = "stackDetails";
var strErrorSrc = "errorSrc";
var strMessage = "message";
var strDescription = "description";
var _parseSequence = [
{ re: FULL_STACK_FRAME_1, len: 5, m: 1, fn: 2, ln: 3, col: 4 },
{ chk: _ignoreNative, pre: _scrubAnonymous, re: FULL_STACK_FRAME_2, len: 4, m: 1, fn: 2, ln: 3 },
{ re: FULL_STACK_FRAME_3, len: 3, m: 1, fn: 2, hdl: _handleFilename },
{ re: EXTRACT_FILENAME, len: 2, fn: 1, hdl: _handleFilename }
];
function _scrubAnonymous(frame) {
return frame.replace(/(\(anonymous\))/, "<anonymous>");
}
function _ignoreNative(frame) {
return strIndexOf(frame, "[native") < 0;
}
function _stringify(value, convertToString) {
var result = value;
if (result && !isString(result)) {
if (JSON && JSON[_DYN_STRINGIFY]) {
result = JSON[_DYN_STRINGIFY](value);
if (convertToString && (!result || result === "{}")) {
if (isFunction(value[_DYN_TO_STRING])) {
result = value[_DYN_TO_STRING]();
} else {
result = "" + value;
}
}
} else {
result = "" + value + " - (Missing JSON.stringify)";
}
}
return result || "";
}
function _formatMessage(theEvent, errorType) {
var evtMessage = theEvent;
if (theEvent) {
if (evtMessage && !isString(evtMessage)) {
evtMessage = theEvent[strMessage] || theEvent[strDescription] || evtMessage;
}
if (evtMessage && !isString(evtMessage)) {
evtMessage = _stringify(evtMessage, true);
}
if (theEvent["filename"]) {
evtMessage = evtMessage + " @" + (theEvent["filename"] || "") + ":" + (theEvent["lineno"] || "?") + ":" + (theEvent["colno"] || "?");
}
}
if (errorType && errorType !== "String" && errorType !== "Object" && errorType !== "Error" && strIndexOf(evtMessage || "", errorType) === -1) {
evtMessage = errorType + ": " + evtMessage;
}
return evtMessage || "";
}
function _isExceptionDetailsInternal(value) {
try {
if (/* @__PURE__ */ isObject(value)) {
return "hasFullStack" in value && "typeName" in value;
}
} catch (e) {
}
return false;
}
function _isExceptionInternal(value) {
try {
if (/* @__PURE__ */ isObject(value)) {
return "ver" in value && "exceptions" in value && "properties" in value;
}
} catch (e) {
}
return false;
}
function _isStackDetails(details) {
return details && details.src && isString(details.src) && details.obj && isArray(details.obj);
}
function _convertStackObj(errorStack) {
var src = errorStack || "";
if (!isString(src)) {
if (isString(src[strStack])) {
src = src[strStack];
} else {
src = "" + src;
}
}
var items = src[_DYN_SPLIT]("\n");
return {
src,
obj: items
};
}
function _getOperaStack(errorMessage) {
var stack = [];
var lines = errorMessage[_DYN_SPLIT]("\n");
for (var lp = 0; lp < lines[_DYN_LENGTH]; lp++) {
var entry = lines[lp];
if (lines[lp + 1]) {
entry += "@" + lines[lp + 1];
lp++;
}
stack.push(entry);
}
return {
src: errorMessage,
obj: stack
};
}
function _getStackFromErrorObj(errorObj) {
var details = null;
if (errorObj) {
try {
if (errorObj[strStack]) {
details = _convertStackObj(errorObj[strStack]);
} else if (errorObj[strError] && errorObj[strError][strStack]) {
details = _convertStackObj(errorObj[strError][strStack]);
} else if (errorObj["exception"] && errorObj.exception[strStack]) {
details = _convertStackObj(errorObj.exception[strStack]);
} else if (_isStackDetails(errorObj)) {
details = errorObj;
} else if (_isStackDetails(errorObj[strStackDetails])) {
details = errorObj[strStackDetails];
} else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
details = _getOperaStack(errorObj[_DYN_MESSAGE]);
} else if (errorObj["reason"] && errorObj.reason[strStack]) {
details = _convertStackObj(errorObj.reason[strStack]);
} else if (isString(errorObj)) {
details = _convertStackObj(errorObj);
} else {
var evtMessage = errorObj[strMessage] || errorObj[strDescription] || "";
if (isString(errorObj[strErrorSrc])) {
if (evtMessage) {
evtMessage += "\n";
}
evtMessage += " from " + errorObj[strErrorSrc];
}
if (evtMessage) {
details = _convertStackObj(evtMessage);
}
}
} catch (e) {
details = _convertStackObj(e);
}
}
return details || {
src: "",
obj: null
};
}
function _formatStackTrace(stackDetails) {
var stack = "";
if (stackDetails) {
if (stackDetails.obj) {
stack = stackDetails.obj.join("\n");
} else {
stack = stackDetails.src || "";
}
}
return stack;
}
function _parseStack(stack) {
var parsedStack;
var frames = stack.obj;
if (frames && frames[_DYN_LENGTH] > 0) {
parsedStack = [];
var level_1 = 0;
var foundStackStart_1 = false;
var totalSizeInBytes_1 = 0;
arrForEach(frames, function(frame) {
if (foundStackStart_1 || _isStackFrame(frame)) {
var theFrame = asString(frame);
foundStackStart_1 = true;
var parsedFrame = _extractStackFrame(theFrame, level_1);
if (parsedFrame) {
totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES];
parsedStack.push(parsedFrame);
level_1++;
}
}
});
var exceptionParsedStackThreshold = 32 * 1024;
if (totalSizeInBytes_1 > exceptionParsedStackThreshold) {
var left = 0;
var right = parsedStack[_DYN_LENGTH] - 1;
var size = 0;
var acceptedLeft = left;
var acceptedRight = right;
while (left < right) {
var lSize = parsedStack[left][_DYN_SIZE_IN_BYTES];
var rSize = parsedStack[right][_DYN_SIZE_IN_BYTES];
size += lSize + rSize;
if (size > exceptionParsedStackThreshold) {
var howMany = acceptedRight - acceptedLeft + 1;
parsedStack.splice(acceptedLeft, howMany);
break;
}
acceptedLeft = left;
acceptedRight = right;
left++;
right--;
}
}
}
return parsedStack;
}
function _getErrorType(errorType) {
var typeName = "";
if (errorType) {
typeName = errorType.typeName || errorType[_DYN_NAME] || "";
if (!typeName) {
try {
var funcNameRegex = /function (.{1,200})\(/;
var results = funcNameRegex.exec(errorType.constructor[_DYN_TO_STRING]());
typeName = results && results[_DYN_LENGTH] > 1 ? results[1] : "";
} catch (e) {
}
}
}
return typeName;
}
function _formatErrorCode(errorObj) {
if (errorObj) {
try {
if (!isString(errorObj)) {
var errorType = _getErrorType(errorObj);
var result = _stringify(errorObj, false);
if (!result || result === "{}") {
if (errorObj[strError]) {
errorObj = errorObj[strError];
errorType = _getErrorType(errorObj);
}
result = _stringify(errorObj, true);
}
if (strIndexOf(result, errorType) !== 0 && errorType !== "String") {
return errorType + ":" + result;
}
return result;
}
} catch (e) {
}
}
return "" + (errorObj || "");
}
var Exception = (
/** @class */
(function() {
function Exception2(logger2, exception, properties, measurements, severityLevel, id) {
this.aiDataContract = {
ver: 1,
exceptions: 1,
severityLevel: 0,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
if (!_isExceptionInternal(exception)) {
if (!properties) {
properties = {};
}
if (id) {
properties.id = id;
}
_self[_DYN_EXCEPTIONS] = [_createExceptionDetails(logger2, exception, properties)];
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
if (severityLevel) {
_self[_DYN_SEVERITY_LEVEL] = severityLevel;
}
if (id) {
_self.id = id;
}
} else {
_self[_DYN_EXCEPTIONS] = exception[_DYN_EXCEPTIONS] || [];
_self[_DYN_PROPERTIES] = exception[_DYN_PROPERTIES];
_self[_DYN_MEASUREMENTS] = exception[_DYN_MEASUREMENTS];
if (exception[_DYN_SEVERITY_LEVEL]) {
_self[_DYN_SEVERITY_LEVEL] = exception[_DYN_SEVERITY_LEVEL];
}
if (exception.id) {
_self.id = exception.id;
exception[_DYN_PROPERTIES].id = exception.id;
}
if (exception[_DYN_PROBLEM_GROUP]) {
_self[_DYN_PROBLEM_GROUP] = exception[_DYN_PROBLEM_GROUP];
}
if (!/* @__PURE__ */ isNullOrUndefined(exception.isManual)) {
_self.isManual = exception.isManual;
}
}
}
Exception2.CreateAutoException = function(message, url, lineNumber, columnNumber, error, evt, stack, errorSrc) {
var errorType = _getErrorType(error || evt || message);
return {
message: _formatMessage(message, errorType),
url,
lineNumber,
columnNumber,
error: _formatErrorCode(error || evt || message),
evt: _formatErrorCode(evt || message),
typeName: errorType,
stackDetails: _getStackFromErrorObj(stack || error || evt),
errorSrc
};
};
Exception2.CreateFromInterface = function(logger2, exception, properties, measurements) {
var exceptions = exception[_DYN_EXCEPTIONS] && arrMap(exception[_DYN_EXCEPTIONS], function(ex) {
return _createExDetailsFromInterface(logger2, ex);
});
var exceptionData = new Exception2(logger2, __assignFn(__assignFn({}, exception), { exceptions }), properties, measurements);
return exceptionData;
};
Exception2.prototype.toInterface = function() {
var _a2 = this, exceptions = _a2.exceptions, properties = _a2.properties, measurements = _a2.measurements, severityLevel = _a2.severityLevel, problemGroup = _a2.problemGroup, id = _a2.id, isManual = _a2.isManual;
var exceptionDetailsInterface = exceptions instanceof Array && arrMap(exceptions, function(exception) {
return exception.toInterface();
}) || void 0;
return {
ver: "4.0",
exceptions: exceptionDetailsInterface,
severityLevel,
properties,
measurements,
problemGroup,
id,
isManual
};
};
Exception2.CreateSimpleException = function(message, typeName, assembly, fileName, details, line) {
var _a2;
return {
exceptions: [
(_a2 = {}, _a2[_DYN_HAS_FULL_STACK] = true, _a2.message = message, _a2.stack = details, _a2.typeName = typeName, _a2)
]
};
};
Exception2.envelopeType = "Microsoft.ApplicationInsights.{0}.Exception";
Exception2.dataType = "ExceptionData";
Exception2.formatError = _formatErrorCode;
return Exception2;
})()
);
var exDetailsAiDataContract = objFreeze({
id: 0,
outerId: 0,
typeName: 1,
message: 1,
hasFullStack: 0,
stack: 0,
parsedStack: 2
});
function _toInterface() {
var _self = this;
var parsedStack = isArray(_self[_DYN_PARSED_STACK]) && arrMap(_self[_DYN_PARSED_STACK], function(frame) {
return _parsedFrameToInterface(frame);
});
var exceptionDetailsInterface = {
id: _self.id,
outerId: _self.outerId,
typeName: _self[_DYN_TYPE_NAME],
message: _self[_DYN_MESSAGE],
hasFullStack: _self[_DYN_HAS_FULL_STACK],
stack: _self[strStack],
parsedStack: parsedStack || void 0
};
return exceptionDetailsInterface;
}
function _createExceptionDetails(logger2, exception, properties) {
var _a2;
var id;
var outerId;
var typeName;
var message;
var hasFullStack;
var theStack;
var parsedStack;
if (!_isExceptionDetailsInternal(exception)) {
var error = exception;
var evt = error && error.evt;
if (!isError(error)) {
error = error[strError] || evt || error;
}
typeName = dataSanitizeString(logger2, _getErrorType(error)) || strNotSpecified;
message = dataSanitizeMessage(logger2, _formatMessage(exception || error, typeName)) || strNotSpecified;
var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
parsedStack = _parseStack(stack);
if (isArray(parsedStack)) {
arrMap(parsedStack, function(frame) {
frame[_DYN_ASSEMBLY] = dataSanitizeString(logger2, frame[_DYN_ASSEMBLY]);
frame[_DYN_FILE_NAME] = dataSanitizeString(logger2, frame[_DYN_FILE_NAME]);
});
}
theStack = dataSanitizeException(logger2, _formatStackTrace(stack));
hasFullStack = isArray(parsedStack) && parsedStack[_DYN_LENGTH] > 0;
if (properties) {
properties[_DYN_TYPE_NAME] = properties[_DYN_TYPE_NAME] || typeName;
}
} else {
typeName = exception[_DYN_TYPE_NAME];
message = exception[_DYN_MESSAGE];
theStack = exception[strStack];
parsedStack = exception[_DYN_PARSED_STACK] || [];
hasFullStack = exception[_DYN_HAS_FULL_STACK];
}
return _a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = exDetailsAiDataContract, _a2.id = id, _a2.outerId = outerId, _a2.typeName = typeName, _a2.message = message, _a2[_DYN_HAS_FULL_STACK] = hasFullStack, _a2.stack = theStack, _a2.parsedStack = parsedStack, _a2.toInterface = _toInterface, _a2;
}
function _createExDetailsFromInterface(logger2, exception) {
var parsedStack = isArray(exception[_DYN_PARSED_STACK]) && arrMap(exception[_DYN_PARSED_STACK], function(frame) {
return _stackFrameFromInterface(frame);
}) || exception[_DYN_PARSED_STACK];
var exceptionDetails = _createExceptionDetails(logger2, __assignFn(__assignFn({}, exception), { parsedStack }));
return exceptionDetails;
}
function _parseFilename(theFrame, fileName) {
var lineCol = fileName[_DYN_MATCH](PARSE_FILENAME_LINE_COL);
if (lineCol && lineCol[_DYN_LENGTH] >= 4) {
theFrame[_DYN_FILE_NAME] = lineCol[1];
theFrame[_DYN_LINE] = parseInt(lineCol[2]);
} else {
var lineNo = fileName[_DYN_MATCH](PARSE_FILENAME_LINE_ONLY);
if (lineNo && lineNo[_DYN_LENGTH] >= 3) {
theFrame[_DYN_FILE_NAME] = lineNo[1];
theFrame[_DYN_LINE] = parseInt(lineNo[2]);
} else {
theFrame[_DYN_FILE_NAME] = fileName;
}
}
}
function _handleFilename(theFrame, sequence, matches) {
var filename = theFrame[_DYN_FILE_NAME];
if (sequence.fn && matches && matches[_DYN_LENGTH] > sequence.fn) {
if (sequence.ln && matches[_DYN_LENGTH] > sequence.ln) {
filename = strTrim(matches[sequence.fn] || "");
theFrame[_DYN_LINE] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
} else {
filename = strTrim(matches[sequence.fn] || "");
}
}
if (filename) {
_parseFilename(theFrame, filename);
}
}
function _isStackFrame(frame) {
var result = false;
if (frame && isString(frame)) {
var trimmedFrame = strTrim(frame);
if (trimmedFrame) {
result = IS_FRAME.test(trimmedFrame);
}
}
return result;
}
var stackFrameAiDataContract = objFreeze({
level: 1,
method: 1,
assembly: 0,
fileName: 0,
line: 0
});
function _extractStackFrame(frame, level) {
var _a2;
var theFrame;
if (frame && isString(frame) && strTrim(frame)) {
theFrame = (_a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = stackFrameAiDataContract, _a2.level = level, _a2.assembly = strTrim(frame), _a2.method = NoMethod, _a2.fileName = "", _a2.line = 0, _a2.sizeInBytes = 0, _a2);
var idx = 0;
while (idx < _parseSequence[_DYN_LENGTH]) {
var sequence = _parseSequence[idx];
if (sequence.chk && !sequence.chk(frame)) {
break;
}
if (sequence.pre) {
frame = sequence.pre(frame);
}
var matches = frame[_DYN_MATCH](sequence.re);
if (matches && matches[_DYN_LENGTH] >= sequence.len) {
if (sequence.m) {
theFrame.method = strTrim(matches[sequence.m] || NoMethod);
}
if (sequence.hdl) {
sequence.hdl(theFrame, sequence, matches);
} else if (sequence.fn) {
if (sequence.ln) {
theFrame[_DYN_FILE_NAME] = strTrim(matches[sequence.fn] || "");
theFrame[_DYN_LINE] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
} else {
_parseFilename(theFrame, matches[sequence.fn] || "");
}
}
break;
}
idx++;
}
}
return _populateFrameSizeInBytes(theFrame);
}
function _stackFrameFromInterface(frame) {
var _a2;
var parsedFrame = (_a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = stackFrameAiDataContract, _a2.level = frame.level, _a2.method = frame.method, _a2.assembly = frame[_DYN_ASSEMBLY], _a2.fileName = frame[_DYN_FILE_NAME], _a2.line = frame[_DYN_LINE], _a2.sizeInBytes = 0, _a2);
return _populateFrameSizeInBytes(parsedFrame);
}
function _populateFrameSizeInBytes(frame) {
var sizeInBytes = STACKFRAME_BASE_SIZE;
if (frame) {
sizeInBytes += frame.method[_DYN_LENGTH];
sizeInBytes += frame.assembly[_DYN_LENGTH];
sizeInBytes += frame.fileName[_DYN_LENGTH];
sizeInBytes += frame.level.toString()[_DYN_LENGTH];
sizeInBytes += frame.line.toString()[_DYN_LENGTH];
frame[_DYN_SIZE_IN_BYTES] = sizeInBytes;
}
return frame;
}
function _parsedFrameToInterface(frame) {
return {
level: frame.level,
method: frame.method,
assembly: frame[_DYN_ASSEMBLY],
fileName: frame[_DYN_FILE_NAME],
line: frame[_DYN_LINE]
};
}
var DataPoint = (
/** @class */
/* @__PURE__ */ (function() {
function DataPoint2() {
this.aiDataContract = {
name: 1,
kind: 0,
value: 1,
count: 0,
min: 0,
max: 0,
stdDev: 0
};
this.kind = 0;
}
return DataPoint2;
})()
);
var Metric = (
/** @class */
(function() {
function Metric2(logger2, name, value, count, min, max, stdDev, properties, measurements) {
this.aiDataContract = {
ver: 1,
metrics: 1,
properties: 0
};
var _self = this;
_self.ver = 2;
var dataPoint = new DataPoint();
dataPoint[_DYN_COUNT] = count > 0 ? count : void 0;
dataPoint.max = isNaN(max) || max === null ? void 0 : max;
dataPoint.min = isNaN(min) || min === null ? void 0 : min;
dataPoint[_DYN_NAME] = dataSanitizeString(logger2, name) || strNotSpecified;
dataPoint.value = value;
dataPoint.stdDev = isNaN(stdDev) || stdDev === null ? void 0 : stdDev;
_self.metrics = [dataPoint];
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
}
Metric2.envelopeType = "Microsoft.ApplicationInsights.{0}.Metric";
Metric2.dataType = "MetricData";
return Metric2;
})()
);
var strEmpty = "";
function stringToBoolOrDefault(str, defaultValue) {
if (defaultValue === void 0) {
defaultValue = false;
}
if (str === void 0 || str === null) {
return defaultValue;
}
return str.toString()[_DYN_TO_LOWER_CASE]() === "true";
}
function msToTimeSpan(totalms) {
if (isNaN(totalms) || totalms < 0) {
totalms = 0;
}
totalms = mathRound(totalms);
var ms = strEmpty + totalms % 1e3;
var sec = strEmpty + mathFloor(totalms / 1e3) % 60;
var min = strEmpty + mathFloor(totalms / (1e3 * 60)) % 60;
var hour = strEmpty + mathFloor(totalms / (1e3 * 60 * 60)) % 24;
var days = mathFloor(totalms / (1e3 * 60 * 60 * 24));
ms = ms[_DYN_LENGTH] === 1 ? "00" + ms : ms[_DYN_LENGTH] === 2 ? "0" + ms : ms;
sec = sec[_DYN_LENGTH] < 2 ? "0" + sec : sec;
min = min[_DYN_LENGTH] < 2 ? "0" + min : min;
hour = hour[_DYN_LENGTH] < 2 ? "0" + hour : hour;
return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
}
function getExtensionByName(extensions3, identifier) {
var extension = null;
arrForEach(extensions3, function(value) {
if (value.identifier === identifier) {
extension = value;
return -1;
}
});
return extension;
}
function isCrossOriginError(message, url, lineNumber, columnNumber, error) {
return !error && isString(message) && (message === "Script error." || message === "Script error");
}
var PageView = (
/** @class */
(function() {
function PageView2(logger2, name, url, durationMs, properties, measurements, id) {
this.aiDataContract = {
ver: 1,
name: 0,
url: 0,
duration: 0,
properties: 0,
measurements: 0,
id: 0
};
var _self = this;
_self.ver = 2;
_self.id = dataSanitizeId(logger2, id);
_self.url = dataSanitizeUrl(logger2, url);
_self[_DYN_NAME] = dataSanitizeString(logger2, name) || strNotSpecified;
if (!isNaN(durationMs)) {
_self[_DYN_DURATION] = msToTimeSpan(durationMs);
}
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
}
PageView2.envelopeType = "Microsoft.ApplicationInsights.{0}.Pageview";
PageView2.dataType = "PageviewData";
return PageView2;
})()
);
var RemoteDependencyData = (
/** @class */
(function() {
function RemoteDependencyData2(logger2, id, absoluteUrl, commandName, value, success, resultCode, method, requestAPI, correlationContext, properties, measurements) {
if (requestAPI === void 0) {
requestAPI = "Ajax";
}
this.aiDataContract = {
id: 1,
ver: 1,
name: 0,
resultCode: 0,
duration: 0,
success: 0,
data: 0,
target: 0,
type: 0,
properties: 0,
measurements: 0,
kind: 0,
value: 0,
count: 0,
min: 0,
max: 0,
stdDev: 0,
dependencyKind: 0,
dependencySource: 0,
commandName: 0,
dependencyTypeName: 0
};
var _self = this;
_self.ver = 2;
_self.id = id;
_self[_DYN_DURATION] = msToTimeSpan(value);
_self.success = success;
_self.resultCode = resultCode + "";
_self.type = dataSanitizeString(logger2, requestAPI);
var dependencyFields = AjaxHelperParseDependencyPath(logger2, absoluteUrl, method, commandName);
_self.data = dataSanitizeUrl(logger2, commandName) || dependencyFields.data;
_self.target = dataSanitizeString(logger2, dependencyFields.target);
if (correlationContext) {
_self.target = "".concat(_self.target, " | ").concat(correlationContext);
}
_self[_DYN_NAME] = dataSanitizeString(logger2, dependencyFields[_DYN_NAME]);
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
}
RemoteDependencyData2.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
RemoteDependencyData2.dataType = "RemoteDependencyData";
return RemoteDependencyData2;
})()
);
var Trace = (
/** @class */
(function() {
function Trace2(logger2, message, severityLevel, properties, measurements) {
this.aiDataContract = {
ver: 1,
message: 1,
severityLevel: 0,
properties: 0
};
var _self = this;
_self.ver = 2;
message = message || strNotSpecified;
_self[_DYN_MESSAGE] = dataSanitizeMessage(logger2, message);
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
if (severityLevel) {
_self[_DYN_SEVERITY_LEVEL] = severityLevel;
}
}
Trace2.envelopeType = "Microsoft.ApplicationInsights.{0}.Message";
Trace2.dataType = "MessageData";
return Trace2;
})()
);
var PageViewPerformance = (
/** @class */
(function() {
function PageViewPerformance2(logger2, name, url, unused, properties, measurements, cs4BaseData) {
this.aiDataContract = {
ver: 1,
name: 0,
url: 0,
duration: 0,
perfTotal: 0,
networkConnect: 0,
sentRequest: 0,
receivedResponse: 0,
domProcessing: 0,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
_self.url = dataSanitizeUrl(logger2, url);
_self[_DYN_NAME] = dataSanitizeString(logger2, name) || strNotSpecified;
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS] = dataSanitizeMeasurements(logger2, measurements);
if (cs4BaseData) {
_self.domProcessing = cs4BaseData.domProcessing;
_self[_DYN_DURATION] = cs4BaseData[_DYN_DURATION];
_self.networkConnect = cs4BaseData.networkConnect;
_self.perfTotal = cs4BaseData.perfTotal;
_self.receivedResponse = cs4BaseData.receivedResponse;
_self.sentRequest = cs4BaseData.sentRequest;
}
}
PageViewPerformance2.envelopeType = "Microsoft.ApplicationInsights.{0}.PageviewPerformance";
PageViewPerformance2.dataType = "PageviewPerformanceData";
return PageViewPerformance2;
})()
);
var Data = (
/** @class */
/* @__PURE__ */ (function() {
function Data2(baseType, data) {
this.aiDataContract = {
baseType: 1,
baseData: 1
};
this.baseType = baseType;
this.baseData = data;
}
return Data2;
})()
);
var SeverityLevel = /* @__PURE__ */ createEnumStyle({
Verbose: 0,
Information: 1,
Warning: 2,
Error: 3,
Critical: 4
});
var ConfigurationManager = (
/** @class */
(function() {
function ConfigurationManager2() {
}
ConfigurationManager2.getConfig = function(config, field, identifier, defaultValue) {
if (defaultValue === void 0) {
defaultValue = false;
}
var configValue;
if (identifier && config[_DYN_EXTENSION_CONFIG] && config[_DYN_EXTENSION_CONFIG][identifier] && !/* @__PURE__ */ isNullOrUndefined(config[_DYN_EXTENSION_CONFIG][identifier][field])) {
configValue = config[_DYN_EXTENSION_CONFIG][identifier][field];
} else {
configValue = config[field];
}
return !/* @__PURE__ */ isNullOrUndefined(configValue) ? configValue : defaultValue;
};
return ConfigurationManager2;
})()
);
function _aiNameFunc(baseName) {
var aiName = "ai." + baseName + ".";
return function(name) {
return aiName + name;
};
}
var _aiApplication = _aiNameFunc("application");
var _aiDevice = _aiNameFunc("device");
var _aiLocation = _aiNameFunc("location");
var _aiOperation = _aiNameFunc("operation");
var _aiSession = _aiNameFunc("session");
var _aiUser = _aiNameFunc("user");
var _aiCloud = _aiNameFunc("cloud");
var _aiInternal = _aiNameFunc("internal");
var ContextTagKeys = (
/** @class */
(function(_super) {
__extendsFn(ContextTagKeys2, _super);
function ContextTagKeys2() {
return _super.call(this) || this;
}
return ContextTagKeys2;
})(createClassFromInterface({
applicationVersion: _aiApplication("ver"),
applicationBuild: _aiApplication("build"),
applicationTypeId: _aiApplication("typeId"),
applicationId: _aiApplication("applicationId"),
applicationLayer: _aiApplication("layer"),
deviceId: _aiDevice("id"),
deviceIp: _aiDevice("ip"),
deviceLanguage: _aiDevice("language"),
deviceLocale: _aiDevice("locale"),
deviceModel: _aiDevice("model"),
deviceFriendlyName: _aiDevice("friendlyName"),
deviceNetwork: _aiDevice("network"),
deviceNetworkName: _aiDevice("networkName"),
deviceOEMName: _aiDevice("oemName"),
deviceOS: _aiDevice("os"),
deviceOSVersion: _aiDevice("osVersion"),
deviceRoleInstance: _aiDevice("roleInstance"),
deviceRoleName: _aiDevice("roleName"),
deviceScreenResolution: _aiDevice("screenResolution"),
deviceType: _aiDevice("type"),
deviceMachineName: _aiDevice("machineName"),
deviceVMName: _aiDevice("vmName"),
deviceBrowser: _aiDevice("browser"),
deviceBrowserVersion: _aiDevice("browserVersion"),
locationIp: _aiLocation("ip"),
locationCountry: _aiLocation("country"),
locationProvince: _aiLocation("province"),
locationCity: _aiLocation("city"),
operationId: _aiOperation("id"),
operationName: _aiOperation("name"),
operationParentId: _aiOperation("parentId"),
operationRootId: _aiOperation("rootId"),
operationSyntheticSource: _aiOperation("syntheticSource"),
operationCorrelationVector: _aiOperation("correlationVector"),
sessionId: _aiSession("id"),
sessionIsFirst: _aiSession("isFirst"),
sessionIsNew: _aiSession("isNew"),
userAccountAcquisitionDate: _aiUser("accountAcquisitionDate"),
userAccountId: _aiUser("accountId"),
userAgent: _aiUser("userAgent"),
userId: _aiUser("id"),
userStoreRegion: _aiUser("storeRegion"),
userAuthUserId: _aiUser("authUserId"),
userAnonymousUserAcquisitionDate: _aiUser("anonUserAcquisitionDate"),
userAuthenticatedUserAcquisitionDate: _aiUser("authUserAcquisitionDate"),
cloudName: _aiCloud("name"),
cloudRole: _aiCloud("role"),
cloudRoleVer: _aiCloud("roleVer"),
cloudRoleInstance: _aiCloud("roleInstance"),
cloudEnvironment: _aiCloud("environment"),
cloudLocation: _aiCloud("location"),
cloudDeploymentUnit: _aiCloud("deploymentUnit"),
internalNodeName: _aiInternal("nodeName"),
internalSdkVersion: _aiInternal("sdkVersion"),
internalAgentVersion: _aiInternal("agentVersion"),
internalSnippet: _aiInternal("snippet"),
internalSdkSrc: _aiInternal("sdkSrc")
}))
);
function createTelemetryItem(item, baseType, envelopeName, logger2, customProperties, systemProperties) {
envelopeName = dataSanitizeString(logger2, envelopeName) || strNotSpecified;
if (/* @__PURE__ */ isNullOrUndefined(item) || /* @__PURE__ */ isNullOrUndefined(baseType) || /* @__PURE__ */ isNullOrUndefined(envelopeName)) {
throwError("Input doesn't contain all required fields");
}
var iKey = "";
if (item[strIkey]) {
iKey = item[strIkey];
delete item[strIkey];
}
var telemetryItem = {
name: envelopeName,
time: toISOString(/* @__PURE__ */ new Date()),
iKey,
ext: systemProperties ? systemProperties : {},
tags: [],
data: {},
baseType,
baseData: item
};
if (!/* @__PURE__ */ isNullOrUndefined(customProperties)) {
objForEachKey(customProperties, function(prop, value) {
telemetryItem.data[prop] = value;
});
}
return telemetryItem;
}
var TelemetryItemCreator = (
/** @class */
(function() {
function TelemetryItemCreator2() {
}
TelemetryItemCreator2.create = createTelemetryItem;
return TelemetryItemCreator2;
})()
);
var Extensions = {
UserExt: "user",
DeviceExt: "device",
TraceExt: "trace",
WebExt: "web",
AppExt: "app",
OSExt: "os",
SessionExt: "ses",
SDKExt: "sdk"
};
var CtxTagKeys = new ContextTagKeys();
function createDomEvent(eventName) {
var event = null;
if (isFunction(Event)) {
event = new Event(eventName);
} else {
var doc = getDocument();
if (doc && doc.createEvent) {
event = doc.createEvent("Event");
event.initEvent(eventName, true, true);
}
}
return event;
}
function _disableEvents(target, evtNamespace) {
eventOff(target, null, null, evtNamespace);
}
function createOfflineListener(parentEvtNamespace) {
var _document2 = getDocument();
var _navigator = getNavigator();
var _isListening = false;
var listenerList = [];
var rState = 1;
if (_navigator && !/* @__PURE__ */ isNullOrUndefined(_navigator.onLine) && !_navigator.onLine) {
rState = 2;
}
var uState = 0;
var _currentState = calCurrentState();
var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
try {
if (_enableEvents(getWindow())) {
_isListening = true;
}
if (_document2) {
var target = _document2.body || _document2;
if (target.ononline) {
if (_enableEvents(target)) {
_isListening = true;
}
}
}
} catch (e) {
_isListening = false;
}
function _enableEvents(target2) {
var enabled = false;
if (target2) {
enabled = eventOn(target2, "online", _setOnline, _evtNamespace);
if (enabled) {
eventOn(target2, "offline", _setOffline, _evtNamespace);
}
}
return enabled;
}
function _isOnline() {
return _currentState;
}
function calCurrentState() {
if (uState === 2 || rState === 2) {
return false;
}
return true;
}
function listnerNoticeCheck() {
var newState = calCurrentState();
if (_currentState !== newState) {
_currentState = newState;
arrForEach(listenerList, function(callback) {
var offlineState = {
isOnline: _currentState,
rState,
uState
};
try {
callback(offlineState);
} catch (e) {
}
});
}
}
function setOnlineState(newState) {
uState = newState;
listnerNoticeCheck();
}
function _setOnline() {
rState = 1;
listnerNoticeCheck();
}
function _setOffline() {
rState = 2;
listnerNoticeCheck();
}
function _unload() {
var win = getWindow();
if (win && _isListening) {
_disableEvents(win, _evtNamespace);
if (_document2) {
var target2 = _document2.body || _document2;
if (!/* @__PURE__ */ isUndefined(target2.ononline)) {
_disableEvents(target2, _evtNamespace);
}
}
_isListening = false;
}
}
function addListener(callback) {
listenerList.push(callback);
return {
rm: function() {
var index = listenerList.indexOf(callback);
if (index > -1) {
return listenerList.splice(index, 1);
} else {
return;
}
}
};
}
return {
isOnline: _isOnline,
isListening: function() {
return _isListening;
},
unload: _unload,
addListener,
setOnlineState
};
}
var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
exports3.AnalyticsPluginIdentifier = AnalyticsPluginIdentifier;
exports3.BreezeChannelIdentifier = BreezeChannelIdentifier;
exports3.ConfigurationManager = ConfigurationManager;
exports3.ConnectionStringParser = ConnectionStringParser;
exports3.ContextTagKeys = ContextTagKeys;
exports3.CtxTagKeys = CtxTagKeys;
exports3.DEFAULT_BREEZE_ENDPOINT = DEFAULT_BREEZE_ENDPOINT;
exports3.DEFAULT_BREEZE_PATH = DEFAULT_BREEZE_PATH;
exports3.Data = Data;
exports3.DisabledPropertyName = DisabledPropertyName;
exports3.DistributedTracingModes = DistributedTracingModes;
exports3.Envelope = Envelope;
exports3.Event = Event$1;
exports3.EventPersistence = EventPersistence;
exports3.Exception = Exception;
exports3.Extensions = Extensions;
exports3.HttpMethod = HttpMethod;
exports3.Metric = Metric;
exports3.PageView = PageView;
exports3.PageViewPerformance = PageViewPerformance;
exports3.ProcessLegacy = ProcessLegacy;
exports3.PropertiesPluginIdentifier = PropertiesPluginIdentifier;
exports3.RemoteDependencyData = RemoteDependencyData;
exports3.RequestHeaders = RequestHeaders;
exports3.SampleRate = SampleRate;
exports3.SeverityLevel = SeverityLevel;
exports3.TelemetryItemCreator = TelemetryItemCreator;
exports3.ThrottleMgr = ThrottleMgr;
exports3.Trace = Trace;
exports3.correlationIdCanIncludeCorrelationHeader = correlationIdCanIncludeCorrelationHeader;
exports3.correlationIdGetCorrelationContext = correlationIdGetCorrelationContext;
exports3.correlationIdGetCorrelationContextValue = correlationIdGetCorrelationContextValue;
exports3.correlationIdGetPrefix = correlationIdGetPrefix;
exports3.correlationIdSetPrefix = correlationIdSetPrefix;
exports3.createDistributedTraceContextFromTrace = createDistributedTraceContextFromTrace;
exports3.createDomEvent = createDomEvent;
exports3.createOfflineListener = createOfflineListener;
exports3.createTelemetryItem = createTelemetryItem;
exports3.createTraceParent = createTraceParent;
exports3.dataSanitizeException = dataSanitizeException;
exports3.dataSanitizeId = dataSanitizeId;
exports3.dataSanitizeInput = dataSanitizeInput;
exports3.dataSanitizeKey = dataSanitizeKey;
exports3.dataSanitizeKeyAndAddUniqueness = dataSanitizeKeyAndAddUniqueness;
exports3.dataSanitizeMeasurements = dataSanitizeMeasurements;
exports3.dataSanitizeMessage = dataSanitizeMessage;
exports3.dataSanitizeProperties = dataSanitizeProperties;
exports3.dataSanitizeString = dataSanitizeString;
exports3.dataSanitizeUrl = dataSanitizeUrl;
exports3.dateTimeUtilsDuration = dateTimeUtilsDuration;
exports3.dateTimeUtilsNow = dateTimeUtilsNow;
exports3.dsPadNumber = dsPadNumber;
exports3.findAllScripts = findAllScripts;
exports3.findW3cTraceParent = findW3cTraceParent;
exports3.formatTraceParent = formatTraceParent;
exports3.getExtensionByName = getExtensionByName;
exports3.isBeaconApiSupported = isBeaconsSupported;
exports3.isCrossOriginError = isCrossOriginError;
exports3.isInternalApplicationInsightsEndpoint = isInternalApplicationInsightsEndpoint;
exports3.isSampledFlag = isSampledFlag;
exports3.isValidSpanId = isValidSpanId;
exports3.isValidTraceId = isValidTraceId;
exports3.isValidTraceParent = isValidTraceParent;
exports3.msToTimeSpan = msToTimeSpan;
exports3.parseConnectionString = parseConnectionString;
exports3.parseTraceParent = parseTraceParent;
exports3.strNotSpecified = strNotSpecified;
exports3.stringToBoolOrDefault = stringToBoolOrDefault;
exports3.urlGetAbsoluteUrl = urlGetAbsoluteUrl;
exports3.urlGetCompleteUrl = urlGetCompleteUrl;
exports3.urlGetPathName = urlGetPathName;
exports3.urlParseFullHost = urlParseFullHost;
exports3.urlParseHost = urlParseHost;
exports3.urlParseUrl = urlParseUrl;
exports3.utlCanUseLocalStorage = utlCanUseLocalStorage;
exports3.utlCanUseSessionStorage = utlCanUseSessionStorage;
exports3.utlDisableStorage = utlDisableStorage;
exports3.utlEnableStorage = utlEnableStorage;
exports3.utlGetLocalStorage = utlGetLocalStorage;
exports3.utlGetSessionStorage = utlGetSessionStorage;
exports3.utlGetSessionStorageKeys = utlGetSessionStorageKeys;
exports3.utlRemoveSessionStorage = utlRemoveSessionStorage;
exports3.utlRemoveStorage = utlRemoveStorage;
exports3.utlSetLocalStorage = utlSetLocalStorage;
exports3.utlSetSessionStorage = utlSetSessionStorage;
exports3.utlSetStoragePrefix = utlSetStoragePrefix;
}));
}
});
// node_modules/@vscode/extension-telemetry/dist/node/common/util.js
var require_util = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/common/util.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TelemetryUtil = void 0;
var TelemetryUtil = class _TelemetryUtil {
static applyReplacements(data, replacementOptions) {
for (const key of Object.keys(data)) {
for (const option of replacementOptions) {
if (option.lookup.test(key)) {
if (option.replacementString !== void 0) {
data[key] = option.replacementString;
} else {
delete data[key];
}
}
}
}
}
/**
* Given a key / connection string checks if it is a valid 1DS key
* @param key The key to check if it's a valid 1DS key
*/
static shouldUseOneDataSystemSDK(key) {
return key.length === 74 && key[32] === "-" && key[41] === "-" && key[46] === "-" && key[51] === "-" && key[56] === "-" && key[69] === "-";
}
// This also includes the common properties which core mixes in
// __GDPR__COMMON__ "common.os" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.nodeArch" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.platformversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.extname" : { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.extversion" : { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.vscodemachineid" : { "endPoint": "MacAddressHash", "classification": "EndUserPseudonymizedInformation", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.vscodesessionid" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.vscodecommithash" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.vscodeversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.uikind" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.remotename" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.isnewappinstall" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.product" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
// __GDPR__COMMON__ "common.telemetryclientversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
static getAdditionalCommonProperties(osShim) {
return {
"common.os": osShim.platform,
"common.nodeArch": osShim.architecture,
"common.platformversion": (osShim.release || "").replace(/^(\d+)(\.\d+)?(\.\d+)?(.*)/, "$1$2$3"),
// Do not change this string as it gets found and replaced upon packaging
"common.telemetryclientversion": "0.9.9"
};
}
// Get singleton instance of TelemetryUtil
static getInstance() {
if (!_TelemetryUtil._instance) {
_TelemetryUtil._instance = new _TelemetryUtil();
}
return _TelemetryUtil._instance;
}
};
exports2.TelemetryUtil = TelemetryUtil;
}
});
// node_modules/@microsoft/applicationinsights-web-basic/dist/es5/applicationinsights-web-basic.js
var require_applicationinsights_web_basic = __commonJS({
"node_modules/@microsoft/applicationinsights-web-basic/dist/es5/applicationinsights-web-basic.js"(exports2, module2) {
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory((global2.Microsoft = global2.Microsoft || {}, global2.Microsoft.ApplicationInsights = global2.Microsoft.ApplicationInsights || {})));
})(exports2, (function(exports3) {
"use strict";
// @__NO_SIDE_EFFECTS__
function _pureAssign(func1, func2) {
return func1 || func2;
}
// @__NO_SIDE_EFFECTS__
function _pureRef(value, name) {
return value[name];
}
var UNDEF_VALUE = void 0;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
var ObjClass$1 = /* @__PURE__ */ _pureAssign(Object);
var ObjProto$1 = /* @__PURE__ */ _pureRef(ObjClass$1, PROTOTYPE);
var StrCls = /* @__PURE__ */ _pureAssign(String);
var StrProto = /* @__PURE__ */ _pureRef(StrCls, PROTOTYPE);
var MathCls = /* @__PURE__ */ _pureAssign(Math);
var ArrCls = /* @__PURE__ */ _pureAssign(Array);
var ArrProto = /* @__PURE__ */ _pureRef(ArrCls, PROTOTYPE);
var ArrSlice = /* @__PURE__ */ _pureRef(ArrProto, "slice");
var POLYFILL_TAG = "_polyfill";
var POLYFILL_TYPE_NAME = "__nw21$polytype__";
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
} catch (e) {
return { e };
}
}
// @__NO_SIDE_EFFECTS__
function safeGet(cb, defValue, argArray) {
var result = safe(cb, argArray);
return result.e ? defValue : result.v;
}
var _primitiveTypes;
// @__NO_SIDE_EFFECTS__
function _createIs(theType) {
return function(value) {
return typeof value === theType;
};
}
// @__NO_SIDE_EFFECTS__
function _createObjIs(theName) {
var theType = "[object " + theName + "]";
return function(value) {
return !!(value && /* @__PURE__ */ objToString(value) === theType);
};
}
// @__NO_SIDE_EFFECTS__
function objToString(value) {
return ObjProto$1[TO_STRING].call(value);
}
// @__NO_SIDE_EFFECTS__
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
// @__NO_SIDE_EFFECTS__
function isStrictUndefined(arg) {
return arg === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isNullOrUndefined(value) {
return value === NULL_VALUE || /* @__PURE__ */ isUndefined(value);
}
// @__NO_SIDE_EFFECTS__
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function isPrimitiveType(theType) {
!_primitiveTypes && (_primitiveTypes = ["string", "number", "boolean", UNDEFINED, "symbol", "bigint"]);
return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);
}
var isString = /* @__PURE__ */ _createIs("string");
var isFunction = /* @__PURE__ */ _createIs(FUNCTION);
// @__NO_SIDE_EFFECTS__
function isObject(value) {
if (!value && /* @__PURE__ */ isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = /* @__PURE__ */ _pureRef(ArrCls, "isArray");
var isDate = /* @__PURE__ */ _createObjIs("Date");
var isNumber = /* @__PURE__ */ _createIs("number");
var isBoolean = /* @__PURE__ */ _createIs("boolean");
var isError = /* @__PURE__ */ _createObjIs("Error");
// @__NO_SIDE_EFFECTS__
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
// @__NO_SIDE_EFFECTS__
function isTruthy(value) {
return !(!value || /* @__PURE__ */ safeGet(function() {
return !(value && 0 + value);
}, !value));
}
function _returnNothing() {
return;
}
function _returnFalse() {
return false;
}
var asString = /* @__PURE__ */ _pureAssign(StrCls);
var ERROR_TYPE = "[object Error]";
// @__NO_SIDE_EFFECTS__
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto$1[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? typeof format === "number" ? format : 4 : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
} catch (e) {
propertyValueDump = " - " + /* @__PURE__ */ dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwError(message) {
throw new Error(message);
}
function throwTypeError(message) {
throw new TypeError(message);
}
function _throwIfNullOrUndefined(obj) {
if (/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + /* @__PURE__ */ dumpObj(value) + "' is not a string");
}
}
// @__NO_SIDE_EFFECTS__
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto$1.hasOwnProperty[CALL](obj, prop);
}
var _objGetOwnPropertyDescriptor$2 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var objHasOwn = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "hasOwn"), polyObjHasOwn);
// @__NO_SIDE_EFFECTS__
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return /* @__PURE__ */ objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (/* @__PURE__ */ isObject(theObject) || isFunction(theObject))) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var _unwrapFunction = _unwrapFunctionWithPoly;
// @__NO_SIDE_EFFECTS__
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function(thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError('"' + asString(funcName) + '" not defined for ' + /* @__PURE__ */ dumpObj(thisArg));
};
}
// @__NO_SIDE_EFFECTS__
function _unwrapProp(propName) {
return function(thisArg) {
return thisArg[propName];
};
}
var _objGetOwnPropertyDescriptor$1 = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
// @__NO_SIDE_EFFECTS__
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function() {
return value.l.v;
};
var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = function(newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function(key, value2) {
prop[propMap[key]] = /* @__PURE__ */ isStrictUndefined(value2) ? prop[propMap[key]] : value2;
});
return prop;
}
var objDefineProp = /* @__PURE__ */ _pureRef(ObjClass$1, "defineProperty");
var objDefineProperties = /* @__PURE__ */ _pureRef(ObjClass$1, "defineProperties");
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, /* @__PURE__ */ _createProp(propDesc));
}
// @__NO_SIDE_EFFECTS__
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function(key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value,
enumerable: true,
writable: false
});
}
var objIsFrozen = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "isFrozen"), _returnFalse);
var _objFreeze = /* @__PURE__ */ _pureRef(ObjClass$1, "freeze");
function _doNothing(value) {
return value;
}
// @__NO_SIDE_EFFECTS__
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = /* @__PURE__ */ _pureRef(ObjClass$1, "assign");
var objKeys = /* @__PURE__ */ _pureRef(ObjClass$1, "keys");
function _deepFreeze(val, visited) {
if ((isArray(val) || /* @__PURE__ */ isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
for (var lp = 0; lp < visited.length; lp++) {
if (visited[lp] === val) {
return val;
}
}
visited.push(val);
objForEachKey(val, function(_key, propValue) {
_deepFreeze(propValue, visited);
});
objFreeze(val);
}
return val;
}
function objDeepFreeze(value) {
return _objFreeze ? _deepFreeze(value, []) : value;
}
var objFreeze = /* @__PURE__ */ _pureAssign(_objFreeze, _doNothing);
var objGetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "getPrototypeOf"), _getProto);
// @__NO_SIDE_EFFECTS__
function createEnum(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 1, 0, objFreeze);
}
// @__NO_SIDE_EFFECTS__
function createEnumKeyMap(values) {
return /* @__PURE__ */ _createKeyValueMap(values, 0, 0, objFreeze);
}
// @__NO_SIDE_EFFECTS__
function createSimpleMap(values) {
var mapClass = {};
objForEachKey(values, function(key, value) {
_assignMapValue(mapClass, key, value[1]);
_assignMapValue(mapClass, value[0], value[1]);
});
return objFreeze(mapClass);
}
// @__NO_SIDE_EFFECTS__
function createTypeMap(values) {
return /* @__PURE__ */ createSimpleMap(values);
}
var _wellKnownSymbolMap = /* @__PURE__ */ createEnumKeyMap({
asyncIterator: 0,
hasInstance: 1,
isConcatSpreadable: 2,
iterator: 3,
match: 4,
matchAll: 5,
replace: 6,
search: 7,
species: 8,
split: 9,
toPrimitive: 10,
toStringTag: 11,
unscopables: 12
});
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
// @__NO_SIDE_EFFECTS__
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var mathMin = /* @__PURE__ */ _pureRef(MathCls, "min");
var mathMax = /* @__PURE__ */ _pureRef(MathCls, "max");
var strSlice = /* @__PURE__ */ _unwrapFunction("slice", StrProto);
var strSubstring = /* @__PURE__ */ _unwrapFunction("substring", StrProto);
var strSubstr = /* @__PURE__ */ _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
// @__NO_SIDE_EFFECTS__
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(value);
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (/* @__PURE__ */ isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
// @__NO_SIDE_EFFECTS__
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(function() {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
var objCreate = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "create"), polyObjCreate);
// @__NO_SIDE_EFFECTS__
function polyObjCreate(obj, properties) {
var newObj = null;
function tempFunc() {
}
if (!/* @__PURE__ */ isStrictNullOrUndefined(obj)) {
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + /* @__PURE__ */ dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(function() {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
} else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
// @__NO_SIDE_EFFECTS__
function utcNow() {
return (Date.now || polyUtcNow)();
}
// @__NO_SIDE_EFFECTS__
function polyUtcNow() {
return (/* @__PURE__ */ new Date()).getTime();
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = /* @__PURE__ */ _getGlobalConfig();
}
// @__NO_SIDE_EFFECTS__
function getLazy(cb, argArray) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function() {
var result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
var mathRandom = /* @__PURE__ */ _pureRef(MathCls, "random");
var _uniqueInstanceId = /* @__PURE__ */ getLazy(function() {
var value = (/* @__PURE__ */ utcNow()).toString(36).slice(2);
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
});
var UNIQUE_REGISTRY_ID = "_urid";
var POLY_SYM = "$nw21sym";
var _polySymbols;
var _polyId = 0;
// @__NO_SIDE_EFFECTS__
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = /* @__PURE__ */ _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
var _wellKnownSymbolCache;
// @__NO_SIDE_EFFECTS__
function polyNewSymbol(description) {
var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
var symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
var theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, function() {
return symString + POLY_SYM + uniqueId;
});
_setProp("valueOf", function() {
return theSymbol;
});
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
// @__NO_SIDE_EFFECTS__
function polySymbolFor(key) {
var registry = /* @__PURE__ */ _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = /* @__PURE__ */ polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function() {
return regId_1 + "_" + newSymbol_1[TO_STRING]();
};
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
// @__NO_SIDE_EFFECTS__
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
var result;
var knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || /* @__PURE__ */ polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
// @__NO_SIDE_EFFECTS__
function createCachedValue(value) {
return objDefineProp({
toJSON: function() {
return value;
}
}, "v", { value });
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function() {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = /* @__PURE__ */ createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = /* @__PURE__ */ createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
// @__NO_SIDE_EFFECTS__
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
} else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
} catch (e) {
}
}
return NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function hasDocument() {
return !!/* @__PURE__ */ getDocument();
}
var getDocument = /* @__PURE__ */ _getGlobalInstFn(getInst, ["document"]);
// @__NO_SIDE_EFFECTS__
function hasWindow() {
return !!/* @__PURE__ */ getWindow();
}
var getWindow = /* @__PURE__ */ _getGlobalInstFn(getInst, [WINDOW]);
// @__NO_SIDE_EFFECTS__
function hasNavigator() {
return !!/* @__PURE__ */ getNavigator();
}
var getNavigator = /* @__PURE__ */ _getGlobalInstFn(getInst, ["navigator"]);
var isNode = /* @__PURE__ */ _getGlobalInstFn(function() {
return !!safe(function() {
return process && (process.versions || {}).node;
}).v;
});
var _symbol;
var _symbolFor;
// @__NO_SIDE_EFFECTS__
function _initSymbol() {
_symbol = /* @__PURE__ */ createCachedValue(safe(getInst, [SYMBOL]).v);
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return gblSym.v ? gblSym.v[key] : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function hasSymbol() {
return !!/* @__PURE__ */ getSymbol();
}
// @__NO_SIDE_EFFECTS__
function getSymbol() {
!_globalLazyTestHooks && _initTestHooks();
return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol()).v;
}
// @__NO_SIDE_EFFECTS__
function getKnownSymbol(name, noPoly) {
var knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v[knownName || name] : !noPoly ? /* @__PURE__ */ polyGetKnownSymbol(name) : UNDEF_VALUE;
}
// @__NO_SIDE_EFFECTS__
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = (!_globalLazyTestHooks.lzy ? _symbol : 0) || /* @__PURE__ */ _initSymbol();
return sym.v ? sym.v(description) : !noPoly ? /* @__PURE__ */ polyNewSymbol(description) : NULL_VALUE;
}
// @__NO_SIDE_EFFECTS__
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = (!_globalLazyTestHooks.lzy ? _symbolFor : 0) || /* @__PURE__ */ createCachedValue(safe(_getSymbolKey, ["for"]).v);
return (_symbolFor.v || polySymbolFor)(key);
}
// @__NO_SIDE_EFFECTS__
function isIterator(value) {
return !!value && isFunction(value.next);
}
// @__NO_SIDE_EFFECTS__
function isIterable(value) {
return !/* @__PURE__ */ isStrictNullOrUndefined(value) && isFunction(value[/* @__PURE__ */ getKnownSymbol(3)]);
}
var _iterSymbol$1;
function iterForOf(iter, callbackfn, thisArg) {
if (iter) {
if (!/* @__PURE__ */ isIterator(iter)) {
!_iterSymbol$1 && (_iterSymbol$1 = /* @__PURE__ */ createCachedValue(/* @__PURE__ */ getKnownSymbol(3)));
iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
}
if (/* @__PURE__ */ isIterator(iter)) {
var err = UNDEF_VALUE;
var iterResult = UNDEF_VALUE;
try {
var count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
break;
}
count++;
}
} catch (failed) {
err = { e: failed };
if (iter.throw) {
iterResult = NULL_VALUE;
iter.throw(err);
}
} finally {
try {
if (iterResult && !iterResult.done) {
iter.return && iter.return(iterResult);
}
} finally {
if (err) {
throw err.e;
}
}
}
}
}
}
function arrAppend(target, elms) {
if (!/* @__PURE__ */ isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
} else if (/* @__PURE__ */ isIterator(elms) || /* @__PURE__ */ isIterable(elms)) {
iterForOf(elms, function(elm) {
target.push(elm);
});
} else {
target.push(elms);
}
}
return target;
}
var arrIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", ArrProto);
var arrMap = /* @__PURE__ */ _unwrapFunction("map", ArrProto);
function arrSlice(theArray, start, end) {
return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
}
var arrReduce = /* @__PURE__ */ _unwrapFunction("reduce", ArrProto);
var _isProtoArray;
var objSetPrototypeOf = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, "setPrototypeOf"), _polyObjSetPrototypeOf);
function _polyObjSetPrototypeOf(obj, proto) {
var _a2;
!_isProtoArray && (_isProtoArray = /* @__PURE__ */ createCachedValue((_a2 = {}, _a2[__PROTO__] = [], _a2) instanceof Array));
_isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function(key, value) {
return obj[key] = value;
});
return obj;
}
// @__NO_SIDE_EFFECTS__
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
// @__NO_SIDE_EFFECTS__
function createCustomError(name, constructCb, errorBase) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return /* @__PURE__ */ _createCustomError(name, function() {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
} finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
// @__NO_SIDE_EFFECTS__
function _createTrimFn(exp) {
return function _doTrim(value) {
_throwIfNullOrUndefined(value);
if (value && value.replace) {
value = value.replace(exp, EMPTY);
}
return value;
};
}
var polyStrTrim = /* @__PURE__ */ _createTrimFn(/^\s+|(?=\s)\s+$/g);
var strTrim = /* @__PURE__ */ _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
var mathFloor = /* @__PURE__ */ _pureRef(MathCls, "floor");
var _fnToString;
var _objCtrFnString;
var _gblWindow;
// @__NO_SIDE_EFFECTS__
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = /* @__PURE__ */ hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass$1);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (/* @__PURE__ */ objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
} catch (ex) {
}
}
return result;
}
// @__NO_SIDE_EFFECTS__
function _defaultDeepCopyHandler(details) {
details.value && plainObjDeepCopyHandler(details);
return true;
}
var defaultDeepCopyHandlers = [
arrayDeepCopyHandler,
plainObjDeepCopyHandler,
functionDeepCopyHandler,
dateDeepCopyHandler
];
// @__NO_SIDE_EFFECTS__
function _getSetVisited(visitMap, source, newPath, cb) {
var theEntry;
arrForEach(visitMap, function(entry) {
if (entry.k === source) {
theEntry = entry;
return -1;
}
});
if (!theEntry) {
theEntry = { k: source, v: source };
visitMap.push(theEntry);
cb(theEntry);
}
return theEntry.v;
}
function _deepCopy(visitMap, value, ctx, key) {
var userHandler = ctx.handler;
var newPath = ctx.path ? key ? ctx.path.concat(key) : ctx.path : [];
var newCtx = {
handler: ctx.handler,
src: ctx.src,
path: newPath
};
var theType = typeof value;
var isPlain = false;
var isPrim = value === NULL_VALUE;
if (!isPrim) {
if (value && theType === OBJECT) {
isPlain = /* @__PURE__ */ isPlainObject(value);
} else {
isPrim = /* @__PURE__ */ isPrimitiveType(theType);
}
}
var details = {
type: theType,
isPrim,
isPlain,
value,
result: value,
path: newPath,
origin: ctx.src,
copy: function(source, newKey) {
return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
},
copyTo: function(target, source) {
return _copyProps(visitMap, target, source, newCtx);
}
};
if (!details.isPrim) {
return /* @__PURE__ */ _getSetVisited(visitMap, value, newPath, function(newEntry) {
objDefine(details, "result", {
g: function() {
return newEntry.v;
},
s: function(newValue) {
newEntry.v = newValue;
}
});
var idx = 0;
var handler = userHandler;
while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler))[CALL](ctx, details)) {
handler = NULL_VALUE;
}
});
}
if (userHandler && userHandler[CALL](ctx, details)) {
return details.result;
}
return value;
}
function _copyProps(visitMap, target, source, ctx) {
if (!/* @__PURE__ */ isNullOrUndefined(source)) {
for (var key in source) {
target[key] = _deepCopy(visitMap, source[key], ctx, key);
}
}
return target;
}
function objCopyProps(target, source, handler) {
var ctx = {
handler,
src: source,
path: []
};
return _copyProps([], target, source, ctx);
}
// @__NO_SIDE_EFFECTS__
function objDeepCopy(source, handler) {
var ctx = {
handler,
src: source
};
return _deepCopy([], source, ctx);
}
function arrayDeepCopyHandler(details) {
var value = details.value;
if (isArray(value)) {
var target = details.result = [];
target.length = value.length;
details.copyTo(target, value);
return true;
}
return false;
}
function dateDeepCopyHandler(details) {
var value = details.value;
if (isDate(value)) {
details.result = new Date(value.getTime());
return true;
}
return false;
}
function functionDeepCopyHandler(details) {
if (details.type === FUNCTION) {
return true;
}
return false;
}
function plainObjDeepCopyHandler(details) {
var value = details.value;
if (value && details.isPlain) {
var target = details.result = {};
details.copyTo(target, value);
return true;
}
return false;
}
function _doExtend(target, theArgs) {
arrForEach(theArgs, function(theArg) {
objCopyProps(target, theArg);
});
return target;
}
function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
return _doExtend(/* @__PURE__ */ objDeepCopy(target) || {}, ArrSlice[CALL](arguments));
}
var getLength = /* @__PURE__ */ _unwrapProp(LENGTH);
var mathRound = /* @__PURE__ */ _pureRef(MathCls, "round");
var objGetOwnPropertyDescriptor = /* @__PURE__ */ _pureAssign(/* @__PURE__ */ _pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR), _returnNothing);
var strEndsWith = /* @__PURE__ */ _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith);
// @__NO_SIDE_EFFECTS__
function polyStrEndsWith(value, searchString, length) {
_throwIfNotString(value);
var searchValue = isString(searchString) ? searchString : asString(searchString);
var end = !/* @__PURE__ */ isUndefined(length) && length < value[LENGTH] ? length : value[LENGTH];
return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
}
var strIndexOf = /* @__PURE__ */ _unwrapFunction("indexOf", StrProto);
var REF = "ref";
var UNREF = "unref";
var HAS_REF = "hasRef";
var ENABLED = "enabled";
// @__NO_SIDE_EFFECTS__
function _createTimerHandler(startTimer, refreshFn, cancelFn) {
var ref = true;
var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
var theTimerHandler;
function _unref() {
ref = false;
timerId && timerId[UNREF] && timerId[UNREF]();
return theTimerHandler;
}
function _cancel() {
timerId && cancelFn(timerId);
timerId = NULL_VALUE;
}
function _refresh() {
timerId = refreshFn(timerId);
if (!ref) {
_unref();
}
return theTimerHandler;
}
function _setEnabled(value) {
!value && timerId && _cancel();
value && !timerId && _refresh();
}
theTimerHandler = {
cancel: _cancel,
refresh: _refresh
};
theTimerHandler[HAS_REF] = function() {
if (timerId && timerId[HAS_REF]) {
return timerId[HAS_REF]();
}
return ref;
};
theTimerHandler[REF] = function() {
ref = true;
timerId && timerId[REF] && timerId[REF]();
return theTimerHandler;
};
theTimerHandler[UNREF] = _unref;
theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
get: function() {
return !!timerId;
},
set: _setEnabled
});
return {
h: theTimerHandler,
dn: function() {
timerId = NULL_VALUE;
}
};
}
var _setTimeoutFn;
var _clearTimeoutFn;
function _resolveTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
result = globalOverrides[0];
}
}
return result || setTimeout;
}
function _resolveClearTimeoutFn(timeoutFn) {
var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
if (!result) {
var globalOverrides = (/* @__PURE__ */ _getGlobalConfig()).tmOut || [];
if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
result = globalOverrides[1];
}
}
return result || clearTimeout;
}
function _createTimeoutWith(startTimer, overrideFn, theArgs) {
var isArr = isArray(overrideFn);
var len = isArr ? overrideFn.length : 0;
var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : !isArr ? overrideFn : UNDEF_VALUE);
var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
var timerFn = theArgs[0];
theArgs[0] = function() {
handler.dn();
fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
};
var handler = /* @__PURE__ */ _createTimerHandler(startTimer, function(timerId) {
if (timerId) {
if (timerId.refresh) {
timerId.refresh();
return timerId;
}
fnApply(clearFn, UNDEF_VALUE, [timerId]);
}
return fnApply(setFn, UNDEF_VALUE, theArgs);
}, function(timerId) {
fnApply(clearFn, UNDEF_VALUE, [timerId]);
});
return handler.h;
}
function scheduleTimeout(callback, timeout) {
return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
function createTimeout(callback, timeout) {
return _createTimeoutWith(false, UNDEF_VALUE, ArrSlice[CALL](arguments));
}
var _a$6;
var Constructor = "constructor";
var Prototype = "prototype";
var strFunction = "function";
var DynInstFuncTable = "_dynInstFuncs";
var DynProxyTag = "_isDynProxy";
var DynClassName = "_dynClass";
var DynClassNamePrefix = "_dynCls$";
var DynInstChkTag = "_dynInstChk";
var DynAllowInstChkTag = DynInstChkTag;
var DynProtoDefaultOptions = "_dfOpts";
var UnknownValue = "_unknown_";
var str__Proto = "__proto__";
var DynProtoBaseProto = "_dyn" + str__Proto;
var DynProtoGlobalSettings = "__dynProto$Gbl";
var DynProtoCurrent = "_dynInstProto";
var strUseBaseInst = "useBaseInst";
var strSetInstFuncs = "setInstFuncs";
var Obj = Object;
var _objGetPrototypeOf = Obj["getPrototypeOf"];
var _objGetOwnProps = Obj["getOwnPropertyNames"];
var _gbl = getGlobal();
var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
o: (_a$6 = {}, _a$6[strSetInstFuncs] = true, _a$6[strUseBaseInst] = true, _a$6),
n: 1e3
});
function _isObjectOrArrayPrototype(target) {
return target && (target === Obj[Prototype] || target === Array[Prototype]);
}
function _isObjectArrayOrFunctionPrototype(target) {
return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
}
function _getObjProto(target) {
var newProto;
if (target) {
if (_objGetPrototypeOf) {
return _objGetPrototypeOf(target);
}
var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
newProto = target[DynProtoBaseProto] || curProto;
if (!/* @__PURE__ */ objHasOwnProperty(target, DynProtoBaseProto)) {
delete target[DynProtoCurrent];
newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
target[DynProtoCurrent] = curProto;
}
}
return newProto;
}
function _forEachProp(target, func) {
var props = [];
if (_objGetOwnProps) {
props = _objGetOwnProps(target);
} else {
for (var name_1 in target) {
if (typeof name_1 === "string" && /* @__PURE__ */ objHasOwnProperty(target, name_1)) {
props.push(name_1);
}
}
}
if (props && props.length > 0) {
for (var lp = 0; lp < props.length; lp++) {
func(props[lp]);
}
}
}
function _isDynamicCandidate(target, funcName, skipOwn) {
return funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || /* @__PURE__ */ objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype;
}
function _throwTypeError(message) {
throwTypeError("DynamicProto: " + message);
}
function _getInstanceFuncs(thisTarget) {
var instFuncs = objCreate(null);
_forEachProp(thisTarget, function(name) {
if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
instFuncs[name] = thisTarget[name];
}
});
return instFuncs;
}
function _hasVisited(values, value) {
for (var lp = values.length - 1; lp >= 0; lp--) {
if (values[lp] === value) {
return true;
}
}
return false;
}
function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
function _instFuncProxy(target, funcHost, funcName) {
var theFunc = funcHost[funcName];
if (theFunc[DynProxyTag] && useBaseInst) {
var instFuncTable = target[DynInstFuncTable] || {};
if (instFuncTable[DynAllowInstChkTag] !== false) {
theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
}
}
return function() {
return theFunc.apply(target, arguments);
};
}
var baseFuncs = objCreate(null);
_forEachProp(instFuncs, function(name) {
baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
});
var baseProto = _getObjProto(classProto);
var visited = [];
while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
_forEachProp(baseProto, function(name) {
if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
}
});
visited.push(baseProto);
baseProto = _getObjProto(baseProto);
}
return baseFuncs;
}
function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
var instFunc = null;
if (target && /* @__PURE__ */ objHasOwnProperty(proto, DynClassName)) {
var instFuncTable = target[DynInstFuncTable] || objCreate(null);
instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
if (!instFunc) {
_throwTypeError("Missing [" + funcName + "] " + strFunction);
}
if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
var canAddInst = !/* @__PURE__ */ objHasOwnProperty(target, funcName);
var objProto = _getObjProto(target);
var visited = [];
while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
var protoFunc = objProto[funcName];
if (protoFunc) {
canAddInst = protoFunc === currentDynProtoProxy;
break;
}
visited.push(objProto);
objProto = _getObjProto(objProto);
}
try {
if (canAddInst) {
target[funcName] = instFunc;
}
instFunc[DynInstChkTag] = 1;
} catch (e) {
instFuncTable[DynAllowInstChkTag] = false;
}
}
}
return instFunc;
}
function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
var protoFunc = proto[funcName];
if (protoFunc === currentDynProtoProxy) {
protoFunc = _getObjProto(proto)[funcName];
}
if (typeof protoFunc !== strFunction) {
_throwTypeError("[" + funcName + "] is not a " + strFunction);
}
return protoFunc;
}
function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
function _createDynamicPrototype(proto2, funcName) {
var dynProtoProxy = function() {
var instFunc = _getInstFunc(this, funcName, proto2, dynProtoProxy) || _getProtoFunc(funcName, proto2, dynProtoProxy);
return instFunc.apply(this, arguments);
};
dynProtoProxy[DynProxyTag] = 1;
return dynProtoProxy;
}
if (!_isObjectOrArrayPrototype(proto)) {
var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
if (!_isObjectOrArrayPrototype(instFuncTable)) {
var instFuncs_1 = instFuncTable[className] = instFuncTable[className] || objCreate(null);
if (instFuncTable[DynAllowInstChkTag] !== false) {
instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
}
if (!_isObjectOrArrayPrototype(instFuncs_1)) {
_forEachProp(target, function(name) {
if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
instFuncs_1[name] = target[name];
delete target[name];
if (!/* @__PURE__ */ objHasOwnProperty(proto, name) || proto[name] && !proto[name][DynProxyTag]) {
proto[name] = _createDynamicPrototype(proto, name);
}
}
});
}
}
}
}
function _checkPrototype(classProto, thisTarget) {
if (_objGetPrototypeOf) {
var visited = [];
var thisProto = _getObjProto(thisTarget);
while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
if (thisProto === classProto) {
return true;
}
visited.push(thisProto);
thisProto = _getObjProto(thisProto);
}
return false;
}
return true;
}
function _getObjName(target, unknownValue) {
if (/* @__PURE__ */ objHasOwnProperty(target, Prototype)) {
return target.name || unknownValue || UnknownValue;
}
return ((target || {})[Constructor] || {}).name || unknownValue || UnknownValue;
}
function dynamicProto(theClass, target, delegateFunc, options) {
if (!/* @__PURE__ */ objHasOwnProperty(theClass, Prototype)) {
_throwTypeError("theClass is an invalid class definition.");
}
var classProto = theClass[Prototype];
if (!_checkPrototype(classProto, target)) {
_throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
}
var className = null;
if (/* @__PURE__ */ objHasOwnProperty(classProto, DynClassName)) {
className = classProto[DynClassName];
} else {
className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
_gblInst.n++;
classProto[DynClassName] = className;
}
var perfOptions = dynamicProto[DynProtoDefaultOptions];
var useBaseInst = !!perfOptions[strUseBaseInst];
if (useBaseInst && options && options[strUseBaseInst] !== void 0) {
useBaseInst = !!options[strUseBaseInst];
}
var instFuncs = _getInstanceFuncs(target);
var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
delegateFunc(target, baseFuncs);
var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
if (setInstanceFunc && options) {
setInstanceFunc = !!options[strSetInstFuncs];
}
_populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
}
dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
var strShimFunction = "function";
var strShimObject = "object";
var strShimUndefined = "undefined";
var strShimPrototype = "prototype";
var ObjClass = Object;
var ObjProto = ObjClass[strShimPrototype];
(getGlobal() || {})["Symbol"];
(getGlobal() || {})["Reflect"];
var strHasOwnProperty = "hasOwnProperty";
var __objAssignFnImpl = function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) {
if (ObjProto[strHasOwnProperty].call(s, p)) {
t[p] = s[p];
}
}
}
return t;
};
var __assignFn = objAssign || __objAssignFnImpl;
var extendStaticsFn = function(d, b) {
extendStaticsFn = ObjClass["setPrototypeOf"] || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) {
if (b2[strHasOwnProperty](p)) {
d2[p] = b2[p];
}
}
};
return extendStaticsFn(d, b);
};
function __extendsFn(d, b) {
if (typeof b !== strShimFunction && b !== null) {
throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
}
extendStaticsFn(d, b);
function __() {
this.constructor = d;
}
d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
}
function __spreadArrayFn(to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {
to[j] = from[i];
}
return to;
}
var createEnumStyle = createEnum;
var createValueMap = createTypeMap;
var ActiveStatus = /* @__PURE__ */ createEnumStyle({
NONE: 0,
PENDING: 3,
INACTIVE: 1,
ACTIVE: 2
});
var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
var _DYN_LENGTH$2 = "length";
var _DYN_WARN_TO_CONSOLE = "warnToConsole";
var _DYN_THROW_INTERNAL = "throwInternal";
var _DYN_WATCH = "watch";
var _DYN_APPLY = "apply";
var _DYN_PUSH$1 = "push";
var _DYN_SPLICE = "splice";
var _DYN_LOGGER = "logger";
var _DYN_CANCEL = "cancel";
var _DYN_INITIALIZE$1 = "initialize";
var _DYN_IDENTIFIER = "identifier";
var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
var _DYN_IS_INITIALIZED = "isInitialized";
var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
var _DYN_GET_PLUGIN = "getPlugin";
var _DYN_NAME$2 = "name";
var _DYN_PROCESS_NEXT = "processNext";
var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
var _DYN_VALUE = "value";
var _DYN_ENABLED = "enabled";
var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
var _DYN_UNLOAD = "unload";
var _DYN_ON_COMPLETE = "onComplete";
var _DYN_VERSION = "version";
var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
var _DYN_CREATE_NEW = "createNew";
var _DYN_TEARDOWN = "teardown";
var _DYN_MESSAGE_ID = "messageId";
var _DYN_MESSAGE$1 = "message";
var _DYN_DIAG_LOG$1 = "diagLog";
var _DYN__DO_TEARDOWN = "_doTeardown";
var _DYN_UPDATE = "update";
var _DYN_GET_NEXT = "getNext";
var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
var _DYN_USER_AGENT = "userAgent";
var _DYN_SPLIT$1 = "split";
var _DYN_REPLACE = "replace";
var _DYN_SUBSTRING = "substring";
var _DYN_INDEX_OF = "indexOf";
var _DYN_TYPE = "type";
var _DYN_EVT_NAME = "evtName";
var _DYN_STATUS = "status";
var _DYN_GET_ALL_RESPONSE_HEA5 = "getAllResponseHeaders";
var _DYN_IS_CHILD_EVT = "isChildEvt";
var _DYN_DATA$1 = "data";
var _DYN_GET_CTX = "getCtx";
var _DYN_SET_CTX = "setCtx";
var _DYN_ITEMS_RECEIVED$1 = "itemsReceived";
var _DYN_HEADERS = "headers";
var _DYN_URL_STRING = "urlString";
var _DYN_TIMEOUT = "timeout";
var _DYN_TRACE_FLAGS = "traceFlags";
var aggregationErrorType;
function throwAggregationError(message, sourceErrors) {
if (!aggregationErrorType) {
aggregationErrorType = /* @__PURE__ */ createCustomError("AggregationError", function(self2, args) {
if (args[_DYN_LENGTH$2] > 1) {
self2.errors = args[1];
}
});
}
var theMessage = message || "One or more errors occurred.";
arrForEach(sourceErrors, function(srcError, idx) {
theMessage += "\n".concat(idx, " > ").concat(/* @__PURE__ */ dumpObj(srcError));
});
throw new aggregationErrorType(theMessage, sourceErrors || []);
}
var STR_PROMISE = "Promise";
var REJECTED = "rejected";
function doAwaitResponse(value, cb) {
return doAwait(value, function(value2) {
return cb ? cb({
status: "fulfilled",
rejected: false,
value: value2
}) : value2;
}, function(reason) {
return cb ? cb({
status: REJECTED,
rejected: true,
reason
}) : reason;
});
}
function doAwait(value, resolveFn, rejectFn, finallyFn) {
var result = value;
try {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (resolveFn || rejectFn) {
result = value.then(resolveFn, rejectFn);
}
} else {
try {
if (resolveFn) {
result = resolveFn(value);
}
} catch (err) {
if (rejectFn) {
result = rejectFn(err);
} else {
throw err;
}
}
}
} finally {
if (finallyFn) {
doFinally(result, finallyFn);
}
}
return result;
}
function doFinally(value, finallyFn) {
var result = value;
if (finallyFn) {
if (/* @__PURE__ */ isPromiseLike(value)) {
if (value.finally) {
result = value.finally(finallyFn);
} else {
result = value.then(function(value2) {
finallyFn();
return value2;
}, function(reason) {
finallyFn();
throw reason;
});
}
} else {
finallyFn();
}
}
return result;
}
var STRING_STATES = [
"pending",
"resolving",
"resolved",
REJECTED
];
var DISPATCH_EVENT = "dispatchEvent";
var _hasInitEvent;
function _hasInitEventFn(doc) {
var evt;
if (doc && doc.createEvent) {
evt = doc.createEvent("Event");
}
return !!evt && evt.initEvent;
}
function emitEvent(target, evtName, populateEvent, useNewEvent) {
var doc = getDocument();
!_hasInitEvent && (_hasInitEvent = /* @__PURE__ */ createCachedValue(!!safe(_hasInitEventFn, [doc]).v));
var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : useNewEvent ? new Event(evtName) : {};
populateEvent && populateEvent(theEvt);
if (_hasInitEvent.v) {
theEvt.initEvent(evtName, false, true);
}
if (theEvt && target[DISPATCH_EVENT]) {
target[DISPATCH_EVENT](theEvt);
} else {
var handler = target["on" + evtName];
if (handler) {
handler(theEvt);
} else {
var theConsole = /* @__PURE__ */ getInst("console");
theConsole && (theConsole["error"] || theConsole["log"])(evtName, /* @__PURE__ */ dumpObj(theEvt));
}
}
}
var NODE_UNHANDLED_REJECTION = "unhandledRejection";
var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
var _unhandledRejectionTimeout = 10;
var _hasPromiseRejectionEvent;
function dumpFnObj(value) {
if (isFunction(value)) {
return value.toString();
}
return /* @__PURE__ */ dumpObj(value);
}
function _createPromise(newPromise, processor, executor) {
var additionalArgs = arrSlice(arguments, 3);
var _state = 0;
var _hasResolved = false;
var _settledValue;
var _queue = [];
var _handled = false;
var _unHandledRejectionHandler = null;
var _thePromise;
function _then(onResolved, onRejected) {
try {
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
var thenPromise = newPromise(function(resolve3, reject) {
_queue.push(function() {
try {
var handler = _state === 2 ? onResolved : onRejected;
var value = /* @__PURE__ */ isUndefined(handler) ? _settledValue : isFunction(handler) ? handler(_settledValue) : handler;
if (/* @__PURE__ */ isPromiseLike(value)) {
value.then(resolve3, reject);
} else if (handler) {
resolve3(value);
} else if (_state === 3) {
reject(value);
} else {
resolve3(value);
}
} catch (e) {
reject(e);
}
});
if (_hasResolved) {
_processQueue();
}
}, additionalArgs);
return thenPromise;
} finally {
}
}
function _catch(onRejected) {
return _then(void 0, onRejected);
}
function _finally(onFinally) {
var thenFinally = onFinally;
var catchFinally = onFinally;
if (isFunction(onFinally)) {
thenFinally = function(value) {
onFinally && onFinally();
return value;
};
catchFinally = function(reason) {
onFinally && onFinally();
throw reason;
};
}
return _then(thenFinally, catchFinally);
}
function _strState() {
return STRING_STATES[_state];
}
function _processQueue() {
if (_queue.length > 0) {
var pending = _queue.slice();
_queue = [];
_handled = true;
_unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
_unHandledRejectionHandler = null;
processor(pending);
}
}
function _createSettleIfFn(newState, allowState) {
return function(theValue) {
if (_state === allowState) {
if (newState === 2 && /* @__PURE__ */ isPromiseLike(theValue)) {
_state = 1;
theValue.then(_createSettleIfFn(2, 1), _createSettleIfFn(3, 1));
return;
}
_state = newState;
_hasResolved = true;
_settledValue = theValue;
_processQueue();
if (!_handled && newState === 3 && !_unHandledRejectionHandler) {
_unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
}
}
};
}
function _notifyUnhandledRejection() {
if (!_handled) {
_handled = true;
if (isNode()) {
process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
} else {
var gbl = getWindow() || getGlobal();
!_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE + "RejectionEvent"]).v));
emitEvent(gbl, UNHANDLED_REJECTION, function(theEvt) {
objDefine(theEvt, "promise", { g: function() {
return _thePromise;
} });
theEvt.reason = _settledValue;
return theEvt;
}, !!_hasPromiseRejectionEvent.v);
}
}
}
_thePromise = {
then: _then,
"catch": _catch,
finally: _finally
};
objDefineProp(_thePromise, "state", {
get: _strState
});
if (/* @__PURE__ */ hasSymbol()) {
_thePromise[/* @__PURE__ */ getKnownSymbol(11)] = "IPromise";
}
function _toString() {
return "IPromise " + _strState() + (_hasResolved ? " - " + dumpFnObj(_settledValue) : "");
}
_thePromise.toString = _toString;
(function _initialize() {
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
}
var _rejectFn = _createSettleIfFn(3, 0);
try {
executor.call(_thePromise, _createSettleIfFn(2, 0), _rejectFn);
} catch (e) {
_rejectFn(e);
}
})();
return _thePromise;
}
// @__NO_SIDE_EFFECTS__
function _createAllPromise(newPromise) {
return function(input) {
var additionalArgs = arrSlice(arguments, 1);
return newPromise(function(resolve3, reject) {
try {
var values_1 = [];
var pending_1 = 1;
iterForOf(input, function(item, idx) {
if (item) {
pending_1++;
doAwait(item, function(value) {
values_1[idx] = value;
if (--pending_1 === 0) {
resolve3(values_1);
}
}, reject);
}
});
pending_1--;
if (pending_1 === 0) {
resolve3(values_1);
}
} catch (e) {
reject(e);
}
}, additionalArgs);
};
}
// @__NO_SIDE_EFFECTS__
function _createAllSettledPromise(newPromise) {
return /* @__PURE__ */ createCachedValue(function(input) {
var additionalArgs = arrSlice(arguments, 1);
return newPromise(function(resolve3, reject) {
var values = [];
var pending = 1;
function processItem(item, idx) {
pending++;
doAwaitResponse(item, function(value) {
if (value.rejected) {
values[idx] = {
status: REJECTED,
reason: value.reason
};
} else {
values[idx] = {
status: "fulfilled",
value: value.value
};
}
if (--pending === 0) {
resolve3(values);
}
});
}
try {
if (isArray(input)) {
arrForEach(input, processItem);
} else if (/* @__PURE__ */ isIterable(input)) {
iterForOf(input, processItem);
} else {
throwTypeError("Input is not an iterable");
}
pending--;
if (pending === 0) {
resolve3(values);
}
} catch (e) {
reject(e);
}
}, additionalArgs);
});
}
function syncItemProcessor(pending) {
arrForEach(pending, function(fn) {
try {
fn();
} catch (e) {
}
});
}
function timeoutItemProcessor(timeout) {
var callbackTimeout = isNumber(timeout) ? timeout : 0;
return function(pending) {
scheduleTimeout(function() {
syncItemProcessor(pending);
}, callbackTimeout);
};
}
function createAsyncPromise(executor, timeout) {
return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
}
var _promiseCls;
function createNativePromise(executor, timeout) {
!_promiseCls && (_promiseCls = /* @__PURE__ */ createCachedValue(safe(getInst, [STR_PROMISE]).v || null));
var PrmCls = _promiseCls.v;
if (!PrmCls) {
return createAsyncPromise(executor);
}
if (!isFunction(executor)) {
throwTypeError(STR_PROMISE + ": executor is not a function - " + /* @__PURE__ */ dumpObj(executor));
}
var _state = 0;
function _strState() {
return STRING_STATES[_state];
}
var thePromise = new PrmCls(function(resolve3, reject) {
function _resolve(value) {
_state = 2;
resolve3(value);
}
function _reject(reason) {
_state = 3;
reject(reason);
}
executor(_resolve, _reject);
});
objDefineProp(thePromise, "state", {
get: _strState
});
return thePromise;
}
var _allSyncSettledCreator;
function createSyncPromise(executor) {
return _createPromise(createSyncPromise, syncItemProcessor, executor);
}
function createSyncAllSettledPromise(input, timeout) {
!_allSyncSettledCreator && (_allSyncSettledCreator = /* @__PURE__ */ _createAllSettledPromise(createSyncPromise));
return _allSyncSettledCreator.v(input, timeout);
}
var _promiseCreator;
function createPromise(executor, timeout) {
!_promiseCreator && (_promiseCreator = /* @__PURE__ */ createCachedValue(createNativePromise));
return _promiseCreator.v.call(this, executor, timeout);
}
var createAllPromise = /* @__PURE__ */ _createAllPromise(createPromise);
var UNDEFINED_VALUE$2 = void 0;
var STR_EMPTY$1 = "";
var STR_CHANNELS = "channels";
var STR_CORE = "core";
var STR_CREATE_PERF_MGR = "createPerfMgr";
var STR_DISABLED = "disabled";
var STR_EXTENSION_CONFIG = "extensionConfig";
var STR_EXTENSIONS = "extensions";
var STR_PROCESS_TELEMETRY = "processTelemetry";
var STR_PRIORITY = "priority";
var STR_EVENTS_SENT = "eventsSent";
var STR_EVENTS_DISCARDED = "eventsDiscarded";
var STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
var STR_PERF_EVENT = "perfEvent";
var STR_OFFLINE_STORE = "offlineEventsStored";
var STR_OFFLINE_SENT = "offlineBatchSent";
var STR_OFFLINE_DROP = "offlineBatchDrop";
var STR_GET_PERF_MGR = "getPerfMgr";
var STR_DOMAIN = "domain";
var STR_PATH = "path";
var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
var STR_REDACTED = "REDACTED";
var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
var rCamelCase = /-([a-z])/g;
var rNormalizeInvalid = /([^\w\d_$])/g;
var rLeadingNumeric = /^(\d+[\w\d_$])/;
function isNotNullOrUndefined(value) {
return !/* @__PURE__ */ isNullOrUndefined(value);
}
function normalizeJsName(name) {
var value = name;
if (value && isString(value)) {
value = value[_DYN_REPLACE](rCamelCase, function(_all, letter) {
return letter.toUpperCase();
});
value = value[_DYN_REPLACE](rNormalizeInvalid, "_");
value = value[_DYN_REPLACE](rLeadingNumeric, function(_all, match) {
return "_" + match;
});
}
return value;
}
function strContains(value, search) {
if (value && search) {
return strIndexOf(value, search) !== -1;
}
return false;
}
function toISOString(date) {
return date && date.toISOString() || "";
}
function getExceptionName(object) {
if (isError(object)) {
return object[_DYN_NAME$2];
}
return STR_EMPTY$1;
}
function setValue(target, field, value, valChk, srcChk) {
var theValue = value;
if (target) {
theValue = target[field];
if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
theValue = value;
target[field] = theValue;
}
}
return theValue;
}
function getSetValue(target, field, defValue) {
var theValue;
if (target) {
theValue = target[field];
if (!theValue && /* @__PURE__ */ isNullOrUndefined(theValue)) {
theValue = !/* @__PURE__ */ isUndefined(defValue) ? defValue : {};
target[field] = theValue;
}
} else {
theValue = !/* @__PURE__ */ isUndefined(defValue) ? defValue : {};
}
return theValue;
}
function _createProxyFunction(source, funcName) {
var srcFunc = null;
var src = null;
if (isFunction(source)) {
srcFunc = source;
} else {
src = source;
}
return function() {
var originalArguments = arguments;
if (srcFunc) {
src = srcFunc();
}
if (src) {
return src[funcName][_DYN_APPLY](src, originalArguments);
}
};
}
function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
if (target && name && source) {
if (overwriteTarget !== false || /* @__PURE__ */ isUndefined(target[name])) {
target[name] = _createProxyFunction(source, theFunc);
}
}
}
function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
if (target && source && /* @__PURE__ */ isObject(target) && isArray(functionsToProxy)) {
arrForEach(functionsToProxy, function(theFuncName) {
if (isString(theFuncName)) {
proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
}
});
}
return target;
}
function createClassFromInterface(defaults) {
return (
/** @class */
/* @__PURE__ */ (function() {
function class_1() {
var _this = this;
if (defaults) {
objForEachKey(defaults, function(field, value) {
_this[field] = value;
});
}
}
return class_1;
})()
);
}
function optimizeObject(theObject) {
if (theObject && objAssign) {
theObject = ObjClass(objAssign({}, theObject));
}
return theObject;
}
function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
var theArgs = arguments;
var extended = theArgs[0] || {};
var argLen = theArgs[_DYN_LENGTH$2];
var deep = false;
var idx = 1;
if (argLen > 0 && isBoolean(extended)) {
deep = extended;
extended = theArgs[idx] || {};
idx++;
}
if (!/* @__PURE__ */ isObject(extended)) {
extended = {};
}
for (; idx < argLen; idx++) {
var arg = theArgs[idx];
var isArgArray = isArray(arg);
var isArgObj = /* @__PURE__ */ isObject(arg);
for (var prop in arg) {
var propOk = isArgArray && prop in arg || isArgObj && objHasOwn(arg, prop);
if (!propOk) {
continue;
}
var newValue = arg[prop];
var isNewArray = void 0;
if (deep && newValue && ((isNewArray = isArray(newValue)) || /* @__PURE__ */ isPlainObject(newValue))) {
var clone = extended[prop];
if (isNewArray) {
if (!isArray(clone)) {
clone = [];
}
} else if (!/* @__PURE__ */ isPlainObject(clone)) {
clone = {};
}
newValue = objExtend(deep, clone, newValue);
}
if (newValue !== void 0) {
extended[prop] = newValue;
}
}
}
return extended;
}
function isFeatureEnabled(feature, cfg, sdkDefaultState) {
var ft = cfg && cfg.featureOptIn && cfg.featureOptIn[feature];
if (feature && ft) {
var mode = ft.mode;
if (mode === 3) {
return true;
} else if (mode === 2) {
return false;
}
}
return sdkDefaultState;
}
function getResponseText(xhr) {
try {
return xhr.responseText;
} catch (e) {
}
return null;
}
function formatErrorMessageXdr(xdr, message) {
if (xdr) {
return "XDomainRequest,Response:" + getResponseText(xdr) || "";
}
return message;
}
function formatErrorMessageXhr(xhr, message) {
if (xhr) {
return "XMLHttpRequest,Status:" + xhr[_DYN_STATUS] + ",Response:" + getResponseText(xhr) || xhr.response || "";
}
return message;
}
function prependTransports(theTransports, newTransports) {
if (newTransports) {
if (isNumber(newTransports)) {
theTransports = [newTransports].concat(theTransports);
} else if (isArray(newTransports)) {
theTransports = newTransports.concat(theTransports);
}
}
return theTransports;
}
var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
var strWithCredentials = "withCredentials";
var strTimeout = "timeout";
function openXhr(method, urlString, withCredentials, disabled, isSync, timeout) {
if (disabled === void 0) {
disabled = false;
}
if (isSync === void 0) {
isSync = false;
}
function _wrapSetXhrProp(xhr2, prop, value) {
try {
xhr2[prop] = value;
} catch (e) {
}
}
var xhr = new XMLHttpRequest();
if (disabled) {
_wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
}
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
xhr.open(method, urlString, !isSync);
if (withCredentials) {
_wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
}
if (!isSync && timeout) {
_wrapSetXhrProp(xhr, strTimeout, timeout);
}
return xhr;
}
function convertAllHeadersToMap(headersString) {
var headers = {};
if (isString(headersString)) {
var headersArray = strTrim(headersString)[_DYN_SPLIT$1](/[\r\n]+/);
arrForEach(headersArray, function(headerEntry) {
if (headerEntry) {
var idx = headerEntry[_DYN_INDEX_OF](": ");
if (idx !== -1) {
var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE$1]();
var value = strTrim(headerEntry[_DYN_SUBSTRING](idx + 1));
headers[header] = value;
} else {
headers[strTrim(headerEntry)] = 1;
}
}
});
}
return headers;
}
function _appendHeader(theHeaders, xhr, name) {
if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
var value = xhr.getResponseHeader(name);
if (value) {
theHeaders[name] = strTrim(value);
}
}
return theHeaders;
}
var STR_KILL_DURATION_HEADER = "kill-duration";
var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
var STR_TIME_DELTA_HEADER = "time-delta-millis";
function _getAllResponseHeaders(xhr, isOneDs) {
var theHeaders = {};
if (!xhr[_DYN_GET_ALL_RESPONSE_HEA5]) {
if (!!isOneDs) {
theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
}
} else {
theHeaders = convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA5]());
}
return theHeaders;
}
var strDocumentMode = "documentMode";
var strLocation = "location";
var strConsole = "console";
var strJSON = "JSON";
var strCrypto = "crypto";
var strMsCrypto = "msCrypto";
var strMsie = "msie";
var strTrident = "trident/";
var strXMLHttpRequest = "XMLHttpRequest";
var _isTrident = null;
var _navUserAgentCheck = null;
var _enableMocks = false;
var _useXDomainRequest = null;
var _beaconsSupported = null;
function _hasProperty(theClass, property) {
var supported = false;
if (theClass) {
try {
supported = property in theClass;
if (!supported) {
var proto = theClass[strShimPrototype];
if (proto) {
supported = property in proto;
}
}
} catch (e) {
}
if (!supported) {
try {
var tmp = new theClass();
supported = !/* @__PURE__ */ isUndefined(tmp[property]);
} catch (e) {
}
}
}
return supported;
}
function getLocation(checkForMock) {
if (checkForMock && _enableMocks) {
var mockLocation = /* @__PURE__ */ getInst("__mockLocation");
if (mockLocation) {
return mockLocation;
}
}
if (typeof location === strShimObject && location) {
return location;
}
return /* @__PURE__ */ getInst(strLocation);
}
function getConsole() {
if (typeof console !== strShimUndefined) {
return console;
}
return /* @__PURE__ */ getInst(strConsole);
}
function hasJSON() {
return Boolean(typeof JSON === strShimObject && JSON || /* @__PURE__ */ getInst(strJSON) !== null);
}
function getJSON() {
if (hasJSON()) {
return JSON || /* @__PURE__ */ getInst(strJSON);
}
return null;
}
function getCrypto() {
return /* @__PURE__ */ getInst(strCrypto);
}
function getMsCrypto() {
return /* @__PURE__ */ getInst(strMsCrypto);
}
function isIE() {
var nav = getNavigator();
if (nav && (nav[_DYN_USER_AGENT] !== _navUserAgentCheck || _isTrident === null)) {
_navUserAgentCheck = nav[_DYN_USER_AGENT];
var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1]();
_isTrident = strContains(userAgent, strMsie) || strContains(userAgent, strTrident);
}
return _isTrident;
}
function getIEVersion(userAgentStr) {
if (userAgentStr === void 0) {
userAgentStr = null;
}
if (!userAgentStr) {
var navigator_1 = getNavigator() || {};
userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1]() : STR_EMPTY$1;
}
var ua = (userAgentStr || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1]();
if (strContains(ua, strMsie)) {
var doc = getDocument() || {};
return mathMax(parseInt(ua[_DYN_SPLIT$1](strMsie)[1]), doc[strDocumentMode] || 0);
} else if (strContains(ua, strTrident)) {
var tridentVer = parseInt(ua[_DYN_SPLIT$1](strTrident)[1]);
if (tridentVer) {
return tridentVer + 4;
}
}
return null;
}
function isBeaconsSupported(useCached) {
if (_beaconsSupported === null || useCached === false) {
_beaconsSupported = /* @__PURE__ */ hasNavigator() && Boolean(getNavigator().sendBeacon);
}
return _beaconsSupported;
}
function isFetchSupported(withKeepAlive) {
var isSupported = false;
try {
isSupported = !!/* @__PURE__ */ getInst("fetch");
var request = /* @__PURE__ */ getInst("Request");
if (isSupported && withKeepAlive && request) {
isSupported = _hasProperty(request, "keepalive");
}
} catch (e) {
}
return isSupported;
}
function useXDomainRequest() {
if (_useXDomainRequest === null) {
_useXDomainRequest = typeof XDomainRequest !== strShimUndefined;
if (_useXDomainRequest && isXhrSupported()) {
_useXDomainRequest = _useXDomainRequest && !_hasProperty(/* @__PURE__ */ getInst(strXMLHttpRequest), "withCredentials");
}
}
return _useXDomainRequest;
}
function isXhrSupported() {
var isSupported = false;
try {
var xmlHttpRequest = /* @__PURE__ */ getInst(strXMLHttpRequest);
isSupported = !!xmlHttpRequest;
} catch (e) {
}
return isSupported;
}
function redactUserInfo(url) {
return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
}
function redactQueryParameters(url, config) {
var sensitiveParams;
var questionMarkIndex = strIndexOf(url, "?");
if (questionMarkIndex === -1) {
return url;
}
if (config && config.redactQueryParams) {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
} else {
sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
}
var baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
var queryString = strSubstring(url, questionMarkIndex + 1);
var fragment = STR_EMPTY$1;
var hashIndex = strIndexOf(queryString, "#");
if (hashIndex !== -1) {
fragment = strSubstring(queryString, hashIndex);
queryString = strSubstring(queryString, 0, hashIndex);
}
var hasPotentialSensitiveParam = false;
for (var i = 0; i < sensitiveParams[_DYN_LENGTH$2]; i++) {
var paramCheck = sensitiveParams[i] + "=";
if (strIndexOf(queryString, paramCheck) !== -1) {
hasPotentialSensitiveParam = true;
break;
}
}
if (!hasPotentialSensitiveParam) {
return url;
}
var resultParts = [];
var anyParamRedacted = false;
if (queryString && queryString[_DYN_LENGTH$2]) {
var pairs = queryString[_DYN_SPLIT$1]("&");
for (var i = 0; i < pairs[_DYN_LENGTH$2]; i++) {
var pair = pairs[i];
if (!pair) {
continue;
}
var equalsIndex = strIndexOf(pair, "=");
if (equalsIndex === -1) {
resultParts[_DYN_PUSH$1](pair);
} else {
var paramName = pair[_DYN_SUBSTRING](0, equalsIndex);
var paramValue = pair[_DYN_SUBSTRING](equalsIndex + 1);
if (paramValue === STR_EMPTY$1) {
resultParts[_DYN_PUSH$1](pair);
} else {
var shouldRedact = false;
for (var j = 0; j < sensitiveParams[_DYN_LENGTH$2]; j++) {
if (paramName === sensitiveParams[j]) {
shouldRedact = true;
anyParamRedacted = true;
break;
}
}
if (shouldRedact) {
resultParts[_DYN_PUSH$1](paramName + "=" + STR_REDACTED);
} else {
resultParts[_DYN_PUSH$1](pair);
}
}
}
}
}
if (!anyParamRedacted) {
return url;
}
return baseUrl + resultParts.join("&") + fragment;
}
function fieldRedaction(input, config) {
if (!input || input[_DYN_INDEX_OF](" ") !== -1) {
return input;
}
var isRedactionDisabled = config && config.redactUrls === false;
if (isRedactionDisabled) {
return input;
}
var hasCredentials = strIndexOf(input, "@") !== -1;
var hasQueryParams = strIndexOf(input, "?") !== -1;
if (!hasCredentials && !hasQueryParams) {
return input;
}
try {
var result = input;
if (hasCredentials) {
result = redactUserInfo(input);
}
if (hasQueryParams) {
result = redactQueryParameters(result, config);
}
return result;
} catch (e) {
return input;
}
}
var UInt32Mask = 4294967296;
var MaxUInt32 = 4294967295;
var SEED1 = 123456789;
var SEED2 = 987654321;
var _mwcSeeded = false;
var _mwcW = SEED1;
var _mwcZ = SEED2;
function _mwcSeed(seedValue) {
if (seedValue < 0) {
seedValue >>>= 0;
}
_mwcW = SEED1 + seedValue & MaxUInt32;
_mwcZ = SEED2 - seedValue & MaxUInt32;
_mwcSeeded = true;
}
function _autoSeedMwc() {
try {
var now = /* @__PURE__ */ utcNow() & 2147483647;
_mwcSeed((Math.random() * UInt32Mask ^ now) + now);
} catch (e) {
}
}
function random32(signed) {
var value = 0;
var c = getCrypto() || getMsCrypto();
if (c && c.getRandomValues) {
value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
}
if (value === 0 && isIE()) {
if (!_mwcSeeded) {
_autoSeedMwc();
}
value = mwcRandom32() & MaxUInt32;
}
if (value === 0) {
value = mathFloor(UInt32Mask * Math.random() | 0);
}
if (!signed) {
value >>>= 0;
}
return value;
}
function mwcRandom32(signed) {
_mwcZ = 36969 * (_mwcZ & 65535) + (_mwcZ >> 16) & MaxUInt32;
_mwcW = 18e3 * (_mwcW & 65535) + (_mwcW >> 16) & MaxUInt32;
var value = (_mwcZ << 16) + (_mwcW & 65535) >>> 0 & MaxUInt32 | 0;
if (!signed) {
value >>>= 0;
}
return value;
}
function newId(maxLength) {
if (maxLength === void 0) {
maxLength = 22;
}
var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var number = random32() >>> 0;
var chars = 0;
var result = STR_EMPTY$1;
while (result[_DYN_LENGTH$2] < maxLength) {
chars++;
result += base64chars.charAt(number & 63);
number >>>= 6;
if (chars === 5) {
number = (random32() << 2 & 4294967295 | number & 3) >>> 0;
chars = 0;
}
}
return result;
}
var version = "3.3.10";
var instanceName = "." + newId(6);
var _dataUid = 0;
function _canAcceptData(target) {
return target.nodeType === 1 || target.nodeType === 9 || !+target.nodeType;
}
function _getCache(data, target) {
var theCache = target[data.id];
if (!theCache) {
theCache = {};
try {
if (_canAcceptData(target)) {
objDefine(target, data.id, {
e: false,
v: theCache
});
}
} catch (e) {
}
}
return theCache;
}
function createUniqueNamespace(name, includeVersion) {
if (includeVersion === void 0) {
includeVersion = false;
}
return normalizeJsName(name + _dataUid++ + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
}
function createElmNodeData(name) {
var data = {
id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
accept: function(target) {
return _canAcceptData(target);
},
get: function(target, name2, defValue, addDefault) {
var theCache = target[data.id];
if (!theCache) {
if (addDefault) {
theCache = _getCache(data, target);
theCache[normalizeJsName(name2)] = defValue;
}
return defValue;
}
return theCache[normalizeJsName(name2)];
},
kill: function(target, name2) {
if (target && target[name2]) {
try {
delete target[name2];
} catch (e) {
}
}
}
};
return data;
}
function _isConfigDefaults(value) {
return value && /* @__PURE__ */ isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set);
}
function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
var defValue;
var isDefaultValid = cfgDefaults.dfVal || isDefined;
if (theConfig && cfgDefaults.fb) {
var fallbacks = cfgDefaults.fb;
if (!isArray(fallbacks)) {
fallbacks = [fallbacks];
}
for (var lp = 0; lp < fallbacks[_DYN_LENGTH$2]; lp++) {
var fallback = fallbacks[lp];
var fbValue = theConfig[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
} else if (dynamicHandler) {
fbValue = dynamicHandler.cfg[fallback];
if (isDefaultValid(fbValue)) {
defValue = fbValue;
}
dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
}
if (isDefaultValid(defValue)) {
break;
}
}
}
if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
defValue = cfgDefaults.v;
}
return defValue;
}
function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
var theValue = cfgDefaults;
if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
}
if (theValue) {
if (_isConfigDefaults(theValue)) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
}
var newValue_1;
if (isArray(theValue)) {
newValue_1 = [];
newValue_1[_DYN_LENGTH$2] = theValue[_DYN_LENGTH$2];
} else if (/* @__PURE__ */ isPlainObject(theValue)) {
newValue_1 = {};
}
if (newValue_1) {
objForEachKey(theValue, function(key, value) {
if (value && _isConfigDefaults(value)) {
value = _resolveDefaultValue(dynamicHandler, theConfig, value);
}
newValue_1[key] = value;
});
theValue = newValue_1;
}
}
return theValue;
}
function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
var isValid;
var setFn;
var defValue;
var cfgDefaults = defaultValue;
var mergeDf;
var reference;
var readOnly;
var blkDynamicValue;
if (_isConfigDefaults(cfgDefaults)) {
isValid = cfgDefaults.isVal;
setFn = cfgDefaults.set;
readOnly = cfgDefaults.rdOnly;
blkDynamicValue = cfgDefaults.blkVal;
mergeDf = cfgDefaults.mrg;
reference = cfgDefaults.ref;
if (!reference && /* @__PURE__ */ isUndefined(reference)) {
reference = !!mergeDf;
}
defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
} else {
defValue = defaultValue;
}
if (blkDynamicValue) {
dynamicHandler.blkVal(theConfig, name);
}
var theValue;
var usingDefault = true;
var cfgValue = theConfig[name];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
theValue = cfgValue;
usingDefault = false;
if (isValid && theValue !== defValue && !isValid(theValue)) {
theValue = defValue;
usingDefault = true;
}
if (setFn) {
theValue = setFn(theValue, defValue, theConfig);
usingDefault = theValue === defValue;
}
}
if (!usingDefault) {
if (/* @__PURE__ */ isPlainObject(theValue) || isArray(defValue)) {
if (mergeDf && defValue && (/* @__PURE__ */ isPlainObject(defValue) || isArray(defValue))) {
objForEachKey(defValue, function(dfName, dfValue) {
_applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
});
}
}
} else if (defValue) {
theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
} else {
theValue = defValue;
}
dynamicHandler.set(theConfig, name, theValue);
if (reference) {
dynamicHandler.ref(theConfig, name);
}
if (readOnly) {
dynamicHandler.rdOnly(theConfig, name);
}
}
var CFG_HANDLER_LINK = /* @__PURE__ */ symbolFor("[[ai_dynCfg_1]]");
var BLOCK_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_blkDynCfg_1]]");
var FORCE_DYNAMIC = /* @__PURE__ */ symbolFor("[[ai_frcDynCfg_1]]");
function _cfgDeepCopy(source) {
if (source) {
var target_1;
if (isArray(source)) {
target_1 = [];
target_1[_DYN_LENGTH$2] = source[_DYN_LENGTH$2];
} else if (/* @__PURE__ */ isPlainObject(source)) {
target_1 = {};
}
if (target_1) {
objForEachKey(source, function(key, value) {
target_1[key] = _cfgDeepCopy(value);
});
return target_1;
}
}
return source;
}
function getDynamicConfigHandler(value) {
if (value) {
var handler = value[CFG_HANDLER_LINK] || value;
if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler;
}
}
return null;
}
function blockDynamicConversion(value) {
if (value && (/* @__PURE__ */ isPlainObject(value) || isArray(value))) {
try {
value[BLOCK_DYNAMIC] = true;
} catch (e) {
}
}
return value;
}
function _canMakeDynamic(getFunc, state, value) {
var result = false;
if (value && !getFunc[state.blkVal]) {
result = value[FORCE_DYNAMIC];
if (!result && !value[BLOCK_DYNAMIC]) {
result = /* @__PURE__ */ isPlainObject(value) || isArray(value);
}
}
return result;
}
function throwInvalidAccess(message) {
throwTypeError("InvalidAccess:" + message);
}
var arrayMethodsToPatch = [
"push",
"pop",
"shift",
"unshift",
"splice"
];
var _throwDynamicError = function(logger2, name, desc, e) {
logger2 && logger2[_DYN_THROW_INTERNAL](3, 108, "".concat(desc, " [").concat(name, "] failed - ") + /* @__PURE__ */ dumpObj(e));
};
function _patchArray(state, target, name) {
if (isArray(target)) {
arrForEach(arrayMethodsToPatch, function(method) {
var orgMethod = target[method];
target[method] = function() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var result = orgMethod[_DYN_APPLY](this, args);
_makeDynamicObject(state, target, name, "Patching");
return result;
};
});
}
}
function _getOwnPropGetter(target, name) {
var propDesc = objGetOwnPropertyDescriptor(target, name);
return propDesc && propDesc.get;
}
function _createDynamicProperty(state, theConfig, name, value) {
var detail = {
n: name,
h: [],
trk: function(handler) {
if (handler && handler.fn) {
if (arrIndexOf(detail.h, handler) === -1) {
detail.h[_DYN_PUSH$1](handler);
}
state.trk(handler, detail);
}
},
clr: function(handler) {
var idx = arrIndexOf(detail.h, handler);
if (idx !== -1) {
detail.h[_DYN_SPLICE](idx, 1);
}
}
};
var checkDynamic = true;
var isObjectOrArray = false;
function _getProperty() {
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
value = _makeDynamicObject(state, value, name, "Converting");
}
checkDynamic = false;
}
var activeHandler = state.act;
if (activeHandler) {
detail.trk(activeHandler);
}
return value;
}
_getProperty[state.prop] = {
chng: function() {
state.add(detail);
}
};
function _setProperty(newValue) {
if (value !== newValue) {
if (!!_getProperty[state.ro] && !state.upd) {
throwInvalidAccess("[" + name + "] is read-only:" + /* @__PURE__ */ dumpObj(theConfig));
}
if (checkDynamic) {
isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
checkDynamic = false;
}
var isReferenced = isObjectOrArray && _getProperty[state.rf];
if (isObjectOrArray) {
if (isReferenced) {
objForEachKey(value, function(key) {
value[key] = newValue ? newValue[key] : UNDEFINED_VALUE$2;
});
try {
objForEachKey(newValue, function(key, theValue) {
_setDynamicProperty(state, value, key, theValue);
});
newValue = value;
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Assigning", e);
isObjectOrArray = false;
}
} else if (value && value[CFG_HANDLER_LINK]) {
objForEachKey(value, function(key) {
var getter = _getOwnPropGetter(value, key);
if (getter) {
var valueState = getter[state.prop];
valueState && valueState.chng();
}
});
}
}
if (newValue !== value) {
var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
if (!isReferenced && newIsObjectOrArray) {
newValue = _makeDynamicObject(state, newValue, name, "Converting");
}
value = newValue;
isObjectOrArray = newIsObjectOrArray;
}
state.add(detail);
}
}
objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
}
function _setDynamicProperty(state, target, name, value) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
if (!isDynamic) {
_createDynamicProperty(state, target, name, value);
} else {
target[name] = value;
}
}
return target;
}
function _setDynamicPropertyState(state, target, name, flags) {
if (target) {
var getter = _getOwnPropGetter(target, name);
var isDynamic = getter && !!getter[state.prop];
var inPlace = flags && flags[0];
var rdOnly = flags && flags[1];
var blkProp = flags && flags[2];
if (!isDynamic) {
if (blkProp) {
try {
blockDynamicConversion(target);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "Blocking", e);
}
}
try {
_setDynamicProperty(state, target, name, target[name]);
getter = _getOwnPropGetter(target, name);
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, "State", e);
}
}
if (inPlace) {
getter[state.rf] = inPlace;
}
if (rdOnly) {
getter[state.ro] = rdOnly;
}
if (blkProp) {
getter[state.blkVal] = true;
}
}
return target;
}
function _makeDynamicObject(state, target, name, desc) {
try {
objForEachKey(target, function(key, value) {
_setDynamicProperty(state, target, key, value);
});
if (!target[CFG_HANDLER_LINK]) {
objDefineProp(target, CFG_HANDLER_LINK, {
get: function() {
return state.hdlr;
}
});
_patchArray(state, target, name);
}
} catch (e) {
_throwDynamicError((state.hdlr || {})[_DYN_LOGGER], name, desc, e);
}
return target;
}
var symPrefix = "[[ai_";
var symPostfix = "]]";
function _createState(cfgHandler) {
var dynamicPropertySymbol = /* @__PURE__ */ newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
var dynamicPropertyReadOnly = /* @__PURE__ */ newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
var dynamicPropertyReferenced = /* @__PURE__ */ newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
var dynamicPropertyBlockValue = /* @__PURE__ */ newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
var dynamicPropertyDetail = /* @__PURE__ */ newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
var _waitingHandlers = null;
var _watcherTimer = null;
var theState;
function _useHandler(activeHandler, callback) {
var prevWatcher = theState.act;
try {
theState.act = activeHandler;
if (activeHandler && activeHandler[dynamicPropertyDetail]) {
arrForEach(activeHandler[dynamicPropertyDetail], function(detail) {
detail.clr(activeHandler);
});
activeHandler[dynamicPropertyDetail] = [];
}
callback({
cfg: cfgHandler.cfg,
set: cfgHandler.set.bind(cfgHandler),
setDf: cfgHandler.setDf.bind(cfgHandler),
ref: cfgHandler.ref.bind(cfgHandler),
rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
});
} catch (e) {
var logger2 = cfgHandler[_DYN_LOGGER];
if (logger2) {
logger2[_DYN_THROW_INTERNAL](1, 107, /* @__PURE__ */ dumpObj(e));
}
throw e;
} finally {
theState.act = prevWatcher || null;
}
}
function _notifyWatchers() {
if (_waitingHandlers) {
var notifyHandlers = _waitingHandlers;
_waitingHandlers = null;
_watcherTimer && _watcherTimer[_DYN_CANCEL]();
_watcherTimer = null;
var watcherFailures_1 = [];
arrForEach(notifyHandlers, function(handler) {
if (handler) {
if (handler[dynamicPropertyDetail]) {
arrForEach(handler[dynamicPropertyDetail], function(detail) {
detail.clr(handler);
});
handler[dynamicPropertyDetail] = null;
}
if (handler.fn) {
try {
_useHandler(handler, handler.fn);
} catch (e) {
watcherFailures_1[_DYN_PUSH$1](e);
}
}
}
});
if (_waitingHandlers) {
try {
_notifyWatchers();
} catch (e) {
watcherFailures_1[_DYN_PUSH$1](e);
}
}
if (watcherFailures_1[_DYN_LENGTH$2] > 0) {
throwAggregationError("Watcher error(s): ", watcherFailures_1);
}
}
}
function _addWatcher(detail) {
if (detail && detail.h[_DYN_LENGTH$2] > 0) {
if (!_waitingHandlers) {
_waitingHandlers = [];
}
if (!_watcherTimer) {
_watcherTimer = scheduleTimeout(function() {
_watcherTimer = null;
_notifyWatchers();
}, 0);
}
for (var idx = 0; idx < detail.h[_DYN_LENGTH$2]; idx++) {
var handler = detail.h[idx];
if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
_waitingHandlers[_DYN_PUSH$1](handler);
}
}
}
}
function _trackHandler(handler, detail) {
if (handler) {
var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
if (arrIndexOf(details, detail) === -1) {
details[_DYN_PUSH$1](detail);
}
}
}
theState = {
prop: dynamicPropertySymbol,
ro: dynamicPropertyReadOnly,
rf: dynamicPropertyReferenced,
blkVal: dynamicPropertyBlockValue,
hdlr: cfgHandler,
add: _addWatcher,
notify: _notifyWatchers,
use: _useHandler,
trk: _trackHandler
};
return theState;
}
function _createAndUseHandler(state, configHandler) {
var handler = {
fn: configHandler,
rm: function() {
handler.fn = null;
state = null;
configHandler = null;
}
};
objDefine(handler, "toJSON", { v: function() {
return "WatcherHandler" + (handler.fn ? "" : "[X]");
} });
state.use(handler, configHandler);
return handler;
}
function _createDynamicHandler(logger2, target, inPlace) {
var dynamicHandler = getDynamicConfigHandler(target);
if (dynamicHandler) {
return dynamicHandler;
}
var uid = createUniqueNamespace("dyncfg", true);
var newTarget = target && inPlace !== false ? target : _cfgDeepCopy(target);
var theState;
function _notifyWatchers() {
theState.notify();
}
function _setValue(target2, name, value) {
try {
target2 = _setDynamicProperty(theState, target2, name, value);
} catch (e) {
_throwDynamicError(logger2, name, "Setting value", e);
}
return target2[name];
}
function _watch(configHandler) {
return _createAndUseHandler(theState, configHandler);
}
function _block(configHandler, allowUpdate) {
theState.use(null, function(details) {
var prevUpd = theState.upd;
try {
if (!/* @__PURE__ */ isUndefined(allowUpdate)) {
theState.upd = allowUpdate;
}
configHandler(details);
} finally {
theState.upd = prevUpd;
}
});
}
function _ref(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[0] = true, _a2))[name];
}
function _rdOnly(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[1] = true, _a2))[name];
}
function _blkPropValue(target2, name) {
var _a2;
return _setDynamicPropertyState(theState, target2, name, (_a2 = {}, _a2[2] = true, _a2))[name];
}
function _applyDefaults(theConfig, defaultValues2) {
if (defaultValues2) {
objForEachKey(defaultValues2, function(name, value) {
_applyDefaultValue(cfgHandler, theConfig, name, value);
});
}
return theConfig;
}
var cfgHandler = {
uid: null,
cfg: newTarget,
logger: logger2,
notify: _notifyWatchers,
set: _setValue,
setDf: _applyDefaults,
watch: _watch,
ref: _ref,
rdOnly: _rdOnly,
blkVal: _blkPropValue,
_block
};
objDefine(cfgHandler, "uid", {
c: false,
e: false,
w: false,
v: uid
});
theState = _createState(cfgHandler);
_makeDynamicObject(theState, newTarget, "config", "Creating");
return cfgHandler;
}
function _logInvalidAccess(logger2, message) {
if (logger2) {
logger2[_DYN_WARN_TO_CONSOLE](message);
logger2[_DYN_THROW_INTERNAL](2, 108, message);
} else {
throwInvalidAccess(message);
}
}
function createDynamicConfig(config, defaultConfig2, logger2, inPlace) {
var dynamicHandler = _createDynamicHandler(logger2, config || {}, inPlace);
if (defaultConfig2) {
dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig2);
}
return dynamicHandler;
}
function onConfigChange(config, configHandler, logger2) {
var handler = config[CFG_HANDLER_LINK] || config;
if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
return handler[_DYN_WATCH](configHandler);
}
_logInvalidAccess(logger2, STR_NOT_DYNAMIC_ERROR + /* @__PURE__ */ dumpObj(config));
return createDynamicConfig(config, null, logger2)[_DYN_WATCH](configHandler);
}
function runTargetUnload(target, isAsync) {
if (target && target[_DYN_UNLOAD]) {
return target[_DYN_UNLOAD](isAsync);
}
}
function doUnloadAll(targets, isAsync, done) {
var result;
if (!done) {
result = createPromise(function(resolved) {
done = resolved;
});
}
if (targets && getLength(targets) > 0) {
doAwaitResponse(runTargetUnload(targets[0], isAsync), function() {
doUnloadAll(arrSlice(targets, 1), isAsync, done);
});
} else {
done();
}
return result;
}
var ChannelControllerPriority = 500;
var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
function _stringToBoolOrDefault(theValue, defaultValue, theConfig) {
if (!theValue && /* @__PURE__ */ isNullOrUndefined(theValue)) {
return defaultValue;
}
if (isBoolean(theValue)) {
return theValue;
}
return asString(theValue)[_DYN_TO_LOWER_CASE$1]() === "true";
}
function cfgDfMerge(defaultValue) {
return {
mrg: true,
v: defaultValue
};
}
function cfgDfValidate(validator, defaultValue, fallBackName) {
return {
fb: fallBackName,
isVal: validator,
v: defaultValue
};
}
function cfgDfBoolean(defaultValue, fallBackName) {
return {
fb: fallBackName,
set: _stringToBoolOrDefault,
v: !!defaultValue
};
}
var listenerFuncs = [STR_EVENTS_SENT, STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_PERF_EVENT];
var _aiNamespace = null;
var _debugListener;
function _listenerProxyFunc(name, config) {
return function() {
var args = arguments;
var dbgExt = getDebugExt(config);
if (dbgExt) {
var listener = dbgExt.listener;
if (listener && listener[name]) {
listener[name][_DYN_APPLY](listener, args);
}
}
};
}
function _getExtensionNamespace() {
var target = /* @__PURE__ */ getInst("Microsoft");
if (target) {
_aiNamespace = target["ApplicationInsights"];
}
return _aiNamespace;
}
function getDebugExt(config) {
var ns = _aiNamespace;
if (!ns && config.disableDbgExt !== true) {
ns = _aiNamespace || _getExtensionNamespace();
}
return ns ? ns["ChromeDbgExt"] : null;
}
function getDebugListener(config) {
if (!_debugListener) {
_debugListener = {};
for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH$2]; lp++) {
_debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
}
}
return _debugListener;
}
var _a$5;
var STR_WARN_TO_CONSOLE = "warnToConsole";
var AiNonUserActionablePrefix = "AI (Internal): ";
var AiUserActionablePrefix = "AI: ";
var AIInternalMessagePrefix = "AITR_";
var defaultValues$2 = {
loggingLevelConsole: 0,
loggingLevelTelemetry: 1,
maxMessageLimit: 25,
enableDebug: false
};
var _logFuncs = (_a$5 = {}, _a$5[0] = null, _a$5[1] = "errorToConsole", _a$5[2] = STR_WARN_TO_CONSOLE, _a$5[3] = "debugToConsole", _a$5);
function _sanitizeDiagnosticText(text) {
if (text) {
return '"' + text[_DYN_REPLACE](/\"/g, STR_EMPTY$1) + '"';
}
return STR_EMPTY$1;
}
function _logToConsole(func, message) {
var theConsole = getConsole();
if (!!theConsole) {
var logFunc = "log";
if (theConsole[func]) {
logFunc = func;
}
if (isFunction(theConsole[logFunc])) {
theConsole[logFunc](message);
}
}
}
var _InternalLogMessage = (
/** @class */
(function() {
function _InternalLogMessage2(msgId, msg, isUserAct, properties) {
if (isUserAct === void 0) {
isUserAct = false;
}
var _self = this;
_self[_DYN_MESSAGE_ID] = msgId;
_self[_DYN_MESSAGE$1] = (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) + msgId;
var strProps = STR_EMPTY$1;
if (hasJSON()) {
strProps = getJSON().stringify(properties);
}
var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) + (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
_self[_DYN_MESSAGE$1] += diagnosticText;
}
_InternalLogMessage2.dataType = "MessageData";
return _InternalLogMessage2;
})()
);
function safeGetLogger(core, config) {
return (core || {})[_DYN_LOGGER] || new DiagnosticLogger(config);
}
var DiagnosticLogger = (
/** @class */
(function() {
function DiagnosticLogger2(config) {
this.identifier = "DiagnosticLogger";
this.queue = [];
var _messageCount = 0;
var _messageLogged = {};
var _loggingLevelConsole;
var _loggingLevelTelemetry;
var _maxInternalMessageLimit;
var _enableDebug;
var _unloadHandler;
dynamicProto(DiagnosticLogger2, this, function(_self) {
_unloadHandler = _setDefaultsFromConfig(config || {});
_self.consoleLoggingLevel = function() {
return _loggingLevelConsole;
};
_self[_DYN_THROW_INTERNAL] = function(severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
if (_enableDebug) {
throw /* @__PURE__ */ dumpObj(message);
} else {
var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
if (!/* @__PURE__ */ isUndefined(message[_DYN_MESSAGE$1])) {
if (isUserAct) {
var messageKey = +message[_DYN_MESSAGE_ID];
if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE$1]);
_messageLogged[messageKey] = true;
}
} else {
if (_loggingLevelConsole >= severity) {
_self[logFunc](message[_DYN_MESSAGE$1]);
}
}
_logInternalMessage(severity, message);
} else {
_debugExtMsg("throw" + (severity === 1 ? "Critical" : "Warning"), message);
}
}
};
_self.debugToConsole = function(message) {
_logToConsole("debug", message);
_debugExtMsg("warning", message);
};
_self[_DYN_WARN_TO_CONSOLE] = function(message) {
_logToConsole("warn", message);
_debugExtMsg("warning", message);
};
_self.errorToConsole = function(message) {
_logToConsole("error", message);
_debugExtMsg("error", message);
};
_self.resetInternalMessageCount = function() {
_messageCount = 0;
_messageLogged = {};
};
_self.logInternalMessage = _logInternalMessage;
_self[_DYN_UNLOAD] = function(isAsync) {
_unloadHandler && _unloadHandler.rm();
_unloadHandler = null;
};
function _logInternalMessage(severity, message) {
if (_areInternalMessagesThrottled()) {
return;
}
var logMessage = true;
var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID];
if (_messageLogged[messageKey]) {
logMessage = false;
} else {
_messageLogged[messageKey] = true;
}
if (logMessage) {
if (severity <= _loggingLevelTelemetry) {
_self.queue[_DYN_PUSH$1](message);
_messageCount++;
_debugExtMsg(severity === 1 ? "error" : "warn", message);
}
if (_messageCount === _maxInternalMessageLimit) {
var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
var throttleMessage = new _InternalLogMessage(23, throttleLimitMessage, false);
_self.queue[_DYN_PUSH$1](throttleMessage);
if (severity === 1) {
_self.errorToConsole(throttleLimitMessage);
} else {
_self[_DYN_WARN_TO_CONSOLE](throttleLimitMessage);
}
}
}
}
function _setDefaultsFromConfig(config2) {
return onConfigChange(createDynamicConfig(config2, defaultValues$2, _self).cfg, function(details) {
var config3 = details.cfg;
_loggingLevelConsole = config3[_DYN_LOGGING_LEVEL_CONSOL4];
_loggingLevelTelemetry = config3.loggingLevelTelemetry;
_maxInternalMessageLimit = config3.maxMessageLimit;
_enableDebug = config3.enableDebug;
});
}
function _areInternalMessagesThrottled() {
return _messageCount >= _maxInternalMessageLimit;
}
function _debugExtMsg(name, data) {
var dbgExt = getDebugExt(config || {});
if (dbgExt && dbgExt[_DYN_DIAG_LOG$1]) {
dbgExt[_DYN_DIAG_LOG$1](name, data);
}
}
});
}
DiagnosticLogger2.__ieDyn = 1;
return DiagnosticLogger2;
})()
);
function _getLogger(logger2) {
return logger2 || new DiagnosticLogger();
}
function _throwInternal(logger2, severity, msgId, msg, properties, isUserAct) {
if (isUserAct === void 0) {
isUserAct = false;
}
_getLogger(logger2)[_DYN_THROW_INTERNAL](severity, msgId, msg, properties, isUserAct);
}
function _warnToConsole(logger2, message) {
_getLogger(logger2)[_DYN_WARN_TO_CONSOLE](message);
}
var _a$4, _b$2;
var strToGMTString = "toGMTString";
var strToUTCString = "toUTCString";
var strCookie = "cookie";
var strExpires = "expires";
var strIsCookieUseDisabled = "isCookieUseDisabled";
var strDisableCookiesUsage = "disableCookiesUsage";
var strConfigCookieMgr = "_ckMgr";
var _supportsCookies = null;
var _allowUaSameSite = null;
var _parsedCookieValue = null;
var _doc;
var _cookieCache = {};
var _globalCookieConfig = {};
var rootDefaultConfig = (_a$4 = {
cookieCfg: cfgDfMerge((_b$2 = {}, _b$2[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined }, _b$2.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined }, _b$2.enabled = UNDEFINED_VALUE$2, _b$2.ignoreCookies = UNDEFINED_VALUE$2, _b$2.blockedCookies = UNDEFINED_VALUE$2, _b$2.disableCookieDefer = false, _b$2)),
cookieDomain: UNDEFINED_VALUE$2,
cookiePath: UNDEFINED_VALUE$2
}, _a$4[strDisableCookiesUsage] = UNDEFINED_VALUE$2, _a$4);
function _getDoc() {
!_doc && (_doc = /* @__PURE__ */ getLazy(function() {
return getDocument();
}));
}
function _isMgrEnabled(cookieMgr) {
if (cookieMgr) {
return cookieMgr.isEnabled();
}
return true;
}
function _isIgnoredCookie(cookieMgrCfg, name) {
if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
}
return false;
}
function _isBlockedCookie(cookieMgrCfg, name) {
if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
return true;
}
}
return _isIgnoredCookie(cookieMgrCfg, name);
}
function _isCfgEnabled(rootConfig, cookieMgrConfig) {
var isCfgEnabled = cookieMgrConfig[_DYN_ENABLED];
if (/* @__PURE__ */ isNullOrUndefined(isCfgEnabled)) {
var cookieEnabled = void 0;
if (!/* @__PURE__ */ isUndefined(rootConfig[strIsCookieUseDisabled])) {
cookieEnabled = !rootConfig[strIsCookieUseDisabled];
}
if (!/* @__PURE__ */ isUndefined(rootConfig[strDisableCookiesUsage])) {
cookieEnabled = !rootConfig[strDisableCookiesUsage];
}
isCfgEnabled = cookieEnabled;
}
return isCfgEnabled;
}
function createCookieMgr(rootConfig, logger2) {
var cookieMgrConfig;
var _path;
var _domain;
var unloadHandler;
var _enabled;
var _getCookieFn;
var _setCookieFn;
var _delCookieFn;
var _pendingCookies = [];
function _formatDeletionValue(path11) {
var _a2;
var values = (_a2 = {}, _a2[STR_PATH] = path11 ? path11 : "/", _a2[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT", _a2);
if (!isIE()) {
values["max-age"] = "0";
}
return _formatCookieValue(STR_EMPTY$1, values);
}
function _formatSetCookieValue(value, maxAgeSec, domain, path11) {
var values = {};
var theValue = strTrim(value || STR_EMPTY$1);
var idx = strIndexOf(theValue, ";");
if (idx !== -1) {
theValue = strTrim(/* @__PURE__ */ strLeft(value, idx));
values = _extractParts(strSubstring(value, idx + 1));
}
setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
if (!/* @__PURE__ */ isNullOrUndefined(maxAgeSec)) {
var _isIE = isIE();
if (/* @__PURE__ */ isUndefined(values[strExpires])) {
var nowMs = /* @__PURE__ */ utcNow();
var expireMs = nowMs + maxAgeSec * 1e3;
if (expireMs > 0) {
var expiry = /* @__PURE__ */ new Date();
expiry.setTime(expireMs);
setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY$1, isTruthy);
}
}
if (!_isIE) {
setValue(values, "max-age", STR_EMPTY$1 + maxAgeSec, null, isUndefined);
}
}
var location2 = getLocation();
if (location2 && location2.protocol === "https:") {
setValue(values, "secure", null, null, isUndefined);
if (_allowUaSameSite === null) {
_allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT]);
}
if (_allowUaSameSite) {
setValue(values, "SameSite", "None", null, isUndefined);
}
}
setValue(values, STR_PATH, path11 || _path, null, isUndefined);
return _formatCookieValue(theValue, values);
}
function _removePendingCookie(name) {
if (_pendingCookies) {
for (var i = _pendingCookies[_DYN_LENGTH$2] - 1; i >= 0; i--) {
if (_pendingCookies[i].n === name) {
_pendingCookies[_DYN_SPLICE](i, 1);
}
}
}
}
function _flushPendingCookies() {
if (areCookiesSupported(logger2) && _pendingCookies) {
arrForEach(_pendingCookies, function(pendingData) {
if (!_isBlockedCookie(cookieMgrConfig, pendingData.n)) {
if (pendingData.o === 0) {
_setCookieFn(pendingData.n, pendingData.v);
} else if (pendingData.o === 1) {
_delCookieFn(pendingData.n, pendingData.v);
}
}
});
_pendingCookies = [];
}
}
rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger2).cfg;
unloadHandler = onConfigChange(rootConfig, function(details) {
details.setDf(details.cfg, rootDefaultConfig);
cookieMgrConfig = details.ref(details.cfg, "cookieCfg");
_path = cookieMgrConfig[STR_PATH] || "/";
_domain = cookieMgrConfig[STR_DOMAIN];
if (cookieMgrConfig.disableCookieDefer) {
_pendingCookies = null;
} else if (_pendingCookies === null) {
_pendingCookies = [];
}
var wasEnabled = _enabled;
_enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false;
_getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
_setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
_delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
if (!wasEnabled && _enabled && _pendingCookies) {
_flushPendingCookies();
}
}, logger2);
var cookieMgr = {
isEnabled: function() {
var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger2);
var gblManager = _globalCookieConfig[strConfigCookieMgr];
if (enabled && gblManager && cookieMgr !== gblManager) {
enabled = _isMgrEnabled(gblManager);
}
return enabled;
},
setEnabled: function(value) {
cookieMgrConfig[_DYN_ENABLED] = value;
if (!/* @__PURE__ */ isUndefined(rootConfig[strDisableCookiesUsage])) {
rootConfig[strDisableCookiesUsage] = !value;
}
},
set: function(name, value, maxAgeSec, domain, path11) {
var result = false;
var isBlocked = _isBlockedCookie(cookieMgrConfig, name);
if (!isBlocked) {
var cookieValue = _formatSetCookieValue(value, maxAgeSec, domain, path11);
if (_isMgrEnabled(cookieMgr)) {
_setCookieFn(name, cookieValue);
result = true;
} else if (_pendingCookies) {
_removePendingCookie(name);
_pendingCookies[_DYN_PUSH$1]({
n: name,
o: 0,
v: cookieValue
});
result = true;
}
}
return result;
},
get: function(name) {
var value = STR_EMPTY$1;
var isIgnored = _isIgnoredCookie(cookieMgrConfig, name);
if (!isIgnored) {
if (_isMgrEnabled(cookieMgr)) {
value = _getCookieFn(name);
} else if (_pendingCookies) {
for (var i = _pendingCookies[_DYN_LENGTH$2] - 1; i >= 0; i--) {
var pendingData = _pendingCookies[i];
if (pendingData.n === name) {
if (pendingData.o === 0) {
var cookieValue = pendingData.v;
var idx = strIndexOf(cookieValue, ";");
value = idx !== -1 ? strTrim(/* @__PURE__ */ strLeft(cookieValue, idx)) : strTrim(cookieValue);
}
break;
}
}
}
}
return value;
},
del: function(name, path11) {
var result = false;
if (_isMgrEnabled(cookieMgr)) {
result = cookieMgr.purge(name, path11);
} else if (_pendingCookies) {
_removePendingCookie(name);
_pendingCookies[_DYN_PUSH$1]({
n: name,
o: 1,
v: _formatDeletionValue(path11)
});
result = true;
}
return result;
},
purge: function(name, path11) {
var result = false;
if (areCookiesSupported(logger2)) {
_delCookieFn(name, _formatDeletionValue(path11));
result = true;
}
return result;
},
unload: function(isAsync) {
unloadHandler && unloadHandler.rm();
unloadHandler = null;
_pendingCookies = null;
}
};
cookieMgr[strConfigCookieMgr] = cookieMgr;
return cookieMgr;
}
function areCookiesSupported(logger2) {
if (_supportsCookies === null) {
_supportsCookies = false;
!_doc && _getDoc();
try {
var doc = _doc.v || {};
_supportsCookies = doc[strCookie] !== void 0;
} catch (e) {
_throwInternal(logger2, 2, 68, "Cannot access document.cookie - " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return _supportsCookies;
}
function _extractParts(theValue) {
var values = {};
if (theValue && theValue[_DYN_LENGTH$2]) {
var parts = strTrim(theValue)[_DYN_SPLIT$1](";");
arrForEach(parts, function(thePart) {
thePart = strTrim(thePart || STR_EMPTY$1);
if (thePart) {
var idx = strIndexOf(thePart, "=");
if (idx === -1) {
values[thePart] = null;
} else {
values[strTrim(/* @__PURE__ */ strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
}
}
});
}
return values;
}
function _formatDate(theDate, func) {
if (isFunction(theDate[func])) {
return theDate[func]();
}
return null;
}
function _formatCookieValue(value, values) {
var cookieValue = value || STR_EMPTY$1;
objForEachKey(values, function(name, theValue) {
cookieValue += "; " + name + (!/* @__PURE__ */ isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY$1);
});
return cookieValue;
}
function _getCookieValue(name) {
var cookieValue = STR_EMPTY$1;
!_doc && _getDoc();
if (_doc.v) {
var theCookie = _doc.v[strCookie] || STR_EMPTY$1;
if (_parsedCookieValue !== theCookie) {
_cookieCache = _extractParts(theCookie);
_parsedCookieValue = theCookie;
}
cookieValue = strTrim(_cookieCache[name] || STR_EMPTY$1);
}
return cookieValue;
}
function _setCookieValue(name, cookieValue) {
!_doc && _getDoc();
if (_doc.v) {
_doc.v[strCookie] = name + "=" + cookieValue;
}
}
function uaDisallowsSameSiteNone(userAgent) {
if (!isString(userAgent)) {
return false;
}
if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
return true;
}
if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
return true;
}
if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
return true;
}
if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
return true;
}
if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
return true;
}
if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
return true;
}
return false;
}
var defaultValues$1 = {
perfEvtsSendAll: false
};
function _runScheduledListeners(asyncNotifications) {
asyncNotifications.h = null;
var callbacks = asyncNotifications.cb;
asyncNotifications.cb = [];
arrForEach(callbacks, function(cb) {
safe(cb.fn, [cb.arg]);
});
}
function _runListeners(listeners, name, asyncNotifications, callback) {
arrForEach(listeners, function(listener) {
if (listener && listener[name]) {
if (asyncNotifications) {
asyncNotifications.cb[_DYN_PUSH$1]({
fn: callback,
arg: listener
});
asyncNotifications.h = asyncNotifications.h || scheduleTimeout(_runScheduledListeners, 0, asyncNotifications);
} else {
safe(callback, [listener]);
}
}
});
}
var NotificationManager = (
/** @class */
(function() {
function NotificationManager2(config) {
this.listeners = [];
var perfEvtsSendAll;
var unloadHandler;
var _listeners = [];
var _asyncNotifications = {
h: null,
cb: []
};
var cfgHandler = createDynamicConfig(config, defaultValues$1);
unloadHandler = cfgHandler[_DYN_WATCH](function(details) {
perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
});
dynamicProto(NotificationManager2, this, function(_self) {
objDefine(_self, "listeners", {
g: function() {
return _listeners;
}
});
_self[_DYN_ADD_NOTIFICATION_LIS1] = function(listener) {
_listeners[_DYN_PUSH$1](listener);
};
_self[_DYN_REMOVE_NOTIFICATION_0] = function(listener) {
var index = arrIndexOf(_listeners, listener);
while (index > -1) {
_listeners[_DYN_SPLICE](index, 1);
index = arrIndexOf(_listeners, listener);
}
};
_self[STR_EVENTS_SENT] = function(events) {
_runListeners(_listeners, STR_EVENTS_SENT, _asyncNotifications, function(listener) {
listener[STR_EVENTS_SENT](events);
});
};
_self[STR_EVENTS_DISCARDED] = function(events, reason) {
_runListeners(_listeners, STR_EVENTS_DISCARDED, _asyncNotifications, function(listener) {
listener[STR_EVENTS_DISCARDED](events, reason);
});
};
_self[STR_EVENTS_SEND_REQUEST] = function(sendReason, isAsync) {
_runListeners(_listeners, STR_EVENTS_SEND_REQUEST, isAsync ? _asyncNotifications : null, function(listener) {
listener[STR_EVENTS_SEND_REQUEST](sendReason, isAsync);
});
};
_self[STR_PERF_EVENT] = function(perfEvent) {
if (perfEvent) {
if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT]()) {
_runListeners(_listeners, STR_PERF_EVENT, null, function(listener) {
if (perfEvent.isAsync) {
scheduleTimeout(function() {
return listener[STR_PERF_EVENT](perfEvent);
}, 0);
} else {
listener[STR_PERF_EVENT](perfEvent);
}
});
}
}
};
_self[STR_OFFLINE_STORE] = function(events) {
if (events && events[_DYN_LENGTH$2]) {
_runListeners(_listeners, STR_OFFLINE_STORE, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_STORE](events);
});
}
};
_self[STR_OFFLINE_SENT] = function(batch) {
if (batch && batch[_DYN_DATA$1]) {
_runListeners(_listeners, STR_OFFLINE_SENT, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_SENT](batch);
});
}
};
_self[STR_OFFLINE_DROP] = function(cnt, reason) {
if (cnt > 0) {
var rn_1 = reason || 0;
_runListeners(_listeners, STR_OFFLINE_DROP, _asyncNotifications, function(listener) {
listener[STR_OFFLINE_DROP](cnt, rn_1);
});
}
};
_self[_DYN_UNLOAD] = function(isAsync) {
var _finishUnload = function() {
unloadHandler && unloadHandler.rm();
unloadHandler = null;
_listeners = [];
_asyncNotifications.h && _asyncNotifications.h[_DYN_CANCEL]();
_asyncNotifications.h = null;
_asyncNotifications.cb = [];
};
var waiting;
_runListeners(_listeners, "unload", null, function(listener) {
var asyncUnload = listener[_DYN_UNLOAD](isAsync);
if (asyncUnload) {
if (!waiting) {
waiting = [];
}
waiting[_DYN_PUSH$1](asyncUnload);
}
});
if (waiting) {
return createPromise(function(resolve3) {
return doAwaitResponse(createAllPromise(waiting), function() {
_finishUnload();
resolve3();
});
});
} else {
_finishUnload();
}
};
});
}
NotificationManager2.__ieDyn = 1;
return NotificationManager2;
})()
);
var strExecutionContextKey = "ctx";
var strParentContextKey = "ParentContextKey";
var strChildrenContextKey = "ChildrenContextKey";
var _defaultPerfManager = null;
var PerfEvent = (
/** @class */
(function() {
function PerfEvent2(name, payloadDetails, isAsync) {
var _self = this;
_self.start = /* @__PURE__ */ utcNow();
_self[_DYN_NAME$2] = name;
_self.isAsync = isAsync;
_self[_DYN_IS_CHILD_EVT] = function() {
return false;
};
if (isFunction(payloadDetails)) {
var theDetails_1;
objDefine(_self, "payload", {
g: function() {
if (!theDetails_1 && isFunction(payloadDetails)) {
theDetails_1 = payloadDetails();
payloadDetails = null;
}
return theDetails_1;
}
});
}
_self[_DYN_GET_CTX] = function(key) {
if (key) {
if (key === PerfEvent2[strParentContextKey] || key === PerfEvent2[strChildrenContextKey]) {
return _self[key];
}
return (_self[strExecutionContextKey] || {})[key];
}
return null;
};
_self[_DYN_SET_CTX] = function(key, value) {
if (key) {
if (key === PerfEvent2[strParentContextKey]) {
if (!_self[key]) {
_self[_DYN_IS_CHILD_EVT] = function() {
return true;
};
}
_self[key] = value;
} else if (key === PerfEvent2[strChildrenContextKey]) {
_self[key] = value;
} else {
var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
ctx[key] = value;
}
}
};
_self.complete = function() {
var childTime = 0;
var childEvts = _self[_DYN_GET_CTX](PerfEvent2[strChildrenContextKey]);
if (isArray(childEvts)) {
for (var lp = 0; lp < childEvts[_DYN_LENGTH$2]; lp++) {
var childEvt = childEvts[lp];
if (childEvt) {
childTime += childEvt.time;
}
}
}
_self.time = /* @__PURE__ */ utcNow() - _self.start;
_self.exTime = _self.time - childTime;
_self.complete = function() {
};
};
}
PerfEvent2.ParentContextKey = "parent";
PerfEvent2.ChildrenContextKey = "childEvts";
return PerfEvent2;
})()
);
var PerfManager = (
/** @class */
(function() {
function PerfManager2(manager) {
this.ctx = {};
dynamicProto(PerfManager2, this, function(_self) {
_self.create = function(src, payloadDetails, isAsync) {
return new PerfEvent(src, payloadDetails, isAsync);
};
_self.fire = function(perfEvent) {
if (perfEvent) {
perfEvent.complete();
if (manager && isFunction(manager[STR_PERF_EVENT])) {
manager[STR_PERF_EVENT](perfEvent);
}
}
};
_self[_DYN_SET_CTX] = function(key, value) {
if (key) {
var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
ctx[key] = value;
}
};
_self[_DYN_GET_CTX] = function(key) {
return (_self[strExecutionContextKey] || {})[key];
};
});
}
PerfManager2.__ieDyn = 1;
return PerfManager2;
})()
);
var doPerfActiveKey = "CoreUtils.doPerf";
function doPerf(mgrSource, getSource, func, details, isAsync) {
if (mgrSource) {
var perfMgr = mgrSource;
if (perfMgr[STR_GET_PERF_MGR]) {
perfMgr = perfMgr[STR_GET_PERF_MGR]();
}
if (perfMgr) {
var perfEvt = void 0;
var currentActive = perfMgr[_DYN_GET_CTX](doPerfActiveKey);
try {
perfEvt = perfMgr.create(getSource(), details, isAsync);
if (perfEvt) {
if (currentActive && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX](PerfEvent[strParentContextKey], currentActive);
if (currentActive[_DYN_GET_CTX] && currentActive[_DYN_SET_CTX]) {
var children = currentActive[_DYN_GET_CTX](PerfEvent[strChildrenContextKey]);
if (!children) {
children = [];
currentActive[_DYN_SET_CTX](PerfEvent[strChildrenContextKey], children);
}
children[_DYN_PUSH$1](perfEvt);
}
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, perfEvt);
return func(perfEvt);
}
} catch (ex) {
if (perfEvt && perfEvt[_DYN_SET_CTX]) {
perfEvt[_DYN_SET_CTX]("exception", ex);
}
} finally {
if (perfEvt) {
perfMgr.fire(perfEvt);
}
perfMgr[_DYN_SET_CTX](doPerfActiveKey, currentActive);
}
}
}
return func();
}
function getGblPerfMgr() {
return _defaultPerfManager;
}
var INVALID_TRACE_ID = "00000000000000000000000000000000";
var INVALID_SPAN_ID = "0000000000000000";
function _isValid(value, len, invalidValue) {
if (value && value[_DYN_LENGTH$2] === len && value !== invalidValue) {
return !!value.match(/^[\da-f]*$/i);
}
return false;
}
function isValidTraceId(value) {
return _isValid(value, 32, INVALID_TRACE_ID);
}
function isValidSpanId(value) {
return _isValid(value, 16, INVALID_SPAN_ID);
}
var pluginStateData = createElmNodeData("plugin");
function _getPluginState(plugin) {
return pluginStateData.get(plugin, "state", {}, true);
}
function initializePlugins(processContext, extensions3) {
var initPlugins = [];
var lastPlugin = null;
var proxy = processContext[_DYN_GET_NEXT]();
var pluginState;
while (proxy) {
var thePlugin = proxy[_DYN_GET_PLUGIN]();
if (thePlugin) {
if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN] && thePlugin[STR_PROCESS_TELEMETRY]) {
lastPlugin[_DYN_SET_NEXT_PLUGIN](thePlugin);
}
pluginState = _getPluginState(thePlugin);
var isInitialized = !!pluginState[_DYN_IS_INITIALIZED];
if (thePlugin[_DYN_IS_INITIALIZED]) {
isInitialized = thePlugin[_DYN_IS_INITIALIZED]();
}
if (!isInitialized) {
initPlugins[_DYN_PUSH$1](thePlugin);
}
lastPlugin = thePlugin;
proxy = proxy[_DYN_GET_NEXT]();
}
}
arrForEach(initPlugins, function(thePlugin2) {
var core = processContext[STR_CORE]();
thePlugin2[_DYN_INITIALIZE$1](processContext.getCfg(), core, extensions3, processContext[_DYN_GET_NEXT]());
pluginState = _getPluginState(thePlugin2);
if (!thePlugin2[STR_CORE] && !pluginState[STR_CORE]) {
pluginState[STR_CORE] = core;
}
pluginState[_DYN_IS_INITIALIZED] = true;
delete pluginState[_DYN_TEARDOWN];
});
}
function sortPlugins(plugins) {
return plugins.sort(function(extA, extB) {
var result = 0;
if (extB) {
var bHasProcess = extB[STR_PROCESS_TELEMETRY];
if (extA[STR_PROCESS_TELEMETRY]) {
result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;
} else if (bHasProcess) {
result = -1;
}
} else {
result = extA ? 1 : -1;
}
return result;
});
}
function createDistributedTraceContext(parentCtx) {
var trace = {};
return {
getName: function() {
return trace[_DYN_NAME$2];
},
setName: function(newValue) {
parentCtx && parentCtx.setName(newValue);
trace[_DYN_NAME$2] = newValue;
},
getTraceId: function() {
return trace.traceId;
},
setTraceId: function(newValue) {
parentCtx && parentCtx.setTraceId(newValue);
if (isValidTraceId(newValue)) {
trace.traceId = newValue;
}
},
getSpanId: function() {
return trace.spanId;
},
setSpanId: function(newValue) {
parentCtx && parentCtx.setSpanId(newValue);
if (isValidSpanId(newValue)) {
trace.spanId = newValue;
}
},
getTraceFlags: function() {
return trace[_DYN_TRACE_FLAGS];
},
setTraceFlags: function(newTraceFlags) {
parentCtx && parentCtx.setTraceFlags(newTraceFlags);
trace[_DYN_TRACE_FLAGS] = newTraceFlags;
}
};
}
var strTelemetryPluginChain = "TelemetryPluginChain";
var strHasRunFlags = "_hasRun";
var strGetTelCtx = "_getTelCtx";
var _chainId = 0;
function _getNextProxyStart(proxy, core, startAt) {
while (proxy) {
if (proxy[_DYN_GET_PLUGIN]() === startAt) {
return proxy;
}
proxy = proxy[_DYN_GET_NEXT]();
}
return createTelemetryProxyChain([startAt], core.config || {}, core);
}
function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
var _nextProxy = null;
var _onComplete = [];
if (!dynamicHandler) {
dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER]);
}
if (startAt !== null) {
_nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
}
var context = {
_next: _moveNext,
ctx: {
core: function() {
return core;
},
diagLog: function() {
return safeGetLogger(core, dynamicHandler.cfg);
},
getCfg: function() {
return dynamicHandler.cfg;
},
getExtCfg: _resolveExtCfg,
getConfig: _getConfig,
hasNext: function() {
return !!_nextProxy;
},
getNext: function() {
return _nextProxy;
},
setNext: function(nextPlugin) {
_nextProxy = nextPlugin;
},
iterate: _iterateChain,
onComplete: _addOnComplete
}
};
function _addOnComplete(onComplete, that) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
if (onComplete) {
_onComplete[_DYN_PUSH$1]({
func: onComplete,
self: !/* @__PURE__ */ isUndefined(that) ? that : context.ctx,
args
});
}
}
function _moveNext() {
var nextProxy = _nextProxy;
_nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT]() : null;
if (!nextProxy) {
var onComplete = _onComplete;
if (onComplete && onComplete[_DYN_LENGTH$2] > 0) {
arrForEach(onComplete, function(completeDetails) {
try {
completeDetails.func.call(completeDetails.self, completeDetails.args);
} catch (e) {
_throwInternal(core[_DYN_LOGGER], 2, 73, "Unexpected Exception during onComplete - " + /* @__PURE__ */ dumpObj(e));
}
});
_onComplete = [];
}
}
return nextProxy;
}
function _getExtCfg(identifier, createIfMissing) {
var idCfg = null;
var cfg = dynamicHandler.cfg;
if (cfg && identifier) {
var extCfg = cfg[STR_EXTENSION_CONFIG];
if (!extCfg && createIfMissing) {
extCfg = {};
}
cfg[STR_EXTENSION_CONFIG] = extCfg;
extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
if (extCfg) {
idCfg = extCfg[identifier];
if (!idCfg && createIfMissing) {
idCfg = {};
}
extCfg[identifier] = idCfg;
idCfg = dynamicHandler.ref(extCfg, identifier);
}
}
return idCfg;
}
function _resolveExtCfg(identifier, defaultValues2) {
var newConfig = _getExtCfg(identifier, true);
if (defaultValues2) {
objForEachKey(defaultValues2, function(field, defaultValue) {
if (/* @__PURE__ */ isNullOrUndefined(newConfig[field])) {
var cfgValue = dynamicHandler.cfg[field];
if (cfgValue || !/* @__PURE__ */ isNullOrUndefined(cfgValue)) {
newConfig[field] = cfgValue;
}
}
_applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
});
}
return dynamicHandler.setDf(newConfig, defaultValues2);
}
function _getConfig(identifier, field, defaultValue) {
if (defaultValue === void 0) {
defaultValue = false;
}
var theValue;
var extConfig = _getExtCfg(identifier, false);
var rootConfig = dynamicHandler.cfg;
if (extConfig && (extConfig[field] || !/* @__PURE__ */ isNullOrUndefined(extConfig[field]))) {
theValue = extConfig[field];
} else if (rootConfig[field] || !/* @__PURE__ */ isNullOrUndefined(rootConfig[field])) {
theValue = rootConfig[field];
}
return theValue || !/* @__PURE__ */ isNullOrUndefined(theValue) ? theValue : defaultValue;
}
function _iterateChain(cb) {
var nextPlugin;
while (!!(nextPlugin = context._next())) {
var plugin = nextPlugin[_DYN_GET_PLUGIN]();
if (plugin) {
cb(plugin);
}
}
}
return context;
}
function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
var config = createDynamicConfig(cfg);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(env2) {
var nextPlugin = internalContext._next();
if (nextPlugin) {
nextPlugin[STR_PROCESS_TELEMETRY](env2, context);
}
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT](), config.cfg, core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(unloadState) {
var nextPlugin = internalContext._next();
nextPlugin && nextPlugin[_DYN_UNLOAD](context, unloadState);
return !nextPlugin;
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
var config = createDynamicConfig(core.config);
var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
var context = internalContext.ctx;
function _processNext(updateState) {
return context.iterate(function(plugin) {
if (isFunction(plugin[_DYN_UPDATE])) {
plugin[_DYN_UPDATE](context, updateState);
}
});
}
function _createNew(plugins, startAt2) {
if (plugins === void 0) {
plugins = null;
}
if (isArray(plugins)) {
plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt2);
}
return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT](), core, startAt2);
}
context[_DYN_PROCESS_NEXT] = _processNext;
context[_DYN_CREATE_NEW] = _createNew;
return context;
}
function createTelemetryProxyChain(plugins, config, core, startAt) {
var firstProxy = null;
var add = startAt ? false : true;
if (isArray(plugins) && plugins[_DYN_LENGTH$2] > 0) {
var lastProxy_1 = null;
arrForEach(plugins, function(thePlugin) {
if (!add && startAt === thePlugin) {
add = true;
}
if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY])) {
var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
if (!firstProxy) {
firstProxy = newProxy;
}
if (lastProxy_1) {
lastProxy_1._setNext(newProxy);
}
lastProxy_1 = newProxy;
}
});
}
if (startAt && !firstProxy) {
return createTelemetryProxyChain([startAt], config, core);
}
return firstProxy;
}
function createTelemetryPluginProxy(plugin, config, core) {
var nextProxy = null;
var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY]);
var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN]);
var chainId;
if (plugin) {
chainId = plugin[_DYN_IDENTIFIER] + "-" + plugin[STR_PRIORITY] + "-" + _chainId++;
} else {
chainId = "Unknown-0-" + _chainId++;
}
var proxyChain = {
getPlugin: function() {
return plugin;
},
getNext: function() {
return nextProxy;
},
processTelemetry: _processTelemetry,
unload: _unloadPlugin,
update: _updatePlugin,
_id: chainId,
_setNext: function(nextPlugin) {
nextProxy = nextPlugin;
}
};
function _getTelCtx() {
var itemCtx;
if (plugin && isFunction(plugin[strGetTelCtx])) {
itemCtx = plugin[strGetTelCtx]();
}
if (!itemCtx) {
itemCtx = createProcessTelemetryContext(proxyChain, config, core);
}
return itemCtx;
}
function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
var hasRun = false;
var identifier = plugin ? plugin[_DYN_IDENTIFIER] : strTelemetryPluginChain;
var hasRunContext = itemCtx[strHasRunFlags];
if (!hasRunContext) {
hasRunContext = itemCtx[strHasRunFlags] = {};
}
itemCtx.setNext(nextProxy);
if (plugin) {
doPerf(itemCtx[STR_CORE](), function() {
return identifier + ":" + name;
}, function() {
hasRunContext[chainId] = true;
try {
var nextId = nextProxy ? nextProxy._id : STR_EMPTY$1;
if (nextId) {
hasRunContext[nextId] = false;
}
hasRun = processPluginFn(itemCtx);
} catch (error) {
var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
if (hasNextRun) {
hasRun = true;
}
if (!nextProxy || !hasNextRun) {
_throwInternal(itemCtx[_DYN_DIAG_LOG$1](), 1, 73, "Plugin [" + identifier + "] failed during " + name + " - " + /* @__PURE__ */ dumpObj(error) + ", run flags: " + /* @__PURE__ */ dumpObj(hasRunContext));
}
}
}, details, isAsync);
}
return hasRun;
}
function _processTelemetry(env2, itemCtx) {
itemCtx = itemCtx || _getTelCtx();
function _callProcessTelemetry(itemCtx2) {
if (!plugin || !hasProcessTelemetry) {
return false;
}
var pluginState = _getPluginState(plugin);
if (pluginState[_DYN_TEARDOWN] || pluginState[STR_DISABLED]) {
return false;
}
if (hasSetNext) {
plugin[_DYN_SET_NEXT_PLUGIN](nextProxy);
}
plugin[STR_PROCESS_TELEMETRY](env2, itemCtx2);
return true;
}
if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function() {
return { item: env2 };
}, !env2.sync)) {
itemCtx[_DYN_PROCESS_NEXT](env2);
}
}
function _unloadPlugin(unloadCtx, unloadState) {
function _callTeardown() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
pluginState[STR_CORE] = null;
pluginState[_DYN_TEARDOWN] = true;
pluginState[_DYN_IS_INITIALIZED] = false;
if (plugin[_DYN_TEARDOWN] && plugin[_DYN_TEARDOWN](unloadCtx, unloadState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(unloadCtx, _callTeardown, "unload", function() {
}, unloadState.isAsync)) {
unloadCtx[_DYN_PROCESS_NEXT](unloadState);
}
}
function _updatePlugin(updateCtx, updateState) {
function _callUpdate() {
var hasRun = false;
if (plugin) {
var pluginState = _getPluginState(plugin);
var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE];
if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN]) {
if (plugin[_DYN_UPDATE] && plugin[_DYN_UPDATE](updateCtx, updateState) === true) {
hasRun = true;
}
}
}
return hasRun;
}
if (!_processChain(updateCtx, _callUpdate, "update", function() {
}, false)) {
updateCtx[_DYN_PROCESS_NEXT](updateState);
}
}
return objFreeze(proxyChain);
}
function createUnloadHandlerContainer() {
var handlers = [];
function _addHandler(handler) {
if (handler) {
handlers[_DYN_PUSH$1](handler);
}
}
function _runHandlers(unloadCtx, unloadState) {
arrForEach(handlers, function(handler) {
try {
handler(unloadCtx, unloadState);
} catch (e) {
_throwInternal(unloadCtx[_DYN_DIAG_LOG$1](), 2, 73, "Unexpected error calling unload handler - " + /* @__PURE__ */ dumpObj(e));
}
});
handlers = [];
}
return {
add: _addHandler,
run: _runHandlers
};
}
function createUnloadHookContainer() {
var _hooks = [];
function _doUnload(logger2) {
var oldHooks = _hooks;
_hooks = [];
arrForEach(oldHooks, function(fn) {
try {
(fn.rm || fn.remove).call(fn);
} catch (e) {
_throwInternal(logger2, 2, 73, "Unloading:" + /* @__PURE__ */ dumpObj(e));
}
});
}
function _addHook(hooks) {
if (hooks) {
arrAppend(_hooks, hooks);
}
}
return {
run: _doUnload,
add: _addHook
};
}
var _a$3;
var strGetPlugin = "getPlugin";
var defaultValues = (_a$3 = {}, _a$3[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} }, _a$3);
var BaseTelemetryPlugin = (
/** @class */
(function() {
function BaseTelemetryPlugin2() {
var _self = this;
var _isinitialized;
var _rootCtx;
var _nextPlugin;
var _unloadHandlerContainer;
var _hookContainer;
_initDefaults();
dynamicProto(BaseTelemetryPlugin2, _self, function(_self2) {
_self2[_DYN_INITIALIZE$1] = function(config, core, extensions3, pluginChain) {
_setDefaults(config, core, pluginChain);
_isinitialized = true;
};
_self2[_DYN_TEARDOWN] = function(unloadCtx, unloadState) {
var core = _self2[STR_CORE];
if (!core || unloadCtx && core !== unloadCtx[STR_CORE]()) {
return;
}
var result;
var unloadDone = false;
var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUnloadState = unloadState || {
reason: 0,
isAsync: false
};
function _unloadCallback() {
if (!unloadDone) {
unloadDone = true;
_unloadHandlerContainer.run(theUnloadCtx, unloadState);
_hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG$1]());
if (result === true) {
theUnloadCtx[_DYN_PROCESS_NEXT](theUnloadState);
}
_initDefaults();
}
}
if (!_self2[_DYN__DO_TEARDOWN] || _self2[_DYN__DO_TEARDOWN](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
_unloadCallback();
} else {
result = true;
}
return result;
};
_self2[_DYN_UPDATE] = function(updateCtx, updateState) {
var core = _self2[STR_CORE];
if (!core || updateCtx && core !== updateCtx[STR_CORE]()) {
return;
}
var result;
var updateDone = false;
var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
var theUpdateState = updateState || {
reason: 0
};
function _updateCallback() {
if (!updateDone) {
updateDone = true;
_setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT]());
}
}
if (!_self2._doUpdate || _self2._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
_updateCallback();
} else {
result = true;
}
return result;
};
proxyFunctionAs(_self2, "_addUnloadCb", function() {
return _unloadHandlerContainer;
}, "add");
proxyFunctionAs(_self2, "_addHook", function() {
return _hookContainer;
}, "add");
objDefine(_self2, "_unloadHooks", { g: function() {
return _hookContainer;
} });
});
_self[_DYN_DIAG_LOG$1] = function(itemCtx) {
return _getTelCtx(itemCtx)[_DYN_DIAG_LOG$1]();
};
_self[_DYN_IS_INITIALIZED] = function() {
return _isinitialized;
};
_self.setInitialized = function(isInitialized) {
_isinitialized = isInitialized;
};
_self[_DYN_SET_NEXT_PLUGIN] = function(next) {
_nextPlugin = next;
};
_self[_DYN_PROCESS_NEXT] = function(env2, itemCtx) {
if (itemCtx) {
itemCtx[_DYN_PROCESS_NEXT](env2);
} else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY])) {
_nextPlugin[STR_PROCESS_TELEMETRY](env2, null);
}
};
_self._getTelCtx = _getTelCtx;
function _getTelCtx(currentCtx) {
if (currentCtx === void 0) {
currentCtx = null;
}
var itemCtx = currentCtx;
if (!itemCtx) {
var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE]);
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin[strGetPlugin]);
} else {
itemCtx = rootCtx[_DYN_CREATE_NEW](null, _nextPlugin);
}
}
return itemCtx;
}
function _setDefaults(config, core, pluginChain) {
createDynamicConfig(config, defaultValues, safeGetLogger(core));
if (!pluginChain && core) {
pluginChain = core[_DYN_GET_PROCESS_TEL_CONT2]()[_DYN_GET_NEXT]();
}
var nextPlugin = _nextPlugin;
if (_nextPlugin && _nextPlugin[strGetPlugin]) {
nextPlugin = _nextPlugin[strGetPlugin]();
}
_self[STR_CORE] = core;
_rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
}
function _initDefaults() {
_isinitialized = false;
_self[STR_CORE] = null;
_rootCtx = null;
_nextPlugin = null;
_hookContainer = createUnloadHookContainer();
_unloadHandlerContainer = createUnloadHandlerContainer();
}
}
BaseTelemetryPlugin2.__ieDyn = 1;
return BaseTelemetryPlugin2;
})()
);
function _addInitializer(_initializers, id, telemetryInitializer) {
var theInitializer = {
id,
fn: telemetryInitializer
};
arrAppend(_initializers, theInitializer);
var handler = {
remove: function() {
arrForEach(_initializers, function(initializer, idx) {
if (initializer.id === theInitializer.id) {
_initializers[_DYN_SPLICE](idx, 1);
return -1;
}
});
}
};
return handler;
}
function _runInitializers(_initializers, item, logger2) {
var doNotSendItem = false;
var telemetryInitializersCount = _initializers[_DYN_LENGTH$2];
for (var i = 0; i < telemetryInitializersCount; ++i) {
var telemetryInitializer = _initializers[i];
if (telemetryInitializer) {
try {
if (telemetryInitializer.fn[_DYN_APPLY](null, [item]) === false) {
doNotSendItem = true;
break;
}
} catch (e) {
_throwInternal(logger2, 2, 64, "Telemetry initializer failed: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) }, true);
}
}
}
return !doNotSendItem;
}
var TelemetryInitializerPlugin = (
/** @class */
(function(_super) {
__extendsFn(TelemetryInitializerPlugin2, _super);
function TelemetryInitializerPlugin2() {
var _this = _super.call(this) || this;
_this.identifier = "TelemetryInitializerPlugin";
_this.priority = 199;
var _id;
var _initializers;
_initDefaults();
dynamicProto(TelemetryInitializerPlugin2, _this, function(_self, _base) {
_self.addTelemetryInitializer = function(telemetryInitializer) {
return _addInitializer(_initializers, _id++, telemetryInitializer);
};
_self[STR_PROCESS_TELEMETRY] = function(item, itemCtx) {
if (_runInitializers(_initializers, item, itemCtx ? itemCtx[_DYN_DIAG_LOG$1]() : _self[_DYN_DIAG_LOG$1]())) {
_self[_DYN_PROCESS_NEXT](item, itemCtx);
}
};
_self[_DYN__DO_TEARDOWN] = function() {
_initDefaults();
};
});
function _initDefaults() {
_id = 0;
_initializers = [];
}
return _this;
}
TelemetryInitializerPlugin2.__ieDyn = 1;
return TelemetryInitializerPlugin2;
})(BaseTelemetryPlugin)
);
var _a$2;
var strValidationError = "Plugins must provide initialize method";
var strNotificationManager = "_notificationManager";
var strSdkUnloadingError = "SDK is still unloading...";
var strSdkNotInitialized = "SDK is not initialized";
var maxInitQueueSize = 100;
var maxInitTimeout = 5e4;
var defaultConfig = objDeepFreeze((_a$2 = {
cookieCfg: {}
}, _a$2[STR_EXTENSIONS] = { rdOnly: true, ref: true, v: [] }, _a$2[STR_CHANNELS] = { rdOnly: true, ref: true, v: [] }, _a$2[STR_EXTENSION_CONFIG] = { ref: true, v: {} }, _a$2[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE$2, _a$2.loggingLevelConsole = 0, _a$2.diagnosticLogInterval = UNDEFINED_VALUE$2, _a$2));
function _createPerfManager(core, notificationMgr) {
return new PerfManager(notificationMgr);
}
function _validateExtensions(logger2, channelPriority, allExtensions) {
var coreExtensions = [];
var channels = [];
var extPriorities = {};
arrForEach(allExtensions, function(ext) {
if (/* @__PURE__ */ isNullOrUndefined(ext) || /* @__PURE__ */ isNullOrUndefined(ext[_DYN_INITIALIZE$1])) {
throwError(strValidationError);
}
var extPriority = ext[STR_PRIORITY];
var identifier = ext[_DYN_IDENTIFIER];
if (ext && extPriority) {
if (!/* @__PURE__ */ isNullOrUndefined(extPriorities[extPriority])) {
_warnToConsole(logger2, "Two extensions have same priority #" + extPriority + " - " + extPriorities[extPriority] + ", " + identifier);
} else {
extPriorities[extPriority] = identifier;
}
}
if (!extPriority || extPriority < channelPriority) {
coreExtensions[_DYN_PUSH$1](ext);
} else {
channels[_DYN_PUSH$1](ext);
}
});
return {
core: coreExtensions,
channels
};
}
function _isPluginPresent(thePlugin, plugins) {
var exists = false;
arrForEach(plugins, function(plugin) {
if (plugin === thePlugin) {
exists = true;
return -1;
}
});
return exists;
}
function _deepMergeConfig(details, target, newValues, merge) {
if (newValues) {
objForEachKey(newValues, function(key, value) {
if (merge) {
if (/* @__PURE__ */ isPlainObject(value) && /* @__PURE__ */ isPlainObject(target[key])) {
_deepMergeConfig(details, target[key], value, merge);
}
}
if (merge && /* @__PURE__ */ isPlainObject(value) && /* @__PURE__ */ isPlainObject(target[key])) {
_deepMergeConfig(details, target[key], value, merge);
} else {
details.set(target, key, value);
}
});
}
}
function _findWatcher(listeners, newWatcher) {
var theListener = null;
var idx = -1;
arrForEach(listeners, function(listener, lp) {
if (listener.w === newWatcher) {
theListener = listener;
idx = lp;
return -1;
}
});
return { i: idx, l: theListener };
}
function _addDelayedCfgListener(listeners, newWatcher) {
var theListener = _findWatcher(listeners, newWatcher).l;
if (!theListener) {
theListener = {
w: newWatcher,
rm: function() {
var fnd = _findWatcher(listeners, newWatcher);
if (fnd.i !== -1) {
listeners[_DYN_SPLICE](fnd.i, 1);
}
}
};
listeners[_DYN_PUSH$1](theListener);
}
return theListener;
}
function _registerDelayedCfgListener(config, listeners, logger2) {
arrForEach(listeners, function(listener) {
var unloadHdl = onConfigChange(config, listener.w, logger2);
delete listener.w;
listener.rm = function() {
unloadHdl.rm();
};
});
}
function _initDebugListener(configHandler, unloadContainer, notificationManager, debugListener) {
unloadContainer.add(configHandler[_DYN_WATCH](function(details) {
var disableDbgExt = details.cfg.disableDbgExt;
if (disableDbgExt === true && debugListener) {
notificationManager[_DYN_REMOVE_NOTIFICATION_0](debugListener);
debugListener = null;
}
if (notificationManager && !debugListener && disableDbgExt !== true) {
debugListener = getDebugListener(details.cfg);
notificationManager[_DYN_ADD_NOTIFICATION_LIS1](debugListener);
}
}));
return debugListener;
}
function _createUnloadHook(unloadHook) {
return objDefine({
rm: function() {
unloadHook.rm();
}
}, "toJSON", { v: function() {
return "aicore::onCfgChange<" + JSON.stringify(unloadHook) + ">";
} });
}
var AppInsightsCore = (
/** @class */
(function() {
function AppInsightsCore2() {
var _configHandler;
var _isInitialized;
var _logger;
var _eventQueue;
var _notificationManager;
var _perfManager;
var _cfgPerfManager;
var _cookieManager;
var _pluginChain;
var _configExtensions;
var _channelConfig;
var _channels;
var _isUnloading;
var _telemetryInitializerPlugin;
var _internalLogsEventName;
var _evtNamespace;
var _unloadHandlers;
var _hookContainer;
var _debugListener2;
var _traceCtx;
var _instrumentationKey;
var _cfgListeners;
var _extensions;
var _pluginVersionStringArr;
var _pluginVersionString;
var _activeStatus;
var _endpoint;
var _initInMemoMaxSize;
var _isStatusSet;
var _initTimer;
var _internalLogPoller;
var _internalLogPollerListening;
var _forceStopInternalLogPoller;
dynamicProto(AppInsightsCore2, this, function(_self) {
_initDefaults();
_self["_getDbgPlgTargets"] = function() {
return [_extensions, _eventQueue];
};
_self[_DYN_IS_INITIALIZED] = function() {
return _isInitialized;
};
_self.activeStatus = function() {
return _activeStatus;
};
_self._setPendingStatus = function() {
_activeStatus = 3;
};
_self[_DYN_INITIALIZE$1] = function(config, extensions3, logger2, notificationManager) {
if (_isUnloading) {
throwError(strSdkUnloadingError);
}
if (_self[_DYN_IS_INITIALIZED]()) {
throwError("Core cannot be initialized more than once");
}
_configHandler = createDynamicConfig(config, defaultConfig, logger2 || _self[_DYN_LOGGER], false);
config = _configHandler.cfg;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var rootCfg = details.cfg;
_initInMemoMaxSize = rootCfg.initInMemoMaxSize || maxInitQueueSize;
_handleIKeyEndpointPromises(rootCfg);
var extCfg = details.ref(details.cfg, STR_EXTENSION_CONFIG);
objForEachKey(extCfg, function(key) {
details.ref(extCfg, key);
});
}));
_notificationManager = notificationManager;
_debugListener2 = _initDebugListener(_configHandler, _hookContainer, _notificationManager && _self[_DYN_GET_NOTIFY_MGR](), _debugListener2);
_initPerfManager();
_self[_DYN_LOGGER] = logger2;
var cfgExtensions = config[STR_EXTENSIONS];
_configExtensions = [];
_configExtensions[_DYN_PUSH$1].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions3, false), cfgExtensions));
_channelConfig = config[STR_CHANNELS];
_initPluginChain(null);
if (!_channels || _channels[_DYN_LENGTH$2] === 0) {
throwError("No " + STR_CHANNELS + " available");
}
if (_channelConfig && _channelConfig[_DYN_LENGTH$2] > 1) {
var teeController = _self[_DYN_GET_PLUGIN]("TeeChannelController");
if (!teeController || !teeController.plugin) {
_throwInternal(_logger, 1, 28, "TeeChannel required");
}
}
_registerDelayedCfgListener(config, _cfgListeners, _logger);
_cfgListeners = null;
_isInitialized = true;
if (_activeStatus === ActiveStatus.ACTIVE) {
_releaseQueues();
}
};
_self.getChannels = function() {
var controls = [];
if (_channels) {
arrForEach(_channels, function(channel) {
controls[_DYN_PUSH$1](channel);
});
}
return objFreeze(controls);
};
_self.track = function(telemetryItem) {
doPerf(_self[STR_GET_PERF_MGR](), function() {
return "AppInsightsCore:track";
}, function() {
if (telemetryItem === null) {
_notifyInvalidEvent(telemetryItem);
throwError("Invalid telemetry item");
}
if (!telemetryItem[_DYN_NAME$2] && /* @__PURE__ */ isNullOrUndefined(telemetryItem[_DYN_NAME$2])) {
_notifyInvalidEvent(telemetryItem);
throwError("telemetry name required");
}
telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;
telemetryItem.time = telemetryItem.time || toISOString(/* @__PURE__ */ new Date());
telemetryItem.ver = telemetryItem.ver || "4.0";
if (!_isUnloading && _self[_DYN_IS_INITIALIZED]() && _activeStatus === ActiveStatus.ACTIVE) {
_createTelCtx()[_DYN_PROCESS_NEXT](telemetryItem);
} else if (_activeStatus !== ActiveStatus.INACTIVE) {
if (_eventQueue[_DYN_LENGTH$2] <= _initInMemoMaxSize) {
_eventQueue[_DYN_PUSH$1](telemetryItem);
}
}
}, function() {
return { item: telemetryItem };
}, !telemetryItem.sync);
};
_self[_DYN_GET_PROCESS_TEL_CONT2] = _createTelCtx;
_self[_DYN_GET_NOTIFY_MGR] = function() {
if (!_notificationManager) {
_notificationManager = new NotificationManager(_configHandler.cfg);
_self[strNotificationManager] = _notificationManager;
}
return _notificationManager;
};
_self[_DYN_ADD_NOTIFICATION_LIS1] = function(listener) {
_self.getNotifyMgr()[_DYN_ADD_NOTIFICATION_LIS1](listener);
};
_self[_DYN_REMOVE_NOTIFICATION_0] = function(listener) {
if (_notificationManager) {
_notificationManager[_DYN_REMOVE_NOTIFICATION_0](listener);
}
};
_self.getCookieMgr = function() {
if (!_cookieManager) {
_cookieManager = createCookieMgr(_configHandler.cfg, _self[_DYN_LOGGER]);
}
return _cookieManager;
};
_self.setCookieMgr = function(cookieMgr) {
if (_cookieManager !== cookieMgr) {
runTargetUnload(_cookieManager, false);
_cookieManager = cookieMgr;
}
};
_self[STR_GET_PERF_MGR] = function() {
return _perfManager || _cfgPerfManager || getGblPerfMgr();
};
_self.setPerfMgr = function(perfMgr) {
_perfManager = perfMgr;
};
_self.eventCnt = function() {
return _eventQueue[_DYN_LENGTH$2];
};
_self.releaseQueue = function() {
if (_isInitialized && _eventQueue[_DYN_LENGTH$2] > 0) {
var eventQueue = _eventQueue;
_eventQueue = [];
if (_activeStatus === 2) {
arrForEach(eventQueue, function(event) {
event.iKey = event.iKey || _instrumentationKey;
_createTelCtx()[_DYN_PROCESS_NEXT](event);
});
} else {
_throwInternal(_logger, 2, 20, "core init status is not active");
}
}
};
_self.pollInternalLogs = function(eventName) {
_internalLogsEventName = eventName || null;
_forceStopInternalLogPoller = false;
_internalLogPoller && _internalLogPoller[_DYN_CANCEL]();
return _startLogPoller(true);
};
function _handleIKeyEndpointPromises(theConfig) {
var ikey = theConfig.instrumentationKey;
var endpointUrl = theConfig.endpointUrl;
if (_activeStatus !== 3) {
if (/* @__PURE__ */ isNullOrUndefined(ikey)) {
_instrumentationKey = null;
_activeStatus = ActiveStatus.INACTIVE;
var msg = "Please provide instrumentation key";
if (!_isInitialized) {
throwError(msg);
} else {
_throwInternal(_logger, 1, 100, msg);
_releaseQueues();
}
return;
}
var promises = [];
if (/* @__PURE__ */ isPromiseLike(ikey)) {
promises[_DYN_PUSH$1](ikey);
_instrumentationKey = null;
} else {
_instrumentationKey = ikey;
}
if (/* @__PURE__ */ isPromiseLike(endpointUrl)) {
promises[_DYN_PUSH$1](endpointUrl);
_endpoint = null;
} else {
_endpoint = endpointUrl;
}
if (promises[_DYN_LENGTH$2]) {
_waitForInitPromises(theConfig, promises);
} else {
_setStatus();
}
}
}
function _waitForInitPromises(theConfig, promises) {
_isStatusSet = false;
_activeStatus = 3;
var initTimeout = isNotNullOrUndefined(theConfig.initTimeOut) ? theConfig.initTimeOut : maxInitTimeout;
var allPromises = createSyncAllSettledPromise(promises);
if (_initTimer) {
_initTimer[_DYN_CANCEL]();
}
_initTimer = scheduleTimeout(function() {
_initTimer = null;
if (!_isStatusSet) {
_setStatus();
}
}, initTimeout);
doAwaitResponse(allPromises, function(response) {
try {
if (_isStatusSet) {
return;
}
if (!response.rejected) {
var values = response[_DYN_VALUE];
if (values && values[_DYN_LENGTH$2]) {
var ikeyRes = values[0];
_instrumentationKey = ikeyRes && ikeyRes[_DYN_VALUE];
if (values[_DYN_LENGTH$2] > 1) {
var endpointRes = values[1];
_endpoint = endpointRes && endpointRes[_DYN_VALUE];
}
}
if (_instrumentationKey) {
theConfig.instrumentationKey = _instrumentationKey;
theConfig.endpointUrl = _endpoint;
}
}
_setStatus();
} catch (e) {
if (!_isStatusSet) {
_setStatus();
}
}
});
}
function _setStatus() {
_isStatusSet = true;
if (/* @__PURE__ */ isNullOrUndefined(_instrumentationKey)) {
_activeStatus = ActiveStatus.INACTIVE;
_throwInternal(_logger, 1, 112, "ikey can't be resolved from promises");
} else {
_activeStatus = ActiveStatus.ACTIVE;
}
_releaseQueues();
}
function _releaseQueues() {
if (_isInitialized) {
_self.releaseQueue();
_self.pollInternalLogs();
}
}
function _startLogPoller(alwaysStart) {
if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED]) && !_forceStopInternalLogPoller) {
var shouldStart = alwaysStart || _logger && _logger.queue[_DYN_LENGTH$2] > 0;
if (shouldStart) {
if (!_internalLogPollerListening) {
_internalLogPollerListening = true;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var interval = details.cfg.diagnosticLogInterval;
if (!interval || !(interval > 0)) {
interval = 1e4;
}
var isRunning = false;
if (_internalLogPoller) {
isRunning = _internalLogPoller[_DYN_ENABLED];
_internalLogPoller[_DYN_CANCEL]();
}
_internalLogPoller = createTimeout(_flushInternalLogs, interval);
_internalLogPoller.unref();
_internalLogPoller[_DYN_ENABLED] = isRunning;
}));
}
_internalLogPoller[_DYN_ENABLED] = true;
}
}
return _internalLogPoller;
}
_self[_DYN_STOP_POLLING_INTERNA3] = function() {
_forceStopInternalLogPoller = true;
_internalLogPoller && _internalLogPoller[_DYN_CANCEL]();
_flushInternalLogs();
};
proxyFunctions(_self, function() {
return _telemetryInitializerPlugin;
}, ["addTelemetryInitializer"]);
_self[_DYN_UNLOAD] = function(isAsync, unloadComplete, cbTimeout) {
if (isAsync === void 0) {
isAsync = true;
}
if (!_isInitialized) {
throwError(strSdkNotInitialized);
}
if (_isUnloading) {
throwError(strSdkUnloadingError);
}
var unloadState = {
reason: 50,
isAsync,
flushComplete: false
};
var result;
if (isAsync && !unloadComplete) {
result = createPromise(function(resolve3) {
unloadComplete = resolve3;
});
}
var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
processUnloadCtx[_DYN_ON_COMPLETE](function() {
_hookContainer.run(_self[_DYN_LOGGER]);
doUnloadAll([_cookieManager, _notificationManager, _logger], isAsync, function() {
_initDefaults();
unloadComplete && unloadComplete(unloadState);
});
}, _self);
function _doUnload(flushComplete) {
unloadState.flushComplete = flushComplete;
_isUnloading = true;
_unloadHandlers.run(processUnloadCtx, unloadState);
_self[_DYN_STOP_POLLING_INTERNA3]();
processUnloadCtx[_DYN_PROCESS_NEXT](unloadState);
}
_flushInternalLogs();
if (!_flushChannels(isAsync, _doUnload, 6, cbTimeout)) ;
return result;
};
_self[_DYN_GET_PLUGIN] = _getPlugin;
_self.addPlugin = function(plugin, replaceExisting, isAsync, addCb) {
if (!plugin) {
addCb && addCb(false);
_logOrThrowError(strValidationError);
return;
}
var existingPlugin = _getPlugin(plugin[_DYN_IDENTIFIER]);
if (existingPlugin && !replaceExisting) {
addCb && addCb(false);
_logOrThrowError("Plugin [" + plugin[_DYN_IDENTIFIER] + "] is already loaded!");
return;
}
var updateState = {
reason: 16
};
function _addPlugin(removed) {
_configExtensions[_DYN_PUSH$1](plugin);
updateState.added = [plugin];
_initPluginChain(updateState);
addCb && addCb(true);
}
if (existingPlugin) {
var removedPlugins_1 = [existingPlugin.plugin];
var unloadState = {
reason: 2,
isAsync: !!isAsync
};
_removePlugins(removedPlugins_1, unloadState, function(removed) {
if (!removed) {
addCb && addCb(false);
} else {
updateState.removed = removedPlugins_1;
updateState.reason |= 32;
_addPlugin();
}
});
} else {
_addPlugin();
}
};
_self.updateCfg = function(newConfig, mergeExisting) {
if (mergeExisting === void 0) {
mergeExisting = true;
}
var updateState;
if (_self[_DYN_IS_INITIALIZED]()) {
updateState = {
reason: 1,
cfg: _configHandler.cfg,
oldCfg: deepExtend({}, _configHandler.cfg),
newConfig: deepExtend({}, newConfig),
merge: mergeExisting
};
newConfig = updateState.newConfig;
var cfg = _configHandler.cfg;
newConfig[STR_EXTENSIONS] = cfg[STR_EXTENSIONS];
newConfig[STR_CHANNELS] = cfg[STR_CHANNELS];
}
_configHandler._block(function(details) {
var theConfig = details.cfg;
_deepMergeConfig(details, theConfig, newConfig, mergeExisting);
if (!mergeExisting) {
objForEachKey(theConfig, function(key) {
if (!objHasOwn(newConfig, key)) {
details.set(theConfig, key, UNDEFINED_VALUE$2);
}
});
}
details.setDf(theConfig, defaultConfig);
}, true);
_configHandler.notify();
if (updateState) {
_doUpdate(updateState);
}
};
_self.evtNamespace = function() {
return _evtNamespace;
};
_self.flush = _flushChannels;
_self.getTraceCtx = function(createNew) {
if (!_traceCtx) {
_traceCtx = createDistributedTraceContext();
}
return _traceCtx;
};
_self.setTraceCtx = function(traceCtx) {
_traceCtx = traceCtx || null;
};
_self.addUnloadHook = _addUnloadHook;
proxyFunctionAs(_self, "addUnloadCb", function() {
return _unloadHandlers;
}, "add");
_self.onCfgChange = function(handler) {
var unloadHook;
if (!_isInitialized) {
unloadHook = _addDelayedCfgListener(_cfgListeners, handler);
} else {
unloadHook = onConfigChange(_configHandler.cfg, handler, _self[_DYN_LOGGER]);
}
return _createUnloadHook(unloadHook);
};
_self.getWParam = function() {
return /* @__PURE__ */ hasDocument() || !!_configHandler.cfg.enableWParam ? 0 : -1;
};
function _setPluginVersions() {
var thePlugins = {};
_pluginVersionStringArr = [];
var _addPluginVersions = function(plugins) {
if (plugins) {
arrForEach(plugins, function(plugin) {
if (plugin[_DYN_IDENTIFIER] && plugin[_DYN_VERSION] && !thePlugins[plugin.identifier]) {
var ver = plugin[_DYN_IDENTIFIER] + "=" + plugin[_DYN_VERSION];
_pluginVersionStringArr[_DYN_PUSH$1](ver);
thePlugins[plugin.identifier] = plugin;
}
});
}
};
_addPluginVersions(_channels);
if (_channelConfig) {
arrForEach(_channelConfig, function(channels) {
_addPluginVersions(channels);
});
}
_addPluginVersions(_configExtensions);
}
function _initDefaults() {
_isInitialized = false;
_configHandler = createDynamicConfig({}, defaultConfig, _self[_DYN_LOGGER]);
_configHandler.cfg[_DYN_LOGGING_LEVEL_CONSOL4] = 1;
objDefine(_self, "config", {
g: function() {
return _configHandler.cfg;
},
s: function(newValue) {
_self.updateCfg(newValue, false);
}
});
objDefine(_self, "pluginVersionStringArr", {
g: function() {
if (!_pluginVersionStringArr) {
_setPluginVersions();
}
return _pluginVersionStringArr;
}
});
objDefine(_self, "pluginVersionString", {
g: function() {
if (!_pluginVersionString) {
if (!_pluginVersionStringArr) {
_setPluginVersions();
}
_pluginVersionString = _pluginVersionStringArr.join(";");
}
return _pluginVersionString || STR_EMPTY$1;
}
});
objDefine(_self, "logger", {
g: function() {
if (!_logger) {
_logger = new DiagnosticLogger(_configHandler.cfg);
_configHandler[_DYN_LOGGER] = _logger;
}
return _logger;
},
s: function(newLogger) {
_configHandler[_DYN_LOGGER] = newLogger;
if (_logger !== newLogger) {
runTargetUnload(_logger, false);
_logger = newLogger;
}
}
});
_self[_DYN_LOGGER] = new DiagnosticLogger(_configHandler.cfg);
_extensions = [];
var cfgExtensions = _self.config[STR_EXTENSIONS] || [];
cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH$2]);
arrAppend(cfgExtensions, _extensions);
_telemetryInitializerPlugin = new TelemetryInitializerPlugin();
_eventQueue = [];
runTargetUnload(_notificationManager, false);
_notificationManager = null;
_perfManager = null;
_cfgPerfManager = null;
runTargetUnload(_cookieManager, false);
_cookieManager = null;
_pluginChain = null;
_configExtensions = [];
_channelConfig = null;
_channels = null;
_isUnloading = false;
_internalLogsEventName = null;
_evtNamespace = createUniqueNamespace("AIBaseCore", true);
_unloadHandlers = createUnloadHandlerContainer();
_traceCtx = null;
_instrumentationKey = null;
_hookContainer = createUnloadHookContainer();
_cfgListeners = [];
_pluginVersionString = null;
_pluginVersionStringArr = null;
_forceStopInternalLogPoller = false;
_internalLogPoller = null;
_internalLogPollerListening = false;
_activeStatus = 0;
_endpoint = null;
_initInMemoMaxSize = null;
_isStatusSet = false;
_initTimer = null;
}
function _createTelCtx() {
var theCtx = createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
theCtx[_DYN_ON_COMPLETE](_startLogPoller);
return theCtx;
}
function _initPluginChain(updateState) {
var theExtensions = _validateExtensions(_self[_DYN_LOGGER], ChannelControllerPriority, _configExtensions);
_pluginChain = null;
_pluginVersionString = null;
_pluginVersionStringArr = null;
_channels = (_channelConfig || [])[0] || [];
_channels = sortPlugins(arrAppend(_channels, theExtensions[STR_CHANNELS]));
var allExtensions = arrAppend(sortPlugins(theExtensions[STR_CORE]), _channels);
_extensions = objFreeze(allExtensions);
var cfgExtensions = _self.config[STR_EXTENSIONS] || [];
cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH$2]);
arrAppend(cfgExtensions, _extensions);
var rootCtx = _createTelCtx();
if (_channels && _channels[_DYN_LENGTH$2] > 0) {
initializePlugins(rootCtx[_DYN_CREATE_NEW](_channels), allExtensions);
}
initializePlugins(rootCtx, allExtensions);
if (updateState) {
_doUpdate(updateState);
}
}
function _getPlugin(pluginIdentifier) {
var theExt = null;
var thePlugin = null;
var channelHosts = [];
arrForEach(_extensions, function(ext) {
if (ext[_DYN_IDENTIFIER] === pluginIdentifier && ext !== _telemetryInitializerPlugin) {
thePlugin = ext;
return -1;
}
if (ext.getChannel) {
channelHosts[_DYN_PUSH$1](ext);
}
});
if (!thePlugin && channelHosts[_DYN_LENGTH$2] > 0) {
arrForEach(channelHosts, function(host) {
thePlugin = host.getChannel(pluginIdentifier);
if (!thePlugin) {
return -1;
}
});
}
if (thePlugin) {
theExt = {
plugin: thePlugin,
setEnabled: function(enabled) {
_getPluginState(thePlugin)[STR_DISABLED] = !enabled;
},
isEnabled: function() {
var pluginState = _getPluginState(thePlugin);
return !pluginState[_DYN_TEARDOWN] && !pluginState[STR_DISABLED];
},
remove: function(isAsync, removeCb) {
if (isAsync === void 0) {
isAsync = true;
}
var pluginsToRemove = [thePlugin];
var unloadState = {
reason: 1,
isAsync
};
_removePlugins(pluginsToRemove, unloadState, function(removed) {
if (removed) {
_initPluginChain({
reason: 32,
removed: pluginsToRemove
});
}
removeCb && removeCb(removed);
});
}
};
}
return theExt;
}
function _getPluginChain() {
if (!_pluginChain) {
var extensions3 = (_extensions || []).slice();
if (arrIndexOf(extensions3, _telemetryInitializerPlugin) === -1) {
extensions3[_DYN_PUSH$1](_telemetryInitializerPlugin);
}
_pluginChain = createTelemetryProxyChain(sortPlugins(extensions3), _configHandler.cfg, _self);
}
return _pluginChain;
}
function _removePlugins(thePlugins, unloadState, removeComplete) {
if (thePlugins && thePlugins[_DYN_LENGTH$2] > 0) {
var unloadChain = createTelemetryProxyChain(thePlugins, _configHandler.cfg, _self);
var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);
unloadCtx[_DYN_ON_COMPLETE](function() {
var removed = false;
var newConfigExtensions = [];
arrForEach(_configExtensions, function(plugin, idx) {
if (!_isPluginPresent(plugin, thePlugins)) {
newConfigExtensions[_DYN_PUSH$1](plugin);
} else {
removed = true;
}
});
_configExtensions = newConfigExtensions;
_pluginVersionString = null;
_pluginVersionStringArr = null;
var newChannelConfig = [];
if (_channelConfig) {
arrForEach(_channelConfig, function(queue, idx) {
var newQueue = [];
arrForEach(queue, function(channel) {
if (!_isPluginPresent(channel, thePlugins)) {
newQueue[_DYN_PUSH$1](channel);
} else {
removed = true;
}
});
newChannelConfig[_DYN_PUSH$1](newQueue);
});
_channelConfig = newChannelConfig;
}
removeComplete && removeComplete(removed);
_startLogPoller();
});
unloadCtx[_DYN_PROCESS_NEXT](unloadState);
} else {
removeComplete(false);
}
}
function _flushInternalLogs() {
if (_logger && _logger.queue) {
var queue = _logger.queue.slice(0);
_logger.queue[_DYN_LENGTH$2] = 0;
arrForEach(queue, function(logMessage) {
var item = {
name: _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID],
iKey: _instrumentationKey,
time: toISOString(/* @__PURE__ */ new Date()),
baseType: _InternalLogMessage.dataType,
baseData: { message: logMessage[_DYN_MESSAGE$1] }
};
_self.track(item);
});
}
}
function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
var waiting = 1;
var doneIterating = false;
var cbTimer = null;
cbTimeout = cbTimeout || 5e3;
function doCallback() {
waiting--;
if (doneIterating && waiting === 0) {
cbTimer && cbTimer[_DYN_CANCEL]();
cbTimer = null;
callBack && callBack(doneIterating);
callBack = null;
}
}
if (_channels && _channels[_DYN_LENGTH$2] > 0) {
var flushCtx = _createTelCtx()[_DYN_CREATE_NEW](_channels);
flushCtx.iterate(function(plugin) {
if (plugin.flush) {
waiting++;
var handled_1 = false;
if (!plugin.flush(isAsync, function() {
handled_1 = true;
doCallback();
}, sendReason)) {
if (!handled_1) {
if (isAsync && cbTimer == null) {
cbTimer = scheduleTimeout(function() {
cbTimer = null;
doCallback();
}, cbTimeout);
} else {
doCallback();
}
}
}
}
});
}
doneIterating = true;
doCallback();
return true;
}
function _initPerfManager() {
var prevCfgPerfMgr;
_addUnloadHook(_configHandler[_DYN_WATCH](function(details) {
var enablePerfMgr = details.cfg.enablePerfMgr;
if (enablePerfMgr) {
var createPerfMgr = details.cfg[STR_CREATE_PERF_MGR];
if (prevCfgPerfMgr !== createPerfMgr || !prevCfgPerfMgr) {
if (!createPerfMgr) {
createPerfMgr = _createPerfManager;
}
getSetValue(details.cfg, STR_CREATE_PERF_MGR, createPerfMgr);
prevCfgPerfMgr = createPerfMgr;
_cfgPerfManager = null;
}
if (!_perfManager && !_cfgPerfManager && isFunction(createPerfMgr)) {
_cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR]());
}
} else {
_cfgPerfManager = null;
prevCfgPerfMgr = null;
}
}));
}
function _doUpdate(updateState) {
var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);
updateCtx[_DYN_ON_COMPLETE](_startLogPoller);
if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
updateCtx[_DYN_PROCESS_NEXT](updateState);
}
}
function _logOrThrowError(message) {
var logger2 = _self[_DYN_LOGGER];
if (logger2) {
_throwInternal(logger2, 2, 73, message);
_startLogPoller();
} else {
throwError(message);
}
}
function _notifyInvalidEvent(telemetryItem) {
var manager = _self[_DYN_GET_NOTIFY_MGR]();
if (manager) {
manager[STR_EVENTS_DISCARDED]([telemetryItem], 2);
}
}
function _addUnloadHook(hooks) {
_hookContainer.add(hooks);
}
});
}
AppInsightsCore2.__ieDyn = 1;
return AppInsightsCore2;
})()
);
function parseResponse(response, diagLog) {
try {
if (response && response !== "") {
var result = getJSON().parse(response);
if (result && result[_DYN_ITEMS_RECEIVED$1] && result[_DYN_ITEMS_RECEIVED$1] >= result.itemsAccepted && result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH$2]) {
return result;
}
}
} catch (e) {
_throwInternal(diagLog, 1, 43, "Cannot parse the response. " + (e[_DYN_NAME$2] || /* @__PURE__ */ dumpObj(e)), {
response
});
}
return null;
}
var STR_EMPTY = "";
var STR_NO_RESPONSE_BODY = "NoResponseBody";
var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
var STR_POST_METHOD = "POST";
var SenderPostManager = (
/** @class */
(function() {
function SenderPostManager2() {
var _syncFetchPayload = 0;
var _enableSendPromise;
var _isInitialized;
var _diagLog;
var _isOneDs;
var _onCompleteFuncs;
var _disableCredentials;
var _fetchCredentials;
var _fallbackInst;
var _disableXhr;
var _disableBeacon;
var _disableBeaconSync;
var _disableFetchKeepAlive;
var _addNoResponse;
var _timeoutWrapper;
dynamicProto(SenderPostManager2, this, function(_self, _base) {
var _sendCredentials = true;
_initDefaults();
_self[_DYN_INITIALIZE$1] = function(config, diagLog) {
_diagLog = diagLog;
if (_isInitialized) {
_throwInternal(_diagLog, 1, 28, "Sender is already initialized");
}
_self.SetConfig(config);
_isInitialized = true;
};
_self["_getDbgPlgTargets"] = function() {
return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
};
_self.SetConfig = function(config) {
try {
_onCompleteFuncs = config.senderOnCompleteCallBack || {};
_disableCredentials = !!config.disableCredentials;
_fetchCredentials = config.fetchCredentials;
_isOneDs = !!config.isOneDs;
_enableSendPromise = !!config.enableSendPromise;
_disableXhr = !!config.disableXhr;
_disableBeacon = !!config.disableBeacon;
_disableBeaconSync = !!config.disableBeaconSync;
_timeoutWrapper = config.timeWrapper;
_addNoResponse = !!config.addNoResponse;
_disableFetchKeepAlive = !!config.disableFetchKeepAlive;
_fallbackInst = { sendPOST: _xhrSender };
if (!_isOneDs) {
_sendCredentials = false;
}
if (_disableCredentials) {
var location_1 = getLocation();
if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE$1]() === "file:") {
_sendCredentials = false;
}
}
return true;
} catch (e) {
}
return false;
};
_self.getSyncFetchPayload = function() {
return _syncFetchPayload;
};
_self.getSenderInst = function(transports, sync) {
if (transports && transports[_DYN_LENGTH$2]) {
return _getSenderInterface(transports, sync);
}
return null;
};
_self.getFallbackInst = function() {
return _fallbackInst;
};
_self[_DYN__DO_TEARDOWN] = function(unloadCtx, unloadState) {
_initDefaults();
};
_self.preparePayload = function(callback, zipPayload, payload, isSync) {
if (!zipPayload || isSync || !payload[_DYN_DATA$1]) {
callback(payload);
return;
}
try {
var csStream = /* @__PURE__ */ getInst("CompressionStream");
if (!isFunction(csStream)) {
callback(payload);
return;
}
var body = new ReadableStream({
start: function(controller) {
controller.enqueue(isString(payload[_DYN_DATA$1]) ? new TextEncoder().encode(payload[_DYN_DATA$1]) : payload[_DYN_DATA$1]);
controller.close();
}
});
var compressedStream = body.pipeThrough(new csStream("gzip"));
var reader_1 = compressedStream.getReader();
var chunks_1 = [];
var totalLength_1 = 0;
var callbackCalled_1 = false;
doAwaitResponse(reader_1.read(), function processChunk(response) {
if (!callbackCalled_1 && !response.rejected) {
var result = response[_DYN_VALUE];
if (!result.done) {
chunks_1[_DYN_PUSH$1](result[_DYN_VALUE]);
totalLength_1 += result.value[_DYN_LENGTH$2];
return doAwaitResponse(reader_1.read(), processChunk);
}
var combined = new Uint8Array(totalLength_1);
var offset = 0;
for (var _i = 0, chunks_2 = chunks_1; _i < chunks_2.length; _i++) {
var chunk = chunks_2[_i];
combined.set(chunk, offset);
offset += chunk[_DYN_LENGTH$2];
}
payload[_DYN_DATA$1] = combined;
payload[_DYN_HEADERS]["Content-Encoding"] = "gzip";
payload._chunkCount = chunks_1[_DYN_LENGTH$2];
}
if (!callbackCalled_1) {
callbackCalled_1 = true;
callback(payload);
}
});
return reader_1;
} catch (error) {
callback(payload);
return;
}
};
function _onSuccess(res, onComplete) {
_doOnComplete(onComplete, 200, {}, res);
}
function _onError(message, onComplete) {
_throwInternal(_diagLog, 2, 26, "Failed to send telemetry.", { message });
_doOnComplete(onComplete, 400, {});
}
function _onNoPayloadUrl(onComplete) {
_onError("No endpoint url is provided for the batch", onComplete);
}
function _getSenderInterface(transports, syncSupport) {
var transportType = 0;
var sendPostFunc = null;
var lp = 0;
while (sendPostFunc == null && lp < transports[_DYN_LENGTH$2]) {
transportType = transports[lp];
if (!_disableXhr && transportType === 1) {
if (useXDomainRequest()) {
sendPostFunc = _xdrSender;
} else if (isXhrSupported()) {
sendPostFunc = _xhrSender;
}
} else if (transportType === 2 && isFetchSupported(syncSupport) && (!syncSupport || !_disableFetchKeepAlive)) {
sendPostFunc = _doFetchSender;
} else if (transportType === 3 && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
sendPostFunc = _beaconSender;
}
lp++;
}
if (sendPostFunc) {
return {
_transport: transportType,
_isSync: syncSupport,
sendPOST: sendPostFunc
};
}
return null;
}
function _doOnComplete(oncomplete, status, headers, response) {
try {
oncomplete && oncomplete(status, headers, response);
} catch (e) {
}
}
function _doBeaconSend(payload, oncomplete) {
var nav = getNavigator();
var url = payload[_DYN_URL_STRING];
if (!url) {
_onNoPayloadUrl(oncomplete);
return true;
}
url = payload[_DYN_URL_STRING] + (_addNoResponse ? _noResponseQs : STR_EMPTY);
var data = payload[_DYN_DATA$1];
var plainTextBatch = _isOneDs ? data : new Blob([data], { type: "text/plain;charset=UTF-8" });
var queued = nav.sendBeacon(url, plainTextBatch);
return queued;
}
function _beaconSender(payload, oncomplete, sync) {
var data = payload[_DYN_DATA$1];
try {
if (data) {
if (!_doBeaconSend(payload, oncomplete)) {
var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
if (onRetry && isFunction(onRetry)) {
onRetry(payload, oncomplete, _doBeaconSend);
} else {
_fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
_throwInternal(_diagLog, 2, 40, ". Failed to send telemetry with Beacon API, retried with normal sender.");
}
} else {
_onSuccess(STR_EMPTY, oncomplete);
}
}
} catch (e) {
_isOneDs && _warnToConsole(_diagLog, "Failed to send telemetry using sendBeacon API. Ex:" + /* @__PURE__ */ dumpObj(e));
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, STR_EMPTY);
}
return;
}
function _xhrSender(payload, oncomplete, sync) {
var thePromise;
var resolveFunc;
var rejectFunc;
var headers = payload[_DYN_HEADERS] || {};
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (_isOneDs && sync && payload.disableXhrSync) {
sync = false;
}
var endPointUrl = payload[_DYN_URL_STRING];
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
var xhr = openXhr(STR_POST_METHOD, endPointUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT]);
if (!_isOneDs) {
xhr.setRequestHeader("Content-type", "application/json");
}
arrForEach(objKeys(headers), function(headerName) {
xhr.setRequestHeader(headerName, headers[headerName]);
});
xhr.onreadystatechange = function() {
if (!_isOneDs) {
_doOnReadyFunc(xhr);
if (xhr.readyState === 4) {
resolveFunc && resolveFunc(true);
}
}
};
xhr.onload = function() {
if (_isOneDs) {
_doOnReadyFunc(xhr);
}
};
function _doOnReadyFunc(xhr2) {
var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
if (onReadyFuncExist) {
onReadyFunc(xhr2, oncomplete, payload);
} else {
var response = getResponseText(xhr2);
_doOnComplete(oncomplete, xhr2[_DYN_STATUS], _getAllResponseHeaders(xhr2, _isOneDs), response);
}
}
xhr.onerror = function(event) {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 400, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY : formatErrorMessageXhr(xhr));
rejectFunc && rejectFunc(event);
};
xhr.ontimeout = function() {
_doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS] : 500, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY : formatErrorMessageXhr(xhr));
resolveFunc && resolveFunc(false);
};
xhr.send(payload[_DYN_DATA$1]);
return thePromise;
}
function _doFetchSender(payload, oncomplete, sync) {
var _a2;
var endPointUrl = payload[_DYN_URL_STRING];
var batch = payload[_DYN_DATA$1];
var plainTextBatch = _isOneDs ? batch : new Blob([batch], { type: "application/json" });
var thePromise;
var resolveFunc;
var rejectFunc;
var requestHeaders = new Headers();
var batchLength = batch[_DYN_LENGTH$2];
var ignoreResponse = false;
var responseHandled = false;
var headers = payload[_DYN_HEADERS] || {};
var init = (_a2 = {
method: STR_POST_METHOD,
body: plainTextBatch
}, _a2[DisabledPropertyName] = true, _a2);
if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH$2] > 0) {
arrForEach(objKeys(headers), function(headerName) {
requestHeaders.append(headerName, headers[headerName]);
});
init[_DYN_HEADERS] = requestHeaders;
}
if (_fetchCredentials) {
init.credentials = _fetchCredentials;
} else if (_sendCredentials && _isOneDs) {
init.credentials = "include";
}
if (sync) {
init.keepalive = true;
_syncFetchPayload += batchLength;
if (_isOneDs) {
if (payload["_sendReason"] === 2) {
ignoreResponse = true;
if (_addNoResponse) {
endPointUrl += _noResponseQs;
}
}
} else {
ignoreResponse = true;
}
}
var request = new Request(endPointUrl, init);
try {
request[DisabledPropertyName] = true;
} catch (e) {
}
if (!sync && _enableSendPromise) {
thePromise = createPromise(function(resolve3, reject) {
resolveFunc = resolve3;
rejectFunc = reject;
});
}
if (!endPointUrl) {
_onNoPayloadUrl(oncomplete);
resolveFunc && resolveFunc(false);
return;
}
function _handleError(res, statusCode) {
if (statusCode) {
_doOnComplete(oncomplete, _isOneDs ? 0 : statusCode, {}, _isOneDs ? STR_EMPTY : res);
} else {
_doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, _isOneDs ? STR_EMPTY : res);
}
}
function _onFetchComplete(response, payload2, value) {
var status = response[_DYN_STATUS];
var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
if (onCompleteFunc && isFunction(onCompleteFunc)) {
onCompleteFunc(response, oncomplete, value || STR_EMPTY, payload2);
} else {
_doOnComplete(oncomplete, status, {}, value || STR_EMPTY);
}
}
try {
doAwaitResponse(fetch(_isOneDs ? endPointUrl : request, _isOneDs ? init : null), function(result) {
if (sync) {
_syncFetchPayload -= batchLength;
batchLength = 0;
}
if (!responseHandled) {
responseHandled = true;
if (!result.rejected) {
var response_1 = result[_DYN_VALUE];
try {
if (!_isOneDs && !response_1.ok) {
if (response_1[_DYN_STATUS]) {
_handleError(response_1.statusText, response_1[_DYN_STATUS]);
} else {
_handleError(response_1.statusText, 499);
}
resolveFunc && resolveFunc(false);
} else {
if (_isOneDs && !response_1.body) {
_onFetchComplete(response_1, null, STR_EMPTY);
resolveFunc && resolveFunc(true);
} else {
doAwaitResponse(response_1.text(), function(resp) {
_onFetchComplete(response_1, payload, resp[_DYN_VALUE]);
resolveFunc && resolveFunc(true);
});
}
}
} catch (e) {
if (response_1 && response_1[_DYN_STATUS]) {
_handleError(/* @__PURE__ */ dumpObj(e), response_1[_DYN_STATUS]);
} else {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
}
rejectFunc && rejectFunc(e);
}
} else {
_handleError(result.reason && result.reason[_DYN_MESSAGE$1], 499);
rejectFunc && rejectFunc(result.reason);
}
}
});
} catch (e) {
if (!responseHandled) {
_handleError(/* @__PURE__ */ dumpObj(e), 499);
rejectFunc && rejectFunc(e);
}
}
if (ignoreResponse && !responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 200, {});
resolveFunc && resolveFunc(true);
}
if (_isOneDs && !responseHandled && payload[_DYN_TIMEOUT] > 0) {
_timeoutWrapper && _timeoutWrapper.set(function() {
if (!responseHandled) {
responseHandled = true;
_doOnComplete(oncomplete, 500, {});
resolveFunc && resolveFunc(true);
}
}, payload[_DYN_TIMEOUT]);
}
return thePromise;
}
function _xdrSender(payload, oncomplete, sync) {
var _window = getWindow();
var xdr = new XDomainRequest();
var data = payload[_DYN_DATA$1];
xdr.onload = function() {
var response = getResponseText(xdr);
var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
if (onloadFunc && isFunction(onloadFunc)) {
onloadFunc(xdr, oncomplete, payload);
} else {
_doOnComplete(oncomplete, 200, {}, response);
}
};
xdr.onerror = function() {
_doOnComplete(oncomplete, 400, {}, _isOneDs ? STR_EMPTY : formatErrorMessageXdr(xdr));
};
xdr.ontimeout = function() {
_doOnComplete(oncomplete, 500, {});
};
xdr.onprogress = function() {
};
var hostingProtocol = _window && _window.location && _window.location.protocol || "";
var endpoint = payload[_DYN_URL_STRING];
if (!endpoint) {
_onNoPayloadUrl(oncomplete);
return;
}
if (!_isOneDs && endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
_throwInternal(_diagLog, 2, 40, ". " + msg);
_onError(msg, oncomplete);
return;
}
var endpointUrl = _isOneDs ? endpoint : endpoint[_DYN_REPLACE](/^(https?:)/, "");
xdr.open(STR_POST_METHOD, endpointUrl);
if (payload[_DYN_TIMEOUT]) {
xdr[_DYN_TIMEOUT] = payload[_DYN_TIMEOUT];
}
xdr.send(data);
if (_isOneDs && sync) {
_timeoutWrapper && _timeoutWrapper.set(function() {
xdr.send(data);
}, 0);
} else {
xdr.send(data);
}
}
function _initDefaults() {
_syncFetchPayload = 0;
_isInitialized = false;
_enableSendPromise = false;
_diagLog = null;
_isOneDs = null;
_onCompleteFuncs = null;
_disableCredentials = null;
_fetchCredentials = null;
_fallbackInst = null;
_disableXhr = false;
_disableBeacon = false;
_disableBeaconSync = false;
_disableFetchKeepAlive = false;
_addNoResponse = false;
_timeoutWrapper = null;
}
});
}
SenderPostManager2.__ieDyn = 1;
return SenderPostManager2;
})()
);
var strOnPrefix = "on";
var strAttachEvent = "attachEvent";
var strAddEventHelper = "addEventListener";
var strDetachEvent = "detachEvent";
var strRemoveEventListener = "removeEventListener";
var strEvents = "events";
createUniqueNamespace("aiEvtPageHide");
createUniqueNamespace("aiEvtPageShow");
var rRemoveEmptyNs = /\.[\.]+/g;
var rRemoveTrailingEmptyNs = /[\.]+$/;
var _guid = 1;
var elmNodeData = createElmNodeData("events");
var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
function _normalizeNamespace(name) {
if (name && name[_DYN_REPLACE]) {
return name[_DYN_REPLACE](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$1);
}
return name;
}
function _getEvtNamespace(eventName, evtNamespace) {
if (evtNamespace) {
var theNamespace_1 = STR_EMPTY$1;
if (isArray(evtNamespace)) {
theNamespace_1 = STR_EMPTY$1;
arrForEach(evtNamespace, function(name) {
name = _normalizeNamespace(name);
if (name) {
if (name[0] !== ".") {
name = "." + name;
}
theNamespace_1 += name;
}
});
} else {
theNamespace_1 = _normalizeNamespace(evtNamespace);
}
if (theNamespace_1) {
if (theNamespace_1[0] !== ".") {
theNamespace_1 = "." + theNamespace_1;
}
eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
}
}
var parsedEvent = eventNamespace.exec(eventName || STR_EMPTY$1) || [];
return {
type: parsedEvent[1],
ns: (parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT$1](".").sort().join(".")
};
}
function _getRegisteredEvents(target, evtName, addDefault) {
if (addDefault === void 0) {
addDefault = true;
}
var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
var registeredEvents = aiEvts[evtName];
if (!registeredEvents) {
registeredEvents = aiEvts[evtName] = [];
}
return registeredEvents;
}
function _doDetach(obj, evtName, handlerRef, useCapture) {
if (obj && evtName && evtName[_DYN_TYPE]) {
if (obj[strRemoveEventListener]) {
obj[strRemoveEventListener](evtName[_DYN_TYPE], handlerRef, useCapture);
} else if (obj[strDetachEvent]) {
obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
}
}
}
function _doAttach(obj, evtName, handlerRef, useCapture) {
var result = false;
if (obj && evtName && evtName[_DYN_TYPE] && handlerRef) {
if (obj[strAddEventHelper]) {
obj[strAddEventHelper](evtName[_DYN_TYPE], handlerRef, useCapture);
result = true;
} else if (obj[strAttachEvent]) {
obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE], handlerRef);
result = true;
}
}
return result;
}
function _doUnregister(target, events, evtName, unRegFn) {
var idx = events[_DYN_LENGTH$2];
while (idx--) {
var theEvent = events[idx];
if (theEvent) {
if (!evtName.ns || evtName.ns === theEvent[_DYN_EVT_NAME].ns) {
if (!unRegFn || unRegFn(theEvent)) {
_doDetach(target, theEvent[_DYN_EVT_NAME], theEvent.handler, theEvent.capture);
events[_DYN_SPLICE](idx, 1);
}
}
}
}
}
function _unregisterEvents(target, evtName, unRegFn) {
if (evtName[_DYN_TYPE]) {
_doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE]), evtName, unRegFn);
} else {
var eventCache = elmNodeData.get(target, strEvents, {});
objForEachKey(eventCache, function(evtType, events) {
_doUnregister(target, events, evtName, unRegFn);
});
if (objKeys(eventCache)[_DYN_LENGTH$2] === 0) {
elmNodeData.kill(target, strEvents);
}
}
}
function mergeEvtNamespace(theNamespace, namespaces) {
var newNamespaces;
if (namespaces) {
if (isArray(namespaces)) {
newNamespaces = [theNamespace].concat(namespaces);
} else {
newNamespaces = [theNamespace, namespaces];
}
newNamespaces = _getEvtNamespace("xx", newNamespaces).ns[_DYN_SPLIT$1](".");
} else {
newNamespaces = theNamespace;
}
return newNamespaces;
}
function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
var result = false;
if (target) {
try {
var evtName = _getEvtNamespace(eventName, evtNamespace);
result = _doAttach(target, evtName, handlerRef, useCapture);
if (result && elmNodeData.accept(target)) {
var registeredEvent = {
guid: _guid++,
evtName,
handler: handlerRef,
capture: useCapture
};
_getRegisteredEvents(target, evtName.type)[_DYN_PUSH$1](registeredEvent);
}
} catch (e) {
}
}
return result;
}
function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
if (useCapture === void 0) {
useCapture = false;
}
if (target) {
try {
var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
var found_1 = false;
_unregisterEvents(target, evtName_1, function(regEvent) {
if (evtName_1.ns && !handlerRef || regEvent.handler === handlerRef) {
found_1 = true;
return true;
}
return false;
});
if (!found_1) {
_doDetach(target, evtName_1, handlerRef, useCapture);
}
} catch (e) {
}
}
}
var SampleRate = "sampleRate";
var ProcessLegacy = "ProcessLegacy";
var HttpMethod = "http.method";
var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
var DEFAULT_BREEZE_PATH = "/v2/track";
var strNotSpecified = "not_specified";
var RequestHeaders = /* @__PURE__ */ createValueMap({
requestContextHeader: [0, "Request-Context"],
requestContextTargetKey: [1, "appId"],
requestContextAppIdFormat: [2, "appId=cid-v1:"],
requestIdHeader: [3, "Request-Id"],
traceParentHeader: [4, "traceparent"],
traceStateHeader: [5, "tracestate"],
sdkContextHeader: [6, "Sdk-Context"],
sdkContextHeaderAppIdRequest: [7, "appId"],
requestContextHeaderLowerCase: [8, "request-context"]
});
var _DYN_SPLIT = "split";
var _DYN_LENGTH$1 = "length";
var _DYN_TO_LOWER_CASE = "toLowerCase";
var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
var _DYN_TO_STRING$1 = "toString";
var _DYN_REMOVE_ITEM = "removeItem";
var _DYN_MESSAGE = "message";
var _DYN_COUNT$1 = "count";
var _DYN_STRINGIFY$1 = "stringify";
var _DYN_PATHNAME = "pathname";
var _DYN_MATCH = "match";
var _DYN_NAME$1 = "name";
var _DYN_PROPERTIES = "properties";
var _DYN_MEASUREMENTS$1 = "measurements";
var _DYN_SIZE_IN_BYTES = "sizeInBytes";
var _DYN_TYPE_NAME = "typeName";
var _DYN_EXCEPTIONS = "exceptions";
var _DYN_SEVERITY_LEVEL = "severityLevel";
var _DYN_PROBLEM_GROUP = "problemGroup";
var _DYN_PARSED_STACK = "parsedStack";
var _DYN_HAS_FULL_STACK = "hasFullStack";
var _DYN_ASSEMBLY = "assembly";
var _DYN_FILE_NAME = "fileName";
var _DYN_LINE = "line";
var _DYN_AI_DATA_CONTRACT = "aiDataContract";
var _DYN_DURATION = "duration";
function dataSanitizeKeyAndAddUniqueness(logger2, key, map) {
var origLength = key[_DYN_LENGTH$1];
var field = dataSanitizeKey(logger2, key);
if (field[_DYN_LENGTH$1] !== origLength) {
var i = 0;
var uniqueField = field;
while (map[uniqueField] !== void 0) {
i++;
uniqueField = strSubstring(field, 0, 150 - 3) + dsPadNumber(i);
}
field = uniqueField;
}
return field;
}
function dataSanitizeKey(logger2, name) {
var nameTrunc;
if (name) {
name = strTrim(asString(name));
if (name[_DYN_LENGTH$1] > 150) {
nameTrunc = strSubstring(name, 0, 150);
_throwInternal(logger2, 2, 57, "name is too long. It has been truncated to 150 characters.", { name }, true);
}
}
return nameTrunc || name;
}
function dataSanitizeString(logger2, value, maxLength) {
if (maxLength === void 0) {
maxLength = 1024;
}
var valueTrunc;
if (value) {
maxLength = maxLength ? maxLength : 1024;
value = strTrim(asString(value));
if (value[_DYN_LENGTH$1] > maxLength) {
valueTrunc = strSubstring(value, 0, maxLength);
_throwInternal(logger2, 2, 61, "string value is too long. It has been truncated to " + maxLength + " characters.", { value }, true);
}
}
return valueTrunc || value;
}
function dataSanitizeUrl(logger2, url, config) {
if (isString(url)) {
url = fieldRedaction(url, config);
}
return dataSanitizeInput(logger2, url, 2048, 66);
}
function dataSanitizeMessage(logger2, message) {
var messageTrunc;
if (message) {
if (message[_DYN_LENGTH$1] > 32768) {
messageTrunc = strSubstring(message, 0, 32768);
_throwInternal(logger2, 2, 56, "message is too long, it has been truncated to 32768 characters.", { message }, true);
}
}
return messageTrunc || message;
}
function dataSanitizeException(logger2, exception) {
var exceptionTrunc;
if (exception) {
var value = "" + exception;
if (value[_DYN_LENGTH$1] > 32768) {
exceptionTrunc = strSubstring(value, 0, 32768);
_throwInternal(logger2, 2, 52, "exception is too long, it has been truncated to 32768 characters.", { exception }, true);
}
}
return exceptionTrunc || exception;
}
function dataSanitizeProperties(logger2, properties) {
if (properties) {
var tempProps_1 = {};
objForEachKey(properties, function(prop, value) {
if (/* @__PURE__ */ isObject(value) && hasJSON()) {
try {
value = getJSON()[_DYN_STRINGIFY$1](value);
} catch (e) {
_throwInternal(logger2, 2, 49, "custom property is not valid", { exception: e }, true);
}
}
value = dataSanitizeString(logger2, value, 8192);
prop = dataSanitizeKeyAndAddUniqueness(logger2, prop, tempProps_1);
tempProps_1[prop] = value;
});
properties = tempProps_1;
}
return properties;
}
function dataSanitizeMeasurements(logger2, measurements) {
if (measurements) {
var tempMeasurements_1 = {};
objForEachKey(measurements, function(measure, value) {
measure = dataSanitizeKeyAndAddUniqueness(logger2, measure, tempMeasurements_1);
tempMeasurements_1[measure] = value;
});
measurements = tempMeasurements_1;
}
return measurements;
}
function dataSanitizeId(logger2, id) {
return id ? dataSanitizeInput(logger2, id, 128, 69)[_DYN_TO_STRING$1]() : id;
}
function dataSanitizeInput(logger2, input, maxLength, _msgId) {
var inputTrunc;
if (input) {
input = strTrim(asString(input));
if (input[_DYN_LENGTH$1] > maxLength) {
inputTrunc = strSubstring(input, 0, maxLength);
_throwInternal(logger2, 2, _msgId, "input is too long, it has been truncated to " + maxLength + " characters.", { data: input }, true);
}
}
return inputTrunc || input;
}
function dsPadNumber(num) {
var s = "00" + num;
return strSubstr(s, s[_DYN_LENGTH$1] - 3);
}
var _document = getDocument() || {};
var _htmlAnchorIdx = 0;
var _htmlAnchorElement = [null, null, null, null, null];
function urlParseUrl(url) {
var anchorIdx = _htmlAnchorIdx;
var anchorCache = _htmlAnchorElement;
var tempAnchor = anchorCache[anchorIdx];
if (!_document.createElement) {
tempAnchor = { host: urlParseHost(url, true) };
} else if (!anchorCache[anchorIdx]) {
tempAnchor = anchorCache[anchorIdx] = _document.createElement("a");
}
tempAnchor.href = url;
anchorIdx++;
if (anchorIdx >= anchorCache[_DYN_LENGTH$1]) {
anchorIdx = 0;
}
_htmlAnchorIdx = anchorIdx;
return tempAnchor;
}
function urlParseHost(url, inclPort) {
var fullHost = urlParseFullHost(url, inclPort) || "";
if (fullHost) {
var match = fullHost[_DYN_MATCH](/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
if (match != null && match[_DYN_LENGTH$1] > 3 && isString(match[2]) && match[2][_DYN_LENGTH$1] > 0) {
return match[2] + (match[3] || "");
}
}
return fullHost;
}
function urlParseFullHost(url, inclPort) {
var result = null;
if (url) {
var match = url[_DYN_MATCH](/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
if (match != null && match[_DYN_LENGTH$1] > 2 && isString(match[2]) && match[2][_DYN_LENGTH$1] > 0) {
result = match[2] || "";
if (inclPort && match[_DYN_LENGTH$1] > 2) {
var protocol = (match[1] || "")[_DYN_TO_LOWER_CASE]();
var port = match[3] || "";
if (protocol === "http" && port === ":80") {
port = "";
} else if (protocol === "https" && port === ":443") {
port = "";
}
result += port;
}
}
}
return result;
}
var _internalEndpoints = [
DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH,
"https://breeze.aimon.applicationinsights.io" + DEFAULT_BREEZE_PATH,
"https://dc-int.services.visualstudio.com" + DEFAULT_BREEZE_PATH
];
function isInternalApplicationInsightsEndpoint(endpointUrl) {
return arrIndexOf(_internalEndpoints, endpointUrl[_DYN_TO_LOWER_CASE]()) !== -1;
}
function AjaxHelperParseDependencyPath(logger2, absoluteUrl, method, commandName) {
var target, name = commandName, data = commandName;
if (absoluteUrl && absoluteUrl[_DYN_LENGTH$1] > 0) {
var parsedUrl = urlParseUrl(absoluteUrl);
target = parsedUrl.host;
if (!name) {
if (parsedUrl[_DYN_PATHNAME] != null) {
var pathName = parsedUrl.pathname[_DYN_LENGTH$1] === 0 ? "/" : parsedUrl[_DYN_PATHNAME];
if (pathName.charAt(0) !== "/") {
pathName = "/" + pathName;
}
data = parsedUrl[_DYN_PATHNAME];
name = dataSanitizeString(logger2, method ? method + " " + pathName : pathName);
} else {
name = dataSanitizeString(logger2, absoluteUrl);
}
}
} else {
target = commandName;
name = commandName;
}
return {
target,
name,
data
};
}
var StorageType = /* @__PURE__ */ createEnumStyle({
LocalStorage: 0,
SessionStorage: 1
});
var _canUseSessionStorage = void 0;
var _storagePrefix = "";
function _getVerifiedStorageObject(storageType) {
try {
if (/* @__PURE__ */ isNullOrUndefined(getGlobal())) {
return null;
}
var uid = (/* @__PURE__ */ new Date())[_DYN_TO_STRING$1]();
var storage = /* @__PURE__ */ getInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
var name_1 = _storagePrefix + uid;
storage.setItem(name_1, uid);
var fail = storage.getItem(name_1) !== uid;
storage[_DYN_REMOVE_ITEM](name_1);
if (!fail) {
return storage;
}
} catch (exception) {
}
return null;
}
function _getSessionStorageObject() {
if (utlCanUseSessionStorage()) {
return _getVerifiedStorageObject(StorageType.SessionStorage);
}
return null;
}
function utlSetStoragePrefix(storagePrefix) {
_storagePrefix = storagePrefix || "";
}
function utlCanUseSessionStorage(reset) {
if (reset || _canUseSessionStorage === void 0) {
_canUseSessionStorage = !!_getVerifiedStorageObject(StorageType.SessionStorage);
}
return _canUseSessionStorage;
}
function utlGetSessionStorage(logger2, name) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
return storage.getItem(name);
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 2, "Browser failed read of session storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return null;
}
function utlSetSessionStorage(logger2, name, data) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
storage.setItem(name, data);
return true;
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 4, "Browser failed write to session storage. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
function utlRemoveSessionStorage(logger2, name) {
var storage = _getSessionStorageObject();
if (storage !== null) {
try {
storage[_DYN_REMOVE_ITEM](name);
return true;
} catch (e) {
_canUseSessionStorage = false;
_throwInternal(logger2, 2, 6, "Browser failed removal of session storage item. " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
return false;
}
var _FIELDS_SEPARATOR = ";";
var _FIELD_KEY_VALUE_SEPARATOR = "=";
function parseConnectionString(connectionString) {
if (!connectionString) {
return {};
}
var kvPairs = connectionString[_DYN_SPLIT](_FIELDS_SEPARATOR);
var result = arrReduce(kvPairs, function(fields, kv) {
var kvParts = kv[_DYN_SPLIT](_FIELD_KEY_VALUE_SEPARATOR);
if (kvParts[_DYN_LENGTH$1] === 2) {
var key = kvParts[0][_DYN_TO_LOWER_CASE]();
var value = kvParts[1];
fields[key] = value;
}
return fields;
}, {});
if (objKeys(result)[_DYN_LENGTH$1] > 0) {
if (result.endpointsuffix) {
var locationPrefix = result.location ? result.location + "." : "";
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT] || "https://" + locationPrefix + "dc." + result.endpointsuffix;
}
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT] || DEFAULT_BREEZE_ENDPOINT;
if (strEndsWith(result[_DYN_INGESTIONENDPOINT], "/")) {
result[_DYN_INGESTIONENDPOINT] = result[_DYN_INGESTIONENDPOINT].slice(0, -1);
}
}
return result;
}
var Envelope = (
/** @class */
/* @__PURE__ */ (function() {
function Envelope2(logger2, data, name) {
var _this = this;
var _self = this;
_self.ver = 1;
_self.sampleRate = 100;
_self.tags = {};
_self[_DYN_NAME$1] = dataSanitizeString(logger2, name) || strNotSpecified;
_self.data = data;
_self.time = toISOString(/* @__PURE__ */ new Date());
_self[_DYN_AI_DATA_CONTRACT] = {
time: 1,
iKey: 1,
name: 1,
sampleRate: function() {
return _this.sampleRate === 100 ? 4 : 1;
},
tags: 1,
data: 1
};
}
return Envelope2;
})()
);
var Event$1 = (
/** @class */
(function() {
function Event2(logger2, name, properties, measurements) {
this.aiDataContract = {
ver: 1,
name: 1,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
_self[_DYN_NAME$1] = dataSanitizeString(logger2, name) || strNotSpecified;
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
}
Event2.envelopeType = "Microsoft.ApplicationInsights.{0}.Event";
Event2.dataType = "EventData";
return Event2;
})()
);
var STACKFRAME_BASE_SIZE = 58;
var IS_FRAME = /^\s{0,50}(from\s|at\s|Line\s{1,5}\d{1,10}\s{1,5}of|\w{1,50}@\w{1,80}|[^\(\s\n]+:[0-9\?]+(?::[0-9\?]+)?)/;
var FULL_STACK_FRAME_1 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+):([0-9\?]+)\)?$/;
var FULL_STACK_FRAME_2 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+)\)?$/;
var FULL_STACK_FRAME_3 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\)\]]+)\)?$/;
var EXTRACT_FILENAME = /(?:^|\(|\s{0,10}[\w\)]+\@)?([^\(\n\s\]\)]+)(?:\:([0-9]+)(?:\:([0-9]+))?)?\)?(?:,|$)/;
var PARSE_FILENAME_LINE_COL = /([^\(\s\n]+):([0-9]+):([0-9]+)$/;
var PARSE_FILENAME_LINE_ONLY = /([^\(\s\n]+):([0-9]+)$/;
var NoMethod = "<no_method>";
var strError = "error";
var strStack = "stack";
var strStackDetails = "stackDetails";
var strErrorSrc = "errorSrc";
var strMessage = "message";
var strDescription = "description";
var _parseSequence = [
{ re: FULL_STACK_FRAME_1, len: 5, m: 1, fn: 2, ln: 3, col: 4 },
{ chk: _ignoreNative, pre: _scrubAnonymous, re: FULL_STACK_FRAME_2, len: 4, m: 1, fn: 2, ln: 3 },
{ re: FULL_STACK_FRAME_3, len: 3, m: 1, fn: 2, hdl: _handleFilename },
{ re: EXTRACT_FILENAME, len: 2, fn: 1, hdl: _handleFilename }
];
function _scrubAnonymous(frame) {
return frame.replace(/(\(anonymous\))/, "<anonymous>");
}
function _ignoreNative(frame) {
return strIndexOf(frame, "[native") < 0;
}
function _stringify(value, convertToString) {
var result = value;
if (result && !isString(result)) {
if (JSON && JSON[_DYN_STRINGIFY$1]) {
result = JSON[_DYN_STRINGIFY$1](value);
if (convertToString && (!result || result === "{}")) {
if (isFunction(value[_DYN_TO_STRING$1])) {
result = value[_DYN_TO_STRING$1]();
} else {
result = "" + value;
}
}
} else {
result = "" + value + " - (Missing JSON.stringify)";
}
}
return result || "";
}
function _formatMessage(theEvent, errorType) {
var evtMessage = theEvent;
if (theEvent) {
if (evtMessage && !isString(evtMessage)) {
evtMessage = theEvent[strMessage] || theEvent[strDescription] || evtMessage;
}
if (evtMessage && !isString(evtMessage)) {
evtMessage = _stringify(evtMessage, true);
}
if (theEvent["filename"]) {
evtMessage = evtMessage + " @" + (theEvent["filename"] || "") + ":" + (theEvent["lineno"] || "?") + ":" + (theEvent["colno"] || "?");
}
}
if (errorType && errorType !== "String" && errorType !== "Object" && errorType !== "Error" && strIndexOf(evtMessage || "", errorType) === -1) {
evtMessage = errorType + ": " + evtMessage;
}
return evtMessage || "";
}
function _isExceptionDetailsInternal(value) {
try {
if (/* @__PURE__ */ isObject(value)) {
return "hasFullStack" in value && "typeName" in value;
}
} catch (e) {
}
return false;
}
function _isExceptionInternal(value) {
try {
if (/* @__PURE__ */ isObject(value)) {
return "ver" in value && "exceptions" in value && "properties" in value;
}
} catch (e) {
}
return false;
}
function _isStackDetails(details) {
return details && details.src && isString(details.src) && details.obj && isArray(details.obj);
}
function _convertStackObj(errorStack) {
var src = errorStack || "";
if (!isString(src)) {
if (isString(src[strStack])) {
src = src[strStack];
} else {
src = "" + src;
}
}
var items = src[_DYN_SPLIT]("\n");
return {
src,
obj: items
};
}
function _getOperaStack(errorMessage) {
var stack = [];
var lines = errorMessage[_DYN_SPLIT]("\n");
for (var lp = 0; lp < lines[_DYN_LENGTH$1]; lp++) {
var entry = lines[lp];
if (lines[lp + 1]) {
entry += "@" + lines[lp + 1];
lp++;
}
stack.push(entry);
}
return {
src: errorMessage,
obj: stack
};
}
function _getStackFromErrorObj(errorObj) {
var details = null;
if (errorObj) {
try {
if (errorObj[strStack]) {
details = _convertStackObj(errorObj[strStack]);
} else if (errorObj[strError] && errorObj[strError][strStack]) {
details = _convertStackObj(errorObj[strError][strStack]);
} else if (errorObj["exception"] && errorObj.exception[strStack]) {
details = _convertStackObj(errorObj.exception[strStack]);
} else if (_isStackDetails(errorObj)) {
details = errorObj;
} else if (_isStackDetails(errorObj[strStackDetails])) {
details = errorObj[strStackDetails];
} else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
details = _getOperaStack(errorObj[_DYN_MESSAGE]);
} else if (errorObj["reason"] && errorObj.reason[strStack]) {
details = _convertStackObj(errorObj.reason[strStack]);
} else if (isString(errorObj)) {
details = _convertStackObj(errorObj);
} else {
var evtMessage = errorObj[strMessage] || errorObj[strDescription] || "";
if (isString(errorObj[strErrorSrc])) {
if (evtMessage) {
evtMessage += "\n";
}
evtMessage += " from " + errorObj[strErrorSrc];
}
if (evtMessage) {
details = _convertStackObj(evtMessage);
}
}
} catch (e) {
details = _convertStackObj(e);
}
}
return details || {
src: "",
obj: null
};
}
function _formatStackTrace(stackDetails) {
var stack = "";
if (stackDetails) {
if (stackDetails.obj) {
stack = stackDetails.obj.join("\n");
} else {
stack = stackDetails.src || "";
}
}
return stack;
}
function _parseStack(stack) {
var parsedStack;
var frames = stack.obj;
if (frames && frames[_DYN_LENGTH$1] > 0) {
parsedStack = [];
var level_1 = 0;
var foundStackStart_1 = false;
var totalSizeInBytes_1 = 0;
arrForEach(frames, function(frame) {
if (foundStackStart_1 || _isStackFrame(frame)) {
var theFrame = asString(frame);
foundStackStart_1 = true;
var parsedFrame = _extractStackFrame(theFrame, level_1);
if (parsedFrame) {
totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES];
parsedStack.push(parsedFrame);
level_1++;
}
}
});
var exceptionParsedStackThreshold = 32 * 1024;
if (totalSizeInBytes_1 > exceptionParsedStackThreshold) {
var left = 0;
var right = parsedStack[_DYN_LENGTH$1] - 1;
var size = 0;
var acceptedLeft = left;
var acceptedRight = right;
while (left < right) {
var lSize = parsedStack[left][_DYN_SIZE_IN_BYTES];
var rSize = parsedStack[right][_DYN_SIZE_IN_BYTES];
size += lSize + rSize;
if (size > exceptionParsedStackThreshold) {
var howMany = acceptedRight - acceptedLeft + 1;
parsedStack.splice(acceptedLeft, howMany);
break;
}
acceptedLeft = left;
acceptedRight = right;
left++;
right--;
}
}
}
return parsedStack;
}
function _getErrorType(errorType) {
var typeName = "";
if (errorType) {
typeName = errorType.typeName || errorType[_DYN_NAME$1] || "";
if (!typeName) {
try {
var funcNameRegex = /function (.{1,200})\(/;
var results = funcNameRegex.exec(errorType.constructor[_DYN_TO_STRING$1]());
typeName = results && results[_DYN_LENGTH$1] > 1 ? results[1] : "";
} catch (e) {
}
}
}
return typeName;
}
function _formatErrorCode(errorObj) {
if (errorObj) {
try {
if (!isString(errorObj)) {
var errorType = _getErrorType(errorObj);
var result = _stringify(errorObj, false);
if (!result || result === "{}") {
if (errorObj[strError]) {
errorObj = errorObj[strError];
errorType = _getErrorType(errorObj);
}
result = _stringify(errorObj, true);
}
if (strIndexOf(result, errorType) !== 0 && errorType !== "String") {
return errorType + ":" + result;
}
return result;
}
} catch (e) {
}
}
return "" + (errorObj || "");
}
var Exception = (
/** @class */
(function() {
function Exception2(logger2, exception, properties, measurements, severityLevel, id) {
this.aiDataContract = {
ver: 1,
exceptions: 1,
severityLevel: 0,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
if (!_isExceptionInternal(exception)) {
if (!properties) {
properties = {};
}
if (id) {
properties.id = id;
}
_self[_DYN_EXCEPTIONS] = [_createExceptionDetails(logger2, exception, properties)];
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
if (severityLevel) {
_self[_DYN_SEVERITY_LEVEL] = severityLevel;
}
if (id) {
_self.id = id;
}
} else {
_self[_DYN_EXCEPTIONS] = exception[_DYN_EXCEPTIONS] || [];
_self[_DYN_PROPERTIES] = exception[_DYN_PROPERTIES];
_self[_DYN_MEASUREMENTS$1] = exception[_DYN_MEASUREMENTS$1];
if (exception[_DYN_SEVERITY_LEVEL]) {
_self[_DYN_SEVERITY_LEVEL] = exception[_DYN_SEVERITY_LEVEL];
}
if (exception.id) {
_self.id = exception.id;
exception[_DYN_PROPERTIES].id = exception.id;
}
if (exception[_DYN_PROBLEM_GROUP]) {
_self[_DYN_PROBLEM_GROUP] = exception[_DYN_PROBLEM_GROUP];
}
if (!/* @__PURE__ */ isNullOrUndefined(exception.isManual)) {
_self.isManual = exception.isManual;
}
}
}
Exception2.CreateAutoException = function(message, url, lineNumber, columnNumber, error, evt, stack, errorSrc) {
var errorType = _getErrorType(error || evt || message);
return {
message: _formatMessage(message, errorType),
url,
lineNumber,
columnNumber,
error: _formatErrorCode(error || evt || message),
evt: _formatErrorCode(evt || message),
typeName: errorType,
stackDetails: _getStackFromErrorObj(stack || error || evt),
errorSrc
};
};
Exception2.CreateFromInterface = function(logger2, exception, properties, measurements) {
var exceptions = exception[_DYN_EXCEPTIONS] && arrMap(exception[_DYN_EXCEPTIONS], function(ex) {
return _createExDetailsFromInterface(logger2, ex);
});
var exceptionData = new Exception2(logger2, __assignFn(__assignFn({}, exception), { exceptions }), properties, measurements);
return exceptionData;
};
Exception2.prototype.toInterface = function() {
var _a2 = this, exceptions = _a2.exceptions, properties = _a2.properties, measurements = _a2.measurements, severityLevel = _a2.severityLevel, problemGroup = _a2.problemGroup, id = _a2.id, isManual = _a2.isManual;
var exceptionDetailsInterface = exceptions instanceof Array && arrMap(exceptions, function(exception) {
return exception.toInterface();
}) || void 0;
return {
ver: "4.0",
exceptions: exceptionDetailsInterface,
severityLevel,
properties,
measurements,
problemGroup,
id,
isManual
};
};
Exception2.CreateSimpleException = function(message, typeName, assembly, fileName, details, line) {
var _a2;
return {
exceptions: [
(_a2 = {}, _a2[_DYN_HAS_FULL_STACK] = true, _a2.message = message, _a2.stack = details, _a2.typeName = typeName, _a2)
]
};
};
Exception2.envelopeType = "Microsoft.ApplicationInsights.{0}.Exception";
Exception2.dataType = "ExceptionData";
Exception2.formatError = _formatErrorCode;
return Exception2;
})()
);
var exDetailsAiDataContract = objFreeze({
id: 0,
outerId: 0,
typeName: 1,
message: 1,
hasFullStack: 0,
stack: 0,
parsedStack: 2
});
function _toInterface() {
var _self = this;
var parsedStack = isArray(_self[_DYN_PARSED_STACK]) && arrMap(_self[_DYN_PARSED_STACK], function(frame) {
return _parsedFrameToInterface(frame);
});
var exceptionDetailsInterface = {
id: _self.id,
outerId: _self.outerId,
typeName: _self[_DYN_TYPE_NAME],
message: _self[_DYN_MESSAGE],
hasFullStack: _self[_DYN_HAS_FULL_STACK],
stack: _self[strStack],
parsedStack: parsedStack || void 0
};
return exceptionDetailsInterface;
}
function _createExceptionDetails(logger2, exception, properties) {
var _a2;
var id;
var outerId;
var typeName;
var message;
var hasFullStack;
var theStack;
var parsedStack;
if (!_isExceptionDetailsInternal(exception)) {
var error = exception;
var evt = error && error.evt;
if (!isError(error)) {
error = error[strError] || evt || error;
}
typeName = dataSanitizeString(logger2, _getErrorType(error)) || strNotSpecified;
message = dataSanitizeMessage(logger2, _formatMessage(exception || error, typeName)) || strNotSpecified;
var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
parsedStack = _parseStack(stack);
if (isArray(parsedStack)) {
arrMap(parsedStack, function(frame) {
frame[_DYN_ASSEMBLY] = dataSanitizeString(logger2, frame[_DYN_ASSEMBLY]);
frame[_DYN_FILE_NAME] = dataSanitizeString(logger2, frame[_DYN_FILE_NAME]);
});
}
theStack = dataSanitizeException(logger2, _formatStackTrace(stack));
hasFullStack = isArray(parsedStack) && parsedStack[_DYN_LENGTH$1] > 0;
if (properties) {
properties[_DYN_TYPE_NAME] = properties[_DYN_TYPE_NAME] || typeName;
}
} else {
typeName = exception[_DYN_TYPE_NAME];
message = exception[_DYN_MESSAGE];
theStack = exception[strStack];
parsedStack = exception[_DYN_PARSED_STACK] || [];
hasFullStack = exception[_DYN_HAS_FULL_STACK];
}
return _a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = exDetailsAiDataContract, _a2.id = id, _a2.outerId = outerId, _a2.typeName = typeName, _a2.message = message, _a2[_DYN_HAS_FULL_STACK] = hasFullStack, _a2.stack = theStack, _a2.parsedStack = parsedStack, _a2.toInterface = _toInterface, _a2;
}
function _createExDetailsFromInterface(logger2, exception) {
var parsedStack = isArray(exception[_DYN_PARSED_STACK]) && arrMap(exception[_DYN_PARSED_STACK], function(frame) {
return _stackFrameFromInterface(frame);
}) || exception[_DYN_PARSED_STACK];
var exceptionDetails = _createExceptionDetails(logger2, __assignFn(__assignFn({}, exception), { parsedStack }));
return exceptionDetails;
}
function _parseFilename(theFrame, fileName) {
var lineCol = fileName[_DYN_MATCH](PARSE_FILENAME_LINE_COL);
if (lineCol && lineCol[_DYN_LENGTH$1] >= 4) {
theFrame[_DYN_FILE_NAME] = lineCol[1];
theFrame[_DYN_LINE] = parseInt(lineCol[2]);
} else {
var lineNo = fileName[_DYN_MATCH](PARSE_FILENAME_LINE_ONLY);
if (lineNo && lineNo[_DYN_LENGTH$1] >= 3) {
theFrame[_DYN_FILE_NAME] = lineNo[1];
theFrame[_DYN_LINE] = parseInt(lineNo[2]);
} else {
theFrame[_DYN_FILE_NAME] = fileName;
}
}
}
function _handleFilename(theFrame, sequence, matches) {
var filename = theFrame[_DYN_FILE_NAME];
if (sequence.fn && matches && matches[_DYN_LENGTH$1] > sequence.fn) {
if (sequence.ln && matches[_DYN_LENGTH$1] > sequence.ln) {
filename = strTrim(matches[sequence.fn] || "");
theFrame[_DYN_LINE] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
} else {
filename = strTrim(matches[sequence.fn] || "");
}
}
if (filename) {
_parseFilename(theFrame, filename);
}
}
function _isStackFrame(frame) {
var result = false;
if (frame && isString(frame)) {
var trimmedFrame = strTrim(frame);
if (trimmedFrame) {
result = IS_FRAME.test(trimmedFrame);
}
}
return result;
}
var stackFrameAiDataContract = objFreeze({
level: 1,
method: 1,
assembly: 0,
fileName: 0,
line: 0
});
function _extractStackFrame(frame, level) {
var _a2;
var theFrame;
if (frame && isString(frame) && strTrim(frame)) {
theFrame = (_a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = stackFrameAiDataContract, _a2.level = level, _a2.assembly = strTrim(frame), _a2.method = NoMethod, _a2.fileName = "", _a2.line = 0, _a2.sizeInBytes = 0, _a2);
var idx = 0;
while (idx < _parseSequence[_DYN_LENGTH$1]) {
var sequence = _parseSequence[idx];
if (sequence.chk && !sequence.chk(frame)) {
break;
}
if (sequence.pre) {
frame = sequence.pre(frame);
}
var matches = frame[_DYN_MATCH](sequence.re);
if (matches && matches[_DYN_LENGTH$1] >= sequence.len) {
if (sequence.m) {
theFrame.method = strTrim(matches[sequence.m] || NoMethod);
}
if (sequence.hdl) {
sequence.hdl(theFrame, sequence, matches);
} else if (sequence.fn) {
if (sequence.ln) {
theFrame[_DYN_FILE_NAME] = strTrim(matches[sequence.fn] || "");
theFrame[_DYN_LINE] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
} else {
_parseFilename(theFrame, matches[sequence.fn] || "");
}
}
break;
}
idx++;
}
}
return _populateFrameSizeInBytes(theFrame);
}
function _stackFrameFromInterface(frame) {
var _a2;
var parsedFrame = (_a2 = {}, _a2[_DYN_AI_DATA_CONTRACT] = stackFrameAiDataContract, _a2.level = frame.level, _a2.method = frame.method, _a2.assembly = frame[_DYN_ASSEMBLY], _a2.fileName = frame[_DYN_FILE_NAME], _a2.line = frame[_DYN_LINE], _a2.sizeInBytes = 0, _a2);
return _populateFrameSizeInBytes(parsedFrame);
}
function _populateFrameSizeInBytes(frame) {
var sizeInBytes = STACKFRAME_BASE_SIZE;
if (frame) {
sizeInBytes += frame.method[_DYN_LENGTH$1];
sizeInBytes += frame.assembly[_DYN_LENGTH$1];
sizeInBytes += frame.fileName[_DYN_LENGTH$1];
sizeInBytes += frame.level.toString()[_DYN_LENGTH$1];
sizeInBytes += frame.line.toString()[_DYN_LENGTH$1];
frame[_DYN_SIZE_IN_BYTES] = sizeInBytes;
}
return frame;
}
function _parsedFrameToInterface(frame) {
return {
level: frame.level,
method: frame.method,
assembly: frame[_DYN_ASSEMBLY],
fileName: frame[_DYN_FILE_NAME],
line: frame[_DYN_LINE]
};
}
var DataPoint = (
/** @class */
/* @__PURE__ */ (function() {
function DataPoint2() {
this.aiDataContract = {
name: 1,
kind: 0,
value: 1,
count: 0,
min: 0,
max: 0,
stdDev: 0
};
this.kind = 0;
}
return DataPoint2;
})()
);
var Metric = (
/** @class */
(function() {
function Metric2(logger2, name, value, count, min, max, stdDev, properties, measurements) {
this.aiDataContract = {
ver: 1,
metrics: 1,
properties: 0
};
var _self = this;
_self.ver = 2;
var dataPoint = new DataPoint();
dataPoint[_DYN_COUNT$1] = count > 0 ? count : void 0;
dataPoint.max = isNaN(max) || max === null ? void 0 : max;
dataPoint.min = isNaN(min) || min === null ? void 0 : min;
dataPoint[_DYN_NAME$1] = dataSanitizeString(logger2, name) || strNotSpecified;
dataPoint.value = value;
dataPoint.stdDev = isNaN(stdDev) || stdDev === null ? void 0 : stdDev;
_self.metrics = [dataPoint];
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
}
Metric2.envelopeType = "Microsoft.ApplicationInsights.{0}.Metric";
Metric2.dataType = "MetricData";
return Metric2;
})()
);
var strEmpty = "";
function msToTimeSpan(totalms) {
if (isNaN(totalms) || totalms < 0) {
totalms = 0;
}
totalms = mathRound(totalms);
var ms = strEmpty + totalms % 1e3;
var sec = strEmpty + mathFloor(totalms / 1e3) % 60;
var min = strEmpty + mathFloor(totalms / (1e3 * 60)) % 60;
var hour = strEmpty + mathFloor(totalms / (1e3 * 60 * 60)) % 24;
var days = mathFloor(totalms / (1e3 * 60 * 60 * 24));
ms = ms[_DYN_LENGTH$1] === 1 ? "00" + ms : ms[_DYN_LENGTH$1] === 2 ? "0" + ms : ms;
sec = sec[_DYN_LENGTH$1] < 2 ? "0" + sec : sec;
min = min[_DYN_LENGTH$1] < 2 ? "0" + min : min;
hour = hour[_DYN_LENGTH$1] < 2 ? "0" + hour : hour;
return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
}
var PageView = (
/** @class */
(function() {
function PageView2(logger2, name, url, durationMs, properties, measurements, id) {
this.aiDataContract = {
ver: 1,
name: 0,
url: 0,
duration: 0,
properties: 0,
measurements: 0,
id: 0
};
var _self = this;
_self.ver = 2;
_self.id = dataSanitizeId(logger2, id);
_self.url = dataSanitizeUrl(logger2, url);
_self[_DYN_NAME$1] = dataSanitizeString(logger2, name) || strNotSpecified;
if (!isNaN(durationMs)) {
_self[_DYN_DURATION] = msToTimeSpan(durationMs);
}
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
}
PageView2.envelopeType = "Microsoft.ApplicationInsights.{0}.Pageview";
PageView2.dataType = "PageviewData";
return PageView2;
})()
);
var RemoteDependencyData = (
/** @class */
(function() {
function RemoteDependencyData2(logger2, id, absoluteUrl, commandName, value, success, resultCode, method, requestAPI, correlationContext, properties, measurements) {
if (requestAPI === void 0) {
requestAPI = "Ajax";
}
this.aiDataContract = {
id: 1,
ver: 1,
name: 0,
resultCode: 0,
duration: 0,
success: 0,
data: 0,
target: 0,
type: 0,
properties: 0,
measurements: 0,
kind: 0,
value: 0,
count: 0,
min: 0,
max: 0,
stdDev: 0,
dependencyKind: 0,
dependencySource: 0,
commandName: 0,
dependencyTypeName: 0
};
var _self = this;
_self.ver = 2;
_self.id = id;
_self[_DYN_DURATION] = msToTimeSpan(value);
_self.success = success;
_self.resultCode = resultCode + "";
_self.type = dataSanitizeString(logger2, requestAPI);
var dependencyFields = AjaxHelperParseDependencyPath(logger2, absoluteUrl, method, commandName);
_self.data = dataSanitizeUrl(logger2, commandName) || dependencyFields.data;
_self.target = dataSanitizeString(logger2, dependencyFields.target);
if (correlationContext) {
_self.target = "".concat(_self.target, " | ").concat(correlationContext);
}
_self[_DYN_NAME$1] = dataSanitizeString(logger2, dependencyFields[_DYN_NAME$1]);
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
}
RemoteDependencyData2.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
RemoteDependencyData2.dataType = "RemoteDependencyData";
return RemoteDependencyData2;
})()
);
var Trace = (
/** @class */
(function() {
function Trace2(logger2, message, severityLevel, properties, measurements) {
this.aiDataContract = {
ver: 1,
message: 1,
severityLevel: 0,
properties: 0
};
var _self = this;
_self.ver = 2;
message = message || strNotSpecified;
_self[_DYN_MESSAGE] = dataSanitizeMessage(logger2, message);
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
if (severityLevel) {
_self[_DYN_SEVERITY_LEVEL] = severityLevel;
}
}
Trace2.envelopeType = "Microsoft.ApplicationInsights.{0}.Message";
Trace2.dataType = "MessageData";
return Trace2;
})()
);
var PageViewPerformance = (
/** @class */
(function() {
function PageViewPerformance2(logger2, name, url, unused, properties, measurements, cs4BaseData) {
this.aiDataContract = {
ver: 1,
name: 0,
url: 0,
duration: 0,
perfTotal: 0,
networkConnect: 0,
sentRequest: 0,
receivedResponse: 0,
domProcessing: 0,
properties: 0,
measurements: 0
};
var _self = this;
_self.ver = 2;
_self.url = dataSanitizeUrl(logger2, url);
_self[_DYN_NAME$1] = dataSanitizeString(logger2, name) || strNotSpecified;
_self[_DYN_PROPERTIES] = dataSanitizeProperties(logger2, properties);
_self[_DYN_MEASUREMENTS$1] = dataSanitizeMeasurements(logger2, measurements);
if (cs4BaseData) {
_self.domProcessing = cs4BaseData.domProcessing;
_self[_DYN_DURATION] = cs4BaseData[_DYN_DURATION];
_self.networkConnect = cs4BaseData.networkConnect;
_self.perfTotal = cs4BaseData.perfTotal;
_self.receivedResponse = cs4BaseData.receivedResponse;
_self.sentRequest = cs4BaseData.sentRequest;
}
}
PageViewPerformance2.envelopeType = "Microsoft.ApplicationInsights.{0}.PageviewPerformance";
PageViewPerformance2.dataType = "PageviewPerformanceData";
return PageViewPerformance2;
})()
);
var Data = (
/** @class */
/* @__PURE__ */ (function() {
function Data2(baseType, data) {
this.aiDataContract = {
baseType: 1,
baseData: 1
};
this.baseType = baseType;
this.baseData = data;
}
return Data2;
})()
);
var SeverityLevel = /* @__PURE__ */ createEnumStyle({
Verbose: 0,
Information: 1,
Warning: 2,
Error: 3,
Critical: 4
});
function _aiNameFunc(baseName) {
var aiName = "ai." + baseName + ".";
return function(name) {
return aiName + name;
};
}
var _aiApplication = _aiNameFunc("application");
var _aiDevice = _aiNameFunc("device");
var _aiLocation = _aiNameFunc("location");
var _aiOperation = _aiNameFunc("operation");
var _aiSession = _aiNameFunc("session");
var _aiUser = _aiNameFunc("user");
var _aiCloud = _aiNameFunc("cloud");
var _aiInternal = _aiNameFunc("internal");
var ContextTagKeys = (
/** @class */
(function(_super) {
__extendsFn(ContextTagKeys2, _super);
function ContextTagKeys2() {
return _super.call(this) || this;
}
return ContextTagKeys2;
})(createClassFromInterface({
applicationVersion: _aiApplication("ver"),
applicationBuild: _aiApplication("build"),
applicationTypeId: _aiApplication("typeId"),
applicationId: _aiApplication("applicationId"),
applicationLayer: _aiApplication("layer"),
deviceId: _aiDevice("id"),
deviceIp: _aiDevice("ip"),
deviceLanguage: _aiDevice("language"),
deviceLocale: _aiDevice("locale"),
deviceModel: _aiDevice("model"),
deviceFriendlyName: _aiDevice("friendlyName"),
deviceNetwork: _aiDevice("network"),
deviceNetworkName: _aiDevice("networkName"),
deviceOEMName: _aiDevice("oemName"),
deviceOS: _aiDevice("os"),
deviceOSVersion: _aiDevice("osVersion"),
deviceRoleInstance: _aiDevice("roleInstance"),
deviceRoleName: _aiDevice("roleName"),
deviceScreenResolution: _aiDevice("screenResolution"),
deviceType: _aiDevice("type"),
deviceMachineName: _aiDevice("machineName"),
deviceVMName: _aiDevice("vmName"),
deviceBrowser: _aiDevice("browser"),
deviceBrowserVersion: _aiDevice("browserVersion"),
locationIp: _aiLocation("ip"),
locationCountry: _aiLocation("country"),
locationProvince: _aiLocation("province"),
locationCity: _aiLocation("city"),
operationId: _aiOperation("id"),
operationName: _aiOperation("name"),
operationParentId: _aiOperation("parentId"),
operationRootId: _aiOperation("rootId"),
operationSyntheticSource: _aiOperation("syntheticSource"),
operationCorrelationVector: _aiOperation("correlationVector"),
sessionId: _aiSession("id"),
sessionIsFirst: _aiSession("isFirst"),
sessionIsNew: _aiSession("isNew"),
userAccountAcquisitionDate: _aiUser("accountAcquisitionDate"),
userAccountId: _aiUser("accountId"),
userAgent: _aiUser("userAgent"),
userId: _aiUser("id"),
userStoreRegion: _aiUser("storeRegion"),
userAuthUserId: _aiUser("authUserId"),
userAnonymousUserAcquisitionDate: _aiUser("anonUserAcquisitionDate"),
userAuthenticatedUserAcquisitionDate: _aiUser("authUserAcquisitionDate"),
cloudName: _aiCloud("name"),
cloudRole: _aiCloud("role"),
cloudRoleVer: _aiCloud("roleVer"),
cloudRoleInstance: _aiCloud("roleInstance"),
cloudEnvironment: _aiCloud("environment"),
cloudLocation: _aiCloud("location"),
cloudDeploymentUnit: _aiCloud("deploymentUnit"),
internalNodeName: _aiInternal("nodeName"),
internalSdkVersion: _aiInternal("sdkVersion"),
internalAgentVersion: _aiInternal("agentVersion"),
internalSnippet: _aiInternal("snippet"),
internalSdkSrc: _aiInternal("sdkSrc")
}))
);
var CtxTagKeys = new ContextTagKeys();
function _disableEvents(target, evtNamespace) {
eventOff(target, null, null, evtNamespace);
}
function createOfflineListener(parentEvtNamespace) {
var _document2 = getDocument();
var _navigator = getNavigator();
var _isListening = false;
var listenerList = [];
var rState = 1;
if (_navigator && !/* @__PURE__ */ isNullOrUndefined(_navigator.onLine) && !_navigator.onLine) {
rState = 2;
}
var uState = 0;
var _currentState = calCurrentState();
var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
try {
if (_enableEvents(getWindow())) {
_isListening = true;
}
if (_document2) {
var target = _document2.body || _document2;
if (target.ononline) {
if (_enableEvents(target)) {
_isListening = true;
}
}
}
} catch (e) {
_isListening = false;
}
function _enableEvents(target2) {
var enabled = false;
if (target2) {
enabled = eventOn(target2, "online", _setOnline, _evtNamespace);
if (enabled) {
eventOn(target2, "offline", _setOffline, _evtNamespace);
}
}
return enabled;
}
function _isOnline() {
return _currentState;
}
function calCurrentState() {
if (uState === 2 || rState === 2) {
return false;
}
return true;
}
function listnerNoticeCheck() {
var newState = calCurrentState();
if (_currentState !== newState) {
_currentState = newState;
arrForEach(listenerList, function(callback) {
var offlineState = {
isOnline: _currentState,
rState,
uState
};
try {
callback(offlineState);
} catch (e) {
}
});
}
}
function setOnlineState(newState) {
uState = newState;
listnerNoticeCheck();
}
function _setOnline() {
rState = 1;
listnerNoticeCheck();
}
function _setOffline() {
rState = 2;
listnerNoticeCheck();
}
function _unload() {
var win = getWindow();
if (win && _isListening) {
_disableEvents(win, _evtNamespace);
if (_document2) {
var target2 = _document2.body || _document2;
if (!/* @__PURE__ */ isUndefined(target2.ononline)) {
_disableEvents(target2, _evtNamespace);
}
}
_isListening = false;
}
}
function addListener(callback) {
listenerList.push(callback);
return {
rm: function() {
var index = listenerList.indexOf(callback);
if (index > -1) {
return listenerList.splice(index, 1);
} else {
return;
}
}
};
}
return {
isOnline: _isOnline,
isListening: function() {
return _isListening;
},
unload: _unload,
addListener,
setOnlineState
};
}
var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
var STR_DURATION = "duration";
var _DYN_TAGS = "tags";
var _DYN_DEVICE_TYPE = "deviceType";
var _DYN_DATA = "data";
var _DYN_NAME = "name";
var _DYN_TRACE_ID = "traceID";
var _DYN_LENGTH = "length";
var _DYN_STRINGIFY = "stringify";
var _DYN_MEASUREMENTS = "measurements";
var _DYN_DATA_TYPE = "dataType";
var _DYN_ENVELOPE_TYPE = "envelopeType";
var _DYN_TO_STRING = "toString";
var _DYN_ENQUEUE = "enqueue";
var _DYN_COUNT = "count";
var _DYN_PUSH = "push";
var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson";
var _DYN_CLEAR = "clear";
var _DYN_MARK_AS_SENT = "markAsSent";
var _DYN_CLEAR_SENT = "clearSent";
var _DYN_BUFFER_OVERRIDE = "bufferOverride";
var _DYN__BUFFER__KEY = "BUFFER_KEY";
var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
var _DYN_CONCAT = "concat";
var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE";
var _DYN_TRIGGER_SEND = "triggerSend";
var _DYN_DIAG_LOG = "diagLog";
var _DYN_INITIALIZE = "initialize";
var _DYN__SENDER = "_sender";
var _DYN_ENDPOINT_URL$1 = "endpointUrl";
var _DYN_INSTRUMENTATION_KEY$1 = "instrumentationKey";
var _DYN_CUSTOM_HEADERS = "customHeaders";
var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon";
var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled";
var _DYN_ALWAYS_USE_XHR_OVERR4 = "alwaysUseXhrOverride";
var _DYN_ENABLE_SESSION_STORA5 = "enableSessionStorageBuffer";
var _DYN__BUFFER = "_buffer";
var _DYN_ONUNLOAD_DISABLE_FET6 = "onunloadDisableFetch";
var _DYN_DISABLE_SEND_BEACON_7 = "disableSendBeaconSplit";
var _DYN_GET_SENDER_INST = "getSenderInst";
var _DYN__ON_ERROR = "_onError";
var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess";
var _DYN__ON_SUCCESS = "_onSuccess";
var _DYN_ITEMS_RECEIVED = "itemsReceived";
var _DYN_ITEMS_ACCEPTED = "itemsAccepted";
var _DYN_BASE_TYPE = "baseType";
var _DYN_SAMPLE_RATE = "sampleRate";
var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore";
var strBaseType = "baseType";
var strBaseData = "baseData";
var strProperties = "properties";
var strTrue = "true";
function _setValueIf(target, field, value) {
return setValue(target, field, value, isTruthy);
}
function _extractPartAExtensions(logger2, item, env2) {
var envTags = env2[_DYN_TAGS] = env2[_DYN_TAGS] || {};
var itmExt = item.ext = item.ext || {};
var itmTags = item[_DYN_TAGS] = item[_DYN_TAGS] || [];
var extUser = itmExt.user;
if (extUser) {
_setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
_setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
}
var extApp = itmExt.app;
if (extApp) {
_setValueIf(envTags, CtxTagKeys.sessionId, extApp.sesId);
}
var extDevice = itmExt.device;
if (extDevice) {
_setValueIf(envTags, CtxTagKeys.deviceId, extDevice.id || extDevice.localId);
_setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE], extDevice.deviceClass);
_setValueIf(envTags, CtxTagKeys.deviceIp, extDevice.ip);
_setValueIf(envTags, CtxTagKeys.deviceModel, extDevice.model);
_setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE], extDevice[_DYN_DEVICE_TYPE]);
}
var web = item.ext.web;
if (web) {
_setValueIf(envTags, CtxTagKeys.deviceLanguage, web.browserLang);
_setValueIf(envTags, CtxTagKeys.deviceBrowserVersion, web.browserVer);
_setValueIf(envTags, CtxTagKeys.deviceBrowser, web.browser);
var envData = env2[_DYN_DATA] = env2[_DYN_DATA] || {};
var envBaseData = envData[strBaseData] = envData[strBaseData] || {};
var envProps = envBaseData[strProperties] = envBaseData[strProperties] || {};
_setValueIf(envProps, "domain", web.domain);
_setValueIf(envProps, "isManual", web.isManual ? strTrue : null);
_setValueIf(envProps, "screenRes", web.screenRes);
_setValueIf(envProps, "userConsent", web.userConsent ? strTrue : null);
}
var extOs = itmExt.os;
if (extOs) {
_setValueIf(envTags, CtxTagKeys.deviceOS, extOs[_DYN_NAME]);
_setValueIf(envTags, CtxTagKeys.deviceOSVersion, extOs.osVer);
}
var extTrace = itmExt.trace;
if (extTrace) {
_setValueIf(envTags, CtxTagKeys.operationParentId, extTrace.parentID);
_setValueIf(envTags, CtxTagKeys.operationName, dataSanitizeString(logger2, extTrace[_DYN_NAME]));
_setValueIf(envTags, CtxTagKeys.operationId, extTrace[_DYN_TRACE_ID]);
}
var tgs = {};
for (var i = itmTags[_DYN_LENGTH] - 1; i >= 0; i--) {
var tg = itmTags[i];
objForEachKey(tg, function(key, value) {
tgs[key] = value;
});
itmTags.splice(i, 1);
}
objForEachKey(itmTags, function(tg2, value) {
tgs[tg2] = value;
});
var theTags = __assignFn(__assignFn({}, envTags), tgs);
if (!theTags[CtxTagKeys.internalSdkVersion]) {
theTags[CtxTagKeys.internalSdkVersion] = dataSanitizeString(logger2, "javascript:".concat(EnvelopeCreator.Version), 64);
}
env2[_DYN_TAGS] = optimizeObject(theTags);
}
function _extractPropsAndMeasurements(data, properties, measurements) {
if (!/* @__PURE__ */ isNullOrUndefined(data)) {
objForEachKey(data, function(key, value) {
if (isNumber(value)) {
measurements[key] = value;
} else if (isString(value)) {
properties[key] = value;
} else if (hasJSON()) {
properties[key] = getJSON()[_DYN_STRINGIFY](value);
}
});
}
}
function _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue) {
if (!/* @__PURE__ */ isNullOrUndefined(properties)) {
objForEachKey(properties, function(key, value) {
properties[key] = value || customUndefinedValue;
});
}
}
function _createEnvelope(logger2, envelopeType, telemetryItem, data) {
var envelope = new Envelope(logger2, data, envelopeType);
_setValueIf(envelope, "sampleRate", telemetryItem[SampleRate]);
if ((telemetryItem[strBaseData] || {}).startTime) {
envelope.time = toISOString(telemetryItem[strBaseData].startTime);
}
envelope.iKey = telemetryItem.iKey;
var iKeyNoDashes = telemetryItem.iKey.replace(/-/g, "");
envelope[_DYN_NAME] = envelope[_DYN_NAME].replace("{0}", iKeyNoDashes);
_extractPartAExtensions(logger2, telemetryItem, envelope);
telemetryItem[_DYN_TAGS] = telemetryItem[_DYN_TAGS] || [];
return optimizeObject(envelope);
}
function EnvelopeCreatorInit(logger2, telemetryItem) {
if (/* @__PURE__ */ isNullOrUndefined(telemetryItem[strBaseData])) {
_throwInternal(logger2, 1, 46, "telemetryItem.baseData cannot be null.");
}
}
var EnvelopeCreator = {
Version: "3.3.10"
};
function DependencyEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS] || {};
var customProperties = telemetryItem[strBaseData][strProperties] || {};
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], customProperties, customMeasurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
}
var bd = telemetryItem[strBaseData];
if (/* @__PURE__ */ isNullOrUndefined(bd)) {
_warnToConsole(logger2, "Invalid input for dependency data");
return null;
}
var method = bd[strProperties] && bd[strProperties][HttpMethod] ? bd[strProperties][HttpMethod] : "GET";
var remoteDepData = new RemoteDependencyData(logger2, bd.id, bd.target, bd[_DYN_NAME], bd[STR_DURATION], bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
var data = new Data(RemoteDependencyData[_DYN_DATA_TYPE], remoteDepData);
return _createEnvelope(logger2, RemoteDependencyData[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function EventEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var customProperties = {};
var customMeasurements = {};
if (telemetryItem[strBaseType] !== Event$1[_DYN_DATA_TYPE]) {
customProperties["baseTypeSource"] = telemetryItem[strBaseType];
}
if (telemetryItem[strBaseType] === Event$1[_DYN_DATA_TYPE]) {
customProperties = telemetryItem[strBaseData][strProperties] || {};
customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS] || {};
} else {
if (telemetryItem[strBaseData]) {
_extractPropsAndMeasurements(telemetryItem[strBaseData], customProperties, customMeasurements);
}
}
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], customProperties, customMeasurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
}
var eventName = telemetryItem[strBaseData][_DYN_NAME];
var eventData = new Event$1(logger2, eventName, customProperties, customMeasurements);
var data = new Data(Event$1[_DYN_DATA_TYPE], eventData);
return _createEnvelope(logger2, Event$1[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function ExceptionEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS] || {};
var customProperties = telemetryItem[strBaseData][strProperties] || {};
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], customProperties, customMeasurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
}
var bd = telemetryItem[strBaseData];
var exData = Exception.CreateFromInterface(logger2, bd, customProperties, customMeasurements);
var data = new Data(Exception[_DYN_DATA_TYPE], exData);
return _createEnvelope(logger2, Exception[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function MetricEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var baseData = telemetryItem[strBaseData];
var props = baseData[strProperties] || {};
var measurements = baseData[_DYN_MEASUREMENTS] || {};
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], props, measurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
}
var baseMetricData = new Metric(logger2, baseData[_DYN_NAME], baseData.average, baseData.sampleCount, baseData.min, baseData.max, baseData.stdDev, props, measurements);
var data = new Data(Metric[_DYN_DATA_TYPE], baseMetricData);
return _createEnvelope(logger2, Metric[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function PageViewEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var duration;
var baseData = telemetryItem[strBaseData];
if (!/* @__PURE__ */ isNullOrUndefined(baseData) && !/* @__PURE__ */ isNullOrUndefined(baseData[strProperties]) && !/* @__PURE__ */ isNullOrUndefined(baseData[strProperties][STR_DURATION])) {
duration = baseData[strProperties][STR_DURATION];
delete baseData[strProperties][STR_DURATION];
} else if (!/* @__PURE__ */ isNullOrUndefined(telemetryItem[_DYN_DATA]) && !/* @__PURE__ */ isNullOrUndefined(telemetryItem[_DYN_DATA][STR_DURATION])) {
duration = telemetryItem[_DYN_DATA][STR_DURATION];
delete telemetryItem[_DYN_DATA][STR_DURATION];
}
var bd = telemetryItem[strBaseData];
var currentContextId;
if (((telemetryItem.ext || {}).trace || {})[_DYN_TRACE_ID]) {
currentContextId = telemetryItem.ext.trace[_DYN_TRACE_ID];
}
var id = bd.id || currentContextId;
var name = bd[_DYN_NAME];
var url = bd.uri;
var properties = bd[strProperties] || {};
var measurements = bd[_DYN_MEASUREMENTS] || {};
if (!/* @__PURE__ */ isNullOrUndefined(bd.refUri)) {
properties["refUri"] = bd.refUri;
}
if (!/* @__PURE__ */ isNullOrUndefined(bd.pageType)) {
properties["pageType"] = bd.pageType;
}
if (!/* @__PURE__ */ isNullOrUndefined(bd.isLoggedIn)) {
properties["isLoggedIn"] = bd.isLoggedIn[_DYN_TO_STRING]();
}
if (!/* @__PURE__ */ isNullOrUndefined(bd[strProperties])) {
var pageTags = bd[strProperties];
objForEachKey(pageTags, function(key, value) {
properties[key] = value;
});
}
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], properties, measurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
}
var pageViewData = new PageView(logger2, name, url, duration, properties, measurements, id);
var data = new Data(PageView[_DYN_DATA_TYPE], pageViewData);
return _createEnvelope(logger2, PageView[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function PageViewPerformanceEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var bd = telemetryItem[strBaseData];
var name = bd[_DYN_NAME];
var url = bd.uri || bd.url;
var properties = bd[strProperties] || {};
var measurements = bd[_DYN_MEASUREMENTS] || {};
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], properties, measurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
}
var baseData = new PageViewPerformance(logger2, name, url, void 0, properties, measurements, bd);
var data = new Data(PageViewPerformance[_DYN_DATA_TYPE], baseData);
return _createEnvelope(logger2, PageViewPerformance[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
function TraceEnvelopeCreator(logger2, telemetryItem, customUndefinedValue) {
EnvelopeCreatorInit(logger2, telemetryItem);
var message = telemetryItem[strBaseData].message;
var severityLevel = telemetryItem[strBaseData].severityLevel;
var props = telemetryItem[strBaseData][strProperties] || {};
var measurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS] || {};
_extractPropsAndMeasurements(telemetryItem[_DYN_DATA], props, measurements);
if (!/* @__PURE__ */ isNullOrUndefined(customUndefinedValue)) {
_convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
}
var baseData = new Trace(logger2, message, severityLevel, props, measurements);
var data = new Data(Trace[_DYN_DATA_TYPE], baseData);
return _createEnvelope(logger2, Trace[_DYN_ENVELOPE_TYPE], telemetryItem, data);
}
var BaseSendBuffer = (
/** @class */
(function() {
function BaseSendBuffer2(logger2, config) {
var _buffer = [];
var _bufferFullMessageSent = false;
var _maxRetryCnt = config.maxRetryCnt;
this._get = function() {
return _buffer;
};
this._set = function(buffer) {
_buffer = buffer;
return _buffer;
};
dynamicProto(BaseSendBuffer2, this, function(_self) {
_self[_DYN_ENQUEUE] = function(payload) {
if (_self[_DYN_COUNT]() >= config.eventsLimitInMem) {
if (!_bufferFullMessageSent) {
_throwInternal(logger2, 2, 105, "Maximum in-memory buffer size reached: " + _self[_DYN_COUNT](), true);
_bufferFullMessageSent = true;
}
return;
}
payload.cnt = payload.cnt || 0;
if (!/* @__PURE__ */ isNullOrUndefined(_maxRetryCnt)) {
if (payload.cnt > _maxRetryCnt) {
return;
}
}
_buffer[_DYN_PUSH](payload);
return;
};
_self[_DYN_COUNT] = function() {
return _buffer[_DYN_LENGTH];
};
_self.size = function() {
var size = _buffer[_DYN_LENGTH];
for (var lp = 0; lp < _buffer[_DYN_LENGTH]; lp++) {
size += _buffer[lp].item[_DYN_LENGTH];
}
if (!config[_DYN_EMIT_LINE_DELIMITED_0]) {
size += 2;
}
return size;
};
_self[_DYN_CLEAR] = function() {
_buffer = [];
_bufferFullMessageSent = false;
};
_self.getItems = function() {
return _buffer.slice(0);
};
_self.batchPayloads = function(payloads) {
if (payloads && payloads[_DYN_LENGTH] > 0) {
var payloadStr_1 = [];
arrForEach(payloads, function(payload) {
payloadStr_1[_DYN_PUSH](payload.item);
});
var batch = config[_DYN_EMIT_LINE_DELIMITED_0] ? payloadStr_1.join("\n") : "[" + payloadStr_1.join(",") + "]";
return batch;
}
return null;
};
_self.createNew = function(newLogger, newConfig, canUseSessionStorage) {
var items = _buffer.slice(0);
newLogger = newLogger || logger2;
newConfig = newConfig || {};
var newBuffer = !!canUseSessionStorage ? new SessionStorageSendBuffer(newLogger, newConfig) : new ArraySendBuffer(newLogger, newConfig);
arrForEach(items, function(payload) {
newBuffer[_DYN_ENQUEUE](payload);
});
return newBuffer;
};
});
}
BaseSendBuffer2.__ieDyn = 1;
return BaseSendBuffer2;
})()
);
var ArraySendBuffer = (
/** @class */
(function(_super) {
__extendsFn(ArraySendBuffer2, _super);
function ArraySendBuffer2(logger2, config) {
var _this = _super.call(this, logger2, config) || this;
dynamicProto(ArraySendBuffer2, _this, function(_self, _base) {
_self[_DYN_MARK_AS_SENT] = function(payload) {
_base[_DYN_CLEAR]();
};
_self[_DYN_CLEAR_SENT] = function(payload) {
};
});
return _this;
}
ArraySendBuffer2.__ieDyn = 1;
return ArraySendBuffer2;
})(BaseSendBuffer)
);
var PREVIOUS_KEYS = ["AI_buffer", "AI_sentBuffer"];
var SessionStorageSendBuffer = (
/** @class */
(function(_super) {
__extendsFn(SessionStorageSendBuffer2, _super);
function SessionStorageSendBuffer2(logger2, config) {
var _this = _super.call(this, logger2, config) || this;
var _bufferFullMessageSent = false;
var _namePrefix = config === null || config === void 0 ? void 0 : config.namePrefix;
var _b2 = config[_DYN_BUFFER_OVERRIDE] || { getItem: utlGetSessionStorage, setItem: utlSetSessionStorage }, getItem = _b2.getItem, setItem = _b2.setItem;
var _maxRetryCnt = config.maxRetryCnt;
dynamicProto(SessionStorageSendBuffer2, _this, function(_self, _base) {
var bufferItems = _getBuffer(SessionStorageSendBuffer2[_DYN__BUFFER__KEY]);
var itemsInSentBuffer = _getBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY]);
var previousItems = _getPreviousEvents();
var notDeliveredItems = itemsInSentBuffer[_DYN_CONCAT](previousItems);
var buffer = _self._set(bufferItems[_DYN_CONCAT](notDeliveredItems));
if (buffer[_DYN_LENGTH] > SessionStorageSendBuffer2[_DYN__MAX__BUFFER__SIZE]) {
buffer[_DYN_LENGTH] = SessionStorageSendBuffer2[_DYN__MAX__BUFFER__SIZE];
}
_setBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY], []);
_setBuffer(SessionStorageSendBuffer2[_DYN__BUFFER__KEY], buffer);
_self[_DYN_ENQUEUE] = function(payload) {
if (_self[_DYN_COUNT]() >= SessionStorageSendBuffer2[_DYN__MAX__BUFFER__SIZE]) {
if (!_bufferFullMessageSent) {
_throwInternal(logger2, 2, 67, "Maximum buffer size reached: " + _self[_DYN_COUNT](), true);
_bufferFullMessageSent = true;
}
return;
}
payload.cnt = payload.cnt || 0;
if (!/* @__PURE__ */ isNullOrUndefined(_maxRetryCnt)) {
if (payload.cnt > _maxRetryCnt) {
return;
}
}
_base[_DYN_ENQUEUE](payload);
_setBuffer(SessionStorageSendBuffer2[_DYN__BUFFER__KEY], _self._get());
};
_self[_DYN_CLEAR] = function() {
_base[_DYN_CLEAR]();
_setBuffer(SessionStorageSendBuffer2[_DYN__BUFFER__KEY], _self._get());
_setBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY], []);
_bufferFullMessageSent = false;
};
_self[_DYN_MARK_AS_SENT] = function(payload) {
_setBuffer(SessionStorageSendBuffer2[_DYN__BUFFER__KEY], _self._set(_removePayloadsFromBuffer(payload, _self._get())));
var sentElements = _getBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY]);
if (sentElements instanceof Array && payload instanceof Array) {
sentElements = sentElements[_DYN_CONCAT](payload);
if (sentElements[_DYN_LENGTH] > SessionStorageSendBuffer2[_DYN__MAX__BUFFER__SIZE]) {
_throwInternal(logger2, 1, 67, "Sent buffer reached its maximum size: " + sentElements[_DYN_LENGTH], true);
sentElements[_DYN_LENGTH] = SessionStorageSendBuffer2[_DYN__MAX__BUFFER__SIZE];
}
_setBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY], sentElements);
}
};
_self[_DYN_CLEAR_SENT] = function(payload) {
var sentElements = _getBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY]);
sentElements = _removePayloadsFromBuffer(payload, sentElements);
_setBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY], sentElements);
};
_self.createNew = function(newLogger, newConfig, canUseSessionStorage) {
canUseSessionStorage = !!canUseSessionStorage;
var unsentItems = _self._get().slice(0);
var sentItems = _getBuffer(SessionStorageSendBuffer2[_DYN__SENT__BUFFER__KEY]).slice(0);
newLogger = newLogger || logger2;
newConfig = newConfig || {};
_self[_DYN_CLEAR]();
var newBuffer = canUseSessionStorage ? new SessionStorageSendBuffer2(newLogger, newConfig) : new ArraySendBuffer(newLogger, newConfig);
arrForEach(unsentItems, function(payload) {
newBuffer[_DYN_ENQUEUE](payload);
});
if (canUseSessionStorage) {
newBuffer[_DYN_MARK_AS_SENT](sentItems);
}
return newBuffer;
};
function _removePayloadsFromBuffer(payloads, buffer2) {
var remaining = [];
var payloadStr = [];
arrForEach(payloads, function(payload) {
payloadStr[_DYN_PUSH](payload.item);
});
arrForEach(buffer2, function(value) {
if (!isFunction(value) && arrIndexOf(payloadStr, value.item) === -1) {
remaining[_DYN_PUSH](value);
}
});
return remaining;
}
function _getBuffer(key) {
var prefixedKey = key;
prefixedKey = _namePrefix ? _namePrefix + "_" + prefixedKey : prefixedKey;
return _getBufferBase(prefixedKey);
}
function _getBufferBase(key) {
try {
var bufferJson = getItem(logger2, key);
if (bufferJson) {
var buffer_1 = getJSON().parse(bufferJson);
if (isString(buffer_1)) {
buffer_1 = getJSON().parse(buffer_1);
}
if (buffer_1 && isArray(buffer_1)) {
return buffer_1;
}
}
} catch (e) {
_throwInternal(logger2, 1, 42, " storage key: " + key + ", " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
return [];
}
function _setBuffer(key, buffer2) {
var prefixedKey = key;
try {
prefixedKey = _namePrefix ? _namePrefix + "_" + prefixedKey : prefixedKey;
var bufferJson = JSON[_DYN_STRINGIFY](buffer2);
setItem(logger2, prefixedKey, bufferJson);
} catch (e) {
setItem(logger2, prefixedKey, JSON[_DYN_STRINGIFY]([]));
_throwInternal(logger2, 2, 41, " storage key: " + prefixedKey + ", " + getExceptionName(e) + ". Buffer cleared", { exception: /* @__PURE__ */ dumpObj(e) });
}
}
function _getPreviousEvents() {
var items = [];
try {
arrForEach(PREVIOUS_KEYS, function(key) {
var events = _getItemsFromPreviousKey(key);
items = items[_DYN_CONCAT](events);
if (_namePrefix) {
var prefixedKey = _namePrefix + "_" + key;
var prefixEvents = _getItemsFromPreviousKey(prefixedKey);
items = items[_DYN_CONCAT](prefixEvents);
}
});
return items;
} catch (e) {
_throwInternal(logger2, 2, 41, "Transfer events from previous buffers: " + getExceptionName(e) + ". previous Buffer items can not be removed", { exception: /* @__PURE__ */ dumpObj(e) });
}
return [];
}
function _getItemsFromPreviousKey(key) {
try {
var items = _getBufferBase(key);
var transFormedItems_1 = [];
arrForEach(items, function(item) {
var internalItem = {
item,
cnt: 0
};
transFormedItems_1[_DYN_PUSH](internalItem);
});
utlRemoveSessionStorage(logger2, key);
return transFormedItems_1;
} catch (e) {
}
return [];
}
});
return _this;
}
var _a2;
_a2 = SessionStorageSendBuffer2;
SessionStorageSendBuffer2.VERSION = "_1";
SessionStorageSendBuffer2.BUFFER_KEY = "AI_buffer" + _a2.VERSION;
SessionStorageSendBuffer2.SENT_BUFFER_KEY = "AI_sentBuffer" + _a2.VERSION;
SessionStorageSendBuffer2.MAX_BUFFER_SIZE = 2e3;
return SessionStorageSendBuffer2;
})(BaseSendBuffer)
);
var Serializer = (
/** @class */
(function() {
function Serializer2(logger2) {
dynamicProto(Serializer2, this, function(_self) {
_self.serialize = function(input) {
var output = _serializeObject(input, "root");
try {
return getJSON()[_DYN_STRINGIFY](output);
} catch (e) {
_throwInternal(logger2, 1, 48, e && isFunction(e[_DYN_TO_STRING]) ? e[_DYN_TO_STRING]() : "Error serializing object", null, true);
}
};
function _serializeObject(source, name) {
var circularReferenceCheck = "__aiCircularRefCheck";
var output = {};
if (!source) {
_throwInternal(logger2, 1, 48, "cannot serialize object because it is null or undefined", { name }, true);
return output;
}
if (source[circularReferenceCheck]) {
_throwInternal(logger2, 2, 50, "Circular reference detected while serializing object", { name }, true);
return output;
}
if (!source.aiDataContract) {
if (name === "measurements") {
output = _serializeStringMap(source, "number", name);
} else if (name === "properties") {
output = _serializeStringMap(source, "string", name);
} else if (name === "tags") {
output = _serializeStringMap(source, "string", name);
} else if (isArray(source)) {
output = _serializeArray(source, name);
} else {
_throwInternal(logger2, 2, 49, "Attempting to serialize an object which does not implement ISerializable", { name }, true);
try {
getJSON()[_DYN_STRINGIFY](source);
output = source;
} catch (e) {
_throwInternal(logger2, 1, 48, e && isFunction(e[_DYN_TO_STRING]) ? e[_DYN_TO_STRING]() : "Error serializing object", null, true);
}
}
return output;
}
source[circularReferenceCheck] = true;
objForEachKey(source.aiDataContract, function(field, contract) {
var isRequired = isFunction(contract) ? contract() & 1 : contract & 1;
var isHidden = isFunction(contract) ? contract() & 4 : contract & 4;
var isArray2 = contract & 2;
var isPresent = source[field] !== void 0;
var isObj = /* @__PURE__ */ isObject(source[field]) && source[field] !== null;
if (isRequired && !isPresent && !isArray2) {
_throwInternal(logger2, 1, 24, "Missing required field specification. The field is required but not present on source", { field, name });
} else if (!isHidden) {
var value = void 0;
if (isObj) {
if (isArray2) {
value = _serializeArray(source[field], field);
} else {
value = _serializeObject(source[field], field);
}
} else {
value = source[field];
}
if (value !== void 0) {
output[field] = value;
}
}
});
delete source[circularReferenceCheck];
return output;
}
function _serializeArray(sources, name) {
var output;
if (!!sources) {
if (!isArray(sources)) {
_throwInternal(logger2, 1, 54, "This field was specified as an array in the contract but the item is not an array.\r\n", { name }, true);
} else {
output = [];
for (var i = 0; i < sources[_DYN_LENGTH]; i++) {
var source = sources[i];
var item = _serializeObject(source, name + "[" + i + "]");
output[_DYN_PUSH](item);
}
}
}
return output;
}
function _serializeStringMap(map, expectedType, name) {
var output;
if (map) {
output = {};
objForEachKey(map, function(field, value) {
if (expectedType === "string") {
if (value === void 0) {
output[field] = "undefined";
} else if (value === null) {
output[field] = "null";
} else if (!value[_DYN_TO_STRING]) {
output[field] = "invalid field: toString() is not defined.";
} else {
output[field] = value[_DYN_TO_STRING]();
}
} else if (expectedType === "number") {
if (value === void 0) {
output[field] = "undefined";
} else if (value === null) {
output[field] = "null";
} else {
var num = parseFloat(value);
output[field] = num;
}
} else {
output[field] = "invalid field: " + name + " is of unknown type.";
_throwInternal(logger2, 1, output[field], null, true);
}
});
}
return output;
}
});
}
Serializer2.__ieDyn = 1;
return Serializer2;
})()
);
var MIN_INPUT_LENGTH = 8;
var HashCodeScoreGenerator = (
/** @class */
(function() {
function HashCodeScoreGenerator2() {
}
HashCodeScoreGenerator2.prototype.getHashCodeScore = function(key) {
var score = this.getHashCode(key) / HashCodeScoreGenerator2.INT_MAX_VALUE;
return score * 100;
};
HashCodeScoreGenerator2.prototype.getHashCode = function(input) {
if (input === "") {
return 0;
}
while (input[_DYN_LENGTH] < MIN_INPUT_LENGTH) {
input = input[_DYN_CONCAT](input);
}
var hash = 5381;
for (var i = 0; i < input[_DYN_LENGTH]; ++i) {
hash = (hash << 5) + hash + input.charCodeAt(i);
hash = hash & hash;
}
return Math.abs(hash);
};
HashCodeScoreGenerator2.INT_MAX_VALUE = 2147483647;
return HashCodeScoreGenerator2;
})()
);
var SamplingScoreGenerator = (
/** @class */
/* @__PURE__ */ (function() {
function SamplingScoreGenerator2() {
var _self = this;
var hashCodeGenerator = new HashCodeScoreGenerator();
var keys = new ContextTagKeys();
_self.getSamplingScore = function(item) {
var score = 0;
if (item[_DYN_TAGS] && item[_DYN_TAGS][keys.userId]) {
score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS][keys.userId]);
} else if (item.ext && item.ext.user && item.ext.user.id) {
score = hashCodeGenerator[_DYN_GET_HASH_CODE_SCORE](item.ext.user.id);
} else if (item[_DYN_TAGS] && item[_DYN_TAGS][keys.operationId]) {
score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS][keys.operationId]);
} else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace[_DYN_TRACE_ID]) {
score = hashCodeGenerator.getHashCodeScore(item.ext.telemetryTrace[_DYN_TRACE_ID]);
} else {
score = Math.random() * 100;
}
return score;
};
}
return SamplingScoreGenerator2;
})()
);
var Sample = (
/** @class */
(function() {
function Sample2(sampleRate, logger2) {
this.INT_MAX_VALUE = 2147483647;
var _logger = logger2 || safeGetLogger(null);
if (sampleRate > 100 || sampleRate < 0) {
_logger.throwInternal(2, 58, "Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.", { samplingRate: sampleRate }, true);
sampleRate = 100;
}
this[_DYN_SAMPLE_RATE] = sampleRate;
this.samplingScoreGenerator = new SamplingScoreGenerator();
}
Sample2.prototype.isSampledIn = function(envelope) {
var samplingPercentage = this[_DYN_SAMPLE_RATE];
var isSampledIn = false;
if (samplingPercentage === null || samplingPercentage === void 0 || samplingPercentage >= 100) {
return true;
} else if (envelope.baseType === Metric[_DYN_DATA_TYPE]) {
return true;
}
isSampledIn = this.samplingScoreGenerator.getSamplingScore(envelope) < samplingPercentage;
return isSampledIn;
};
return Sample2;
})()
);
var _a$1, _b$1;
var UNDEFINED_VALUE$1 = void 0;
var EMPTY_STR = "";
var FetchSyncRequestSizeLimitBytes = 65e3;
function _getResponseText(xhr) {
try {
return xhr.responseText;
} catch (e) {
}
return null;
}
function isOverrideFn(httpXHROverride) {
return httpXHROverride && httpXHROverride.sendPOST;
}
var defaultAppInsightsChannelConfig = objDeepFreeze((_a$1 = {
endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
}, _a$1[_DYN_EMIT_LINE_DELIMITED_0] = cfgDfBoolean(), _a$1.maxBatchInterval = 15e3, _a$1[_DYN_MAX_BATCH_SIZE_IN_BY1] = 102400, _a$1.disableTelemetry = cfgDfBoolean(), _a$1[_DYN_ENABLE_SESSION_STORA5] = cfgDfBoolean(true), _a$1.isRetryDisabled = cfgDfBoolean(), _a$1[_DYN_IS_BEACON_API_DISABL3] = cfgDfBoolean(true), _a$1[_DYN_DISABLE_SEND_BEACON_7] = cfgDfBoolean(true), _a$1.disableXhr = cfgDfBoolean(), _a$1[_DYN_ONUNLOAD_DISABLE_FET6] = cfgDfBoolean(), _a$1[_DYN_ONUNLOAD_DISABLE_BEA2] = cfgDfBoolean(), _a$1[_DYN_INSTRUMENTATION_KEY$1] = UNDEFINED_VALUE$1, _a$1.namePrefix = UNDEFINED_VALUE$1, _a$1.samplingPercentage = cfgDfValidate(_chkSampling, 100), _a$1[_DYN_CUSTOM_HEADERS] = UNDEFINED_VALUE$1, _a$1.convertUndefined = UNDEFINED_VALUE$1, _a$1.eventsLimitInMem = 1e4, _a$1[_DYN_BUFFER_OVERRIDE] = false, _a$1.httpXHROverride = { isVal: isOverrideFn, v: UNDEFINED_VALUE$1 }, _a$1[_DYN_ALWAYS_USE_XHR_OVERR4] = cfgDfBoolean(), _a$1.transports = UNDEFINED_VALUE$1, _a$1.retryCodes = UNDEFINED_VALUE$1, _a$1.corsPolicy = UNDEFINED_VALUE$1, _a$1.maxRetryCnt = { isVal: isNumber, v: 10 }, _a$1));
var CrossOriginResourcePolicyHeader = "X-Set-Cross-Origin-Resource-Policy";
function _chkSampling(value) {
return !isNaN(value) && value > 0 && value <= 100;
}
var EnvelopeTypeCreator = (_b$1 = {}, _b$1[Event$1.dataType] = EventEnvelopeCreator, _b$1[Trace.dataType] = TraceEnvelopeCreator, _b$1[PageView.dataType] = PageViewEnvelopeCreator, _b$1[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator, _b$1[Exception.dataType] = ExceptionEnvelopeCreator, _b$1[Metric.dataType] = MetricEnvelopeCreator, _b$1[RemoteDependencyData.dataType] = DependencyEnvelopeCreator, _b$1);
var Sender = (
/** @class */
(function(_super) {
__extendsFn(Sender2, _super);
function Sender2() {
var _this = _super.call(this) || this;
_this.priority = 1001;
_this.identifier = BreezeChannelIdentifier;
var _consecutiveErrors;
var _retryAt;
var _paused;
var _timeoutHandle;
var _serializer;
var _stamp_specific_redirects;
var _headers;
var _syncFetchPayload = 0;
var _syncUnloadSender;
var _offlineListener;
var _evtNamespace;
var _endpointUrl;
var _orgEndpointUrl;
var _maxBatchSizeInBytes;
var _beaconSupported;
var _beaconOnUnloadSupported;
var _beaconNormalSupported;
var _customHeaders;
var _disableTelemetry;
var _instrumentationKey;
var _convertUndefined;
var _isRetryDisabled;
var _maxBatchInterval;
var _sessionStorageUsed;
var _bufferOverrideUsed;
var _namePrefix;
var _enableSendPromise;
var _alwaysUseCustomSend;
var _disableXhr;
var _fetchKeepAlive;
var _xhrSend;
var _fallbackSend;
var _disableBeaconSplit;
var _sendPostMgr;
var _retryCodes;
var _zipPayload;
dynamicProto(Sender2, _this, function(_self, _base) {
_initDefaults();
_self.pause = function() {
_clearScheduledTimer();
_paused = true;
};
_self.resume = function() {
if (_paused) {
_paused = false;
_retryAt = null;
_checkMaxSize();
_setupTimer();
}
};
_self.flush = function(isAsync, callBack, sendReason) {
if (isAsync === void 0) {
isAsync = true;
}
if (!_paused) {
_clearScheduledTimer();
try {
var result_1 = _self[_DYN_TRIGGER_SEND](isAsync, null, sendReason || 1);
return doAwaitResponse(result_1, function(rsp) {
if (callBack) {
callBack(!rsp.rejected);
return true;
}
if (isAsync) {
return createPromise(function(resolve3) {
resolve3(!rsp.rejected);
});
}
return result_1;
});
} catch (e) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 22, "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
};
_self.onunloadFlush = function() {
if (!_paused) {
if (_beaconSupported || _alwaysUseCustomSend) {
try {
return _self[_DYN_TRIGGER_SEND](true, _doUnloadSend, 2);
} catch (e) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 20, "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
} else {
_self.flush(false);
}
}
};
_self.addHeader = function(name, value) {
_headers[name] = value;
};
_self[_DYN_INITIALIZE] = function(config, core, extensions3, pluginChain) {
if (_self.isInitialized()) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 28, "Sender is already initialized");
}
_base[_DYN_INITIALIZE](config, core, extensions3, pluginChain);
var identifier = _self.identifier;
_serializer = new Serializer(core.logger);
_consecutiveErrors = 0;
_retryAt = null;
_self[_DYN__SENDER] = null;
_stamp_specific_redirects = 0;
var diagLog = _self[_DYN_DIAG_LOG]();
_evtNamespace = mergeEvtNamespace(createUniqueNamespace("Sender"), core.evtNamespace && core.evtNamespace());
_offlineListener = createOfflineListener(_evtNamespace);
_self._addHook(onConfigChange(config, function(details) {
var config2 = details.cfg;
if (config2.storagePrefix) {
utlSetStoragePrefix(config2.storagePrefix);
}
var ctx = createProcessTelemetryContext(null, config2, core);
var senderConfig = ctx.getExtCfg(identifier, defaultAppInsightsChannelConfig);
var curExtUrl = senderConfig[_DYN_ENDPOINT_URL$1];
if (_endpointUrl && curExtUrl === _endpointUrl) {
var coreUrl = config2[_DYN_ENDPOINT_URL$1];
if (coreUrl && coreUrl !== curExtUrl) {
senderConfig[_DYN_ENDPOINT_URL$1] = coreUrl;
}
}
var csStream = /* @__PURE__ */ getInst("CompressionStream");
_zipPayload = isFeatureEnabled("zipPayload", config2, false);
if (!isFunction(csStream)) {
_zipPayload = false;
}
var corsPolicy = senderConfig.corsPolicy;
if (corsPolicy) {
if (corsPolicy === "same-origin" || corsPolicy === "same-site" || corsPolicy === "cross-origin") {
_this.addHeader(CrossOriginResourcePolicyHeader, corsPolicy);
}
} else {
delete _headers[CrossOriginResourcePolicyHeader];
}
if (/* @__PURE__ */ isPromiseLike(senderConfig[_DYN_INSTRUMENTATION_KEY$1])) {
senderConfig[_DYN_INSTRUMENTATION_KEY$1] = config2[_DYN_INSTRUMENTATION_KEY$1];
}
objDefine(_self, "_senderConfig", {
g: function() {
return senderConfig;
}
});
if (_orgEndpointUrl !== senderConfig[_DYN_ENDPOINT_URL$1]) {
_endpointUrl = _orgEndpointUrl = senderConfig[_DYN_ENDPOINT_URL$1];
}
if (core.activeStatus() === ActiveStatus.PENDING) {
_self.pause();
} else if (core.activeStatus() === ActiveStatus.ACTIVE) {
_self.resume();
}
if (_customHeaders && _customHeaders !== senderConfig[_DYN_CUSTOM_HEADERS]) {
arrForEach(_customHeaders, function(customHeader) {
delete _headers[customHeader.header];
});
}
_maxBatchSizeInBytes = senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1];
_beaconSupported = (senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2] === false || senderConfig[_DYN_IS_BEACON_API_DISABL3] === false) && isBeaconsSupported();
_beaconOnUnloadSupported = senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2] === false && isBeaconsSupported();
_beaconNormalSupported = senderConfig[_DYN_IS_BEACON_API_DISABL3] === false && isBeaconsSupported();
_alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4];
_disableXhr = !!senderConfig.disableXhr;
_retryCodes = senderConfig.retryCodes;
var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE];
var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5] && (!!bufferOverride || utlCanUseSessionStorage());
var namePrefix = senderConfig.namePrefix;
var shouldUpdate = canUseSessionStorage !== _sessionStorageUsed || canUseSessionStorage && _namePrefix !== namePrefix || canUseSessionStorage && _bufferOverrideUsed !== bufferOverride;
if (_self[_DYN__BUFFER]) {
if (shouldUpdate) {
try {
_self[_DYN__BUFFER] = _self[_DYN__BUFFER].createNew(diagLog, senderConfig, canUseSessionStorage);
} catch (e) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 12, "failed to transfer telemetry to different buffer storage, telemetry will be lost: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
_checkMaxSize();
} else {
_self[_DYN__BUFFER] = canUseSessionStorage ? new SessionStorageSendBuffer(diagLog, senderConfig) : new ArraySendBuffer(diagLog, senderConfig);
}
_namePrefix = namePrefix;
_sessionStorageUsed = canUseSessionStorage;
_bufferOverrideUsed = bufferOverride;
_fetchKeepAlive = !senderConfig[_DYN_ONUNLOAD_DISABLE_FET6] && isFetchSupported(true);
_disableBeaconSplit = !!senderConfig[_DYN_DISABLE_SEND_BEACON_7];
_self._sample = new Sample(senderConfig.samplingPercentage, diagLog);
_instrumentationKey = senderConfig[_DYN_INSTRUMENTATION_KEY$1];
if (!/* @__PURE__ */ isPromiseLike(_instrumentationKey) && !_validateInstrumentationKey(_instrumentationKey, config2)) {
_throwInternal(diagLog, 1, 100, "Invalid Instrumentation key " + _instrumentationKey);
}
_customHeaders = senderConfig[_DYN_CUSTOM_HEADERS];
if (isString(_endpointUrl) && !isInternalApplicationInsightsEndpoint(_endpointUrl) && _customHeaders && _customHeaders[_DYN_LENGTH] > 0) {
arrForEach(_customHeaders, function(customHeader) {
_this.addHeader(customHeader.header, customHeader.value);
});
} else {
_customHeaders = null;
}
_enableSendPromise = senderConfig.enableSendPromise;
var sendPostConfig = _getSendPostMgrConfig();
if (!_sendPostMgr) {
_sendPostMgr = new SenderPostManager();
_sendPostMgr[_DYN_INITIALIZE](sendPostConfig, diagLog);
} else {
_sendPostMgr.SetConfig(sendPostConfig);
}
var customInterface = senderConfig.httpXHROverride;
var httpInterface = null;
var syncInterface = null;
var theTransports = prependTransports([3, 1, 2], senderConfig.transports);
httpInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST](theTransports, false);
var xhrInterface = _sendPostMgr && _sendPostMgr.getFallbackInst();
_xhrSend = function(payload, isAsync) {
return _doSend(xhrInterface, payload, isAsync);
};
_fallbackSend = function(payload, isAsync) {
return _doSend(xhrInterface, payload, isAsync, false);
};
httpInterface = _alwaysUseCustomSend ? customInterface : httpInterface || customInterface || xhrInterface;
_self[_DYN__SENDER] = function(payload, isAsync) {
return _doSend(httpInterface, payload, isAsync);
};
if (_fetchKeepAlive) {
_syncUnloadSender = _fetchKeepAliveSender;
}
var syncTransports = prependTransports([3, 1], senderConfig.unloadTransports);
if (!_fetchKeepAlive) {
syncTransports = syncTransports.filter(function(transport) {
return transport !== 2;
});
}
syncInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST](syncTransports, true);
syncInterface = _alwaysUseCustomSend ? customInterface : syncInterface || customInterface;
if ((_alwaysUseCustomSend || senderConfig.unloadTransports || !_syncUnloadSender) && syncInterface) {
_syncUnloadSender = function(payload, isAsync) {
return _doSend(syncInterface, payload, isAsync);
};
}
if (!_syncUnloadSender) {
_syncUnloadSender = _xhrSend;
}
_disableTelemetry = senderConfig.disableTelemetry;
_convertUndefined = senderConfig.convertUndefined || UNDEFINED_VALUE$1;
_isRetryDisabled = senderConfig.isRetryDisabled;
_maxBatchInterval = senderConfig.maxBatchInterval;
}));
};
_self.processTelemetry = function(telemetryItem, itemCtx) {
itemCtx = _self._getTelCtx(itemCtx);
var diagLogger = itemCtx[_DYN_DIAG_LOG]();
try {
var isValidate = _validate(telemetryItem, diagLogger);
if (!isValidate) {
return;
}
var aiEnvelope = _getEnvelope(telemetryItem, diagLogger);
if (!aiEnvelope) {
return;
}
var payload = _serializer.serialize(aiEnvelope);
var buffer = _self[_DYN__BUFFER];
_checkMaxSize(payload);
var payloadItem = {
item: payload,
cnt: 0
};
buffer[_DYN_ENQUEUE](payloadItem);
_setupTimer();
} catch (e) {
_throwInternal(diagLogger, 2, 12, "Failed adding telemetry to the sender's buffer, some telemetry will be lost: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
_self.processNext(telemetryItem, itemCtx);
};
_self.isCompletelyIdle = function() {
return !_paused && _syncFetchPayload === 0 && _self._buffer[_DYN_COUNT]() === 0;
};
_self.getOfflineListener = function() {
return _offlineListener;
};
_self._xhrReadyStateChange = function(xhr, payload, countOfItemsInPayload) {
if (_isStringArr(payload)) {
return;
}
return _xhrReadyStateChange(xhr, payload, countOfItemsInPayload);
};
_self[_DYN_TRIGGER_SEND] = function(isAsync, forcedSender, sendReason) {
if (isAsync === void 0) {
isAsync = true;
}
var result;
if (!_paused) {
try {
var buffer = _self[_DYN__BUFFER];
if (!_disableTelemetry) {
if (buffer[_DYN_COUNT]() > 0) {
var payload = buffer.getItems();
_notifySendRequest(sendReason || 0, isAsync);
if (forcedSender) {
result = forcedSender.call(_self, payload, isAsync);
} else {
result = _self[_DYN__SENDER](payload, isAsync);
}
}
} else {
buffer[_DYN_CLEAR]();
}
_clearScheduledTimer();
} catch (e) {
var ieVer = getIEVersion();
if (!ieVer || ieVer > 9) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 40, "Telemetry transmission failed, some telemetry will be lost: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
}
return result;
};
_self.getOfflineSupport = function() {
return {
getUrl: function() {
return _endpointUrl;
},
createPayload: _createPayload,
serialize: _serialize,
batch: _batch,
shouldProcess: function(evt) {
return !!_validate(evt);
}
};
};
_self._doTeardown = function(unloadCtx, unloadState) {
_self.onunloadFlush();
runTargetUnload(_offlineListener, false);
_initDefaults();
};
_self[_DYN__ON_ERROR] = function(payload, message, event) {
if (_isStringArr(payload)) {
return;
}
return _onError(payload, message);
};
_self[_DYN__ON_PARTIAL_SUCCESS] = function(payload, results) {
if (_isStringArr(payload)) {
return;
}
return _onPartialSuccess(payload, results);
};
_self[_DYN__ON_SUCCESS] = function(payload, countOfItemsInPayload) {
if (_isStringArr(payload)) {
return;
}
return _onSuccess(payload);
};
_self._xdrOnLoad = function(xdr, payload) {
if (_isStringArr(payload)) {
return;
}
return _xdrOnLoad(xdr, payload);
};
function _xdrOnLoad(xdr, payload) {
var responseText = _getResponseText(xdr);
if (xdr && (responseText + "" === "200" || responseText === "")) {
_consecutiveErrors = 0;
_self[_DYN__ON_SUCCESS](payload, 0);
} else {
var results = parseResponse(responseText);
if (results && results[_DYN_ITEMS_RECEIVED] && results[_DYN_ITEMS_RECEIVED] > results[_DYN_ITEMS_ACCEPTED] && !_isRetryDisabled) {
_self[_DYN__ON_PARTIAL_SUCCESS](payload, results);
} else {
_self[_DYN__ON_ERROR](payload, formatErrorMessageXdr(xdr));
}
}
}
function _getSendPostMgrConfig() {
try {
var onCompleteFuncs = {
xdrOnComplete: function(xdr, oncomplete, payload) {
var payloadArr = _getPayloadArr(payload);
if (!payloadArr) {
return;
}
return _xdrOnLoad(xdr, payloadArr);
},
fetchOnComplete: function(response, onComplete, resValue, payload) {
var payloadArr = _getPayloadArr(payload);
if (!payloadArr) {
return;
}
return _checkResponsStatus(response.status, payloadArr, response.url, payloadArr[_DYN_LENGTH], response.statusText, resValue || "");
},
xhrOnComplete: function(request, oncomplete, payload) {
var payloadArr = _getPayloadArr(payload);
if (!payloadArr) {
return;
}
return _xhrReadyStateChange(request, payloadArr, payloadArr[_DYN_LENGTH]);
},
beaconOnRetry: function(data, onComplete, canSend) {
return _onBeaconRetry(data, onComplete, canSend);
}
};
var config = {
enableSendPromise: _enableSendPromise,
isOneDs: false,
disableCredentials: false,
disableXhr: _disableXhr,
disableBeacon: !_beaconNormalSupported,
disableBeaconSync: !_beaconOnUnloadSupported,
senderOnCompleteCallBack: onCompleteFuncs
};
return config;
} catch (e) {
}
return null;
}
function _xhrReadyStateChange(xhr, payload, countOfItemsInPayload) {
if (xhr.readyState === 4) {
_checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
}
}
function _onError(payload, message, event) {
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 26, "Failed to send telemetry.", { message });
_self._buffer && _self._buffer[_DYN_CLEAR_SENT](payload);
}
function _onPartialSuccess(payload, results) {
var failed = [];
var retry = [];
var errors = results.errors.reverse();
for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
var error = errors_1[_i];
var extracted = payload.splice(error.index, 1)[0];
if (_isRetriable(error.statusCode)) {
retry[_DYN_PUSH](extracted);
} else {
failed[_DYN_PUSH](extracted);
}
}
if (payload[_DYN_LENGTH] > 0) {
_self[_DYN__ON_SUCCESS](payload, results[_DYN_ITEMS_ACCEPTED]);
}
if (failed[_DYN_LENGTH] > 0) {
_self[_DYN__ON_ERROR](failed, formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED], "of", results.itemsReceived].join(" ")));
}
if (retry[_DYN_LENGTH] > 0) {
_resendPayload(retry);
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, "Partial success. Delivered: " + payload[_DYN_LENGTH] + ", Failed: " + failed[_DYN_LENGTH] + ". Will retry to send " + retry[_DYN_LENGTH] + " our of " + results[_DYN_ITEMS_RECEIVED] + " items");
}
}
function _onSuccess(payload, countOfItemsInPayload) {
_self._buffer && _self._buffer[_DYN_CLEAR_SENT](payload);
}
function _getPayloadArr(payload) {
try {
if (payload) {
var internalPayload = payload;
var arr = internalPayload.oriPayload;
if (arr && arr[_DYN_LENGTH]) {
return arr;
}
return null;
}
} catch (e) {
}
return null;
}
function _validate(telemetryItem, diagLogger) {
if (_disableTelemetry) {
return false;
}
if (!telemetryItem) {
diagLogger && _throwInternal(diagLogger, 1, 7, "Cannot send empty telemetry");
return false;
}
if (telemetryItem.baseData && !telemetryItem[_DYN_BASE_TYPE]) {
diagLogger && _throwInternal(diagLogger, 1, 70, "Cannot send telemetry without baseData and baseType");
return false;
}
if (!telemetryItem[_DYN_BASE_TYPE]) {
telemetryItem[_DYN_BASE_TYPE] = "EventData";
}
if (!_self[_DYN__SENDER]) {
diagLogger && _throwInternal(diagLogger, 1, 28, "Sender was not initialized");
return false;
}
if (!_isSampledIn(telemetryItem)) {
diagLogger && _throwInternal(diagLogger, 2, 33, "Telemetry item was sampled out and not sent", { SampleRate: _self._sample[_DYN_SAMPLE_RATE] });
return false;
} else {
telemetryItem[SampleRate] = _self._sample[_DYN_SAMPLE_RATE];
}
return true;
}
function _getEnvelope(telemetryItem, diagLogger) {
var defaultEnvelopeIkey = telemetryItem.iKey || _instrumentationKey;
var aiEnvelope = Sender2.constructEnvelope(telemetryItem, defaultEnvelopeIkey, diagLogger, _convertUndefined);
if (!aiEnvelope) {
_throwInternal(diagLogger, 1, 47, "Unable to create an AppInsights envelope");
return;
}
var doNotSendItem = false;
if (telemetryItem[_DYN_TAGS] && telemetryItem[_DYN_TAGS][ProcessLegacy]) {
arrForEach(telemetryItem[_DYN_TAGS][ProcessLegacy], function(callBack) {
try {
if (callBack && callBack(aiEnvelope) === false) {
doNotSendItem = true;
_warnToConsole(diagLogger, "Telemetry processor check returns false");
}
} catch (e) {
_throwInternal(diagLogger, 1, 64, "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) }, true);
}
});
delete telemetryItem[_DYN_TAGS][ProcessLegacy];
}
if (doNotSendItem) {
return;
}
return aiEnvelope;
}
function _serialize(item) {
var rlt = EMPTY_STR;
var diagLogger = _self[_DYN_DIAG_LOG]();
try {
var valid = _validate(item, diagLogger);
var envelope = null;
if (valid) {
envelope = _getEnvelope(item, diagLogger);
}
if (envelope) {
rlt = _serializer.serialize(envelope);
}
} catch (e) {
}
return rlt;
}
function _batch(arr) {
var rlt = EMPTY_STR;
if (arr && arr[_DYN_LENGTH]) {
rlt = "[" + arr.join(",") + "]";
}
return rlt;
}
function _createPayload(data) {
var headers = _getHeaders();
return {
urlString: _endpointUrl,
data,
headers
};
}
function _isSampledIn(envelope) {
return _self._sample.isSampledIn(envelope);
}
function _getOnComplete(payload, status, headers, response) {
if (status === 200 && payload) {
_self._onSuccess(payload, payload[_DYN_LENGTH]);
} else {
response && _self[_DYN__ON_ERROR](payload, response);
}
}
function _doSend(sendInterface, payload, isAsync, markAsSent) {
if (markAsSent === void 0) {
markAsSent = true;
}
var onComplete = function(status, headers, response) {
return _getOnComplete(payload, status, headers, response);
};
var payloadData = _getPayload(payload);
var sendPostFunc = sendInterface && sendInterface.sendPOST;
if (sendPostFunc && payloadData) {
if (markAsSent) {
_self._buffer[_DYN_MARK_AS_SENT](payload);
}
var result_2;
var callbackExecuted_1 = false;
var resolveFn_1;
var rejectFn_1;
_sendPostMgr.preparePayload(function(processedPayload) {
result_2 = sendPostFunc(processedPayload, onComplete, !isAsync);
callbackExecuted_1 = true;
if (resolveFn_1) {
doAwait(result_2, resolveFn_1, rejectFn_1);
}
}, _zipPayload, payloadData, !isAsync);
if (callbackExecuted_1) {
return result_2;
}
return createPromise(function(resolve3, reject) {
resolveFn_1 = resolve3;
rejectFn_1 = reject;
});
}
return null;
}
function _getPayload(payload) {
if (isArray(payload) && payload[_DYN_LENGTH] > 0) {
var batch = _self[_DYN__BUFFER].batchPayloads(payload);
var headers = _getHeaders();
var payloadData = {
data: batch,
urlString: _endpointUrl,
headers,
disableXhrSync: _disableXhr,
disableFetchKeepAlive: !_fetchKeepAlive,
oriPayload: payload
};
return payloadData;
}
return null;
}
function _getHeaders() {
try {
var headers = _headers || {};
if (isInternalApplicationInsightsEndpoint(_endpointUrl)) {
headers[RequestHeaders[6]] = RequestHeaders[7];
}
return headers;
} catch (e) {
}
return null;
}
function _checkMaxSize(incomingPayload) {
var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH] : 0;
if (_self[_DYN__BUFFER].size() + incomingSize > _maxBatchSizeInBytes) {
if (!_offlineListener || _offlineListener.isOnline()) {
_self[_DYN_TRIGGER_SEND](true, null, 10);
}
return true;
}
return false;
}
function _checkResponsStatus(status, payload, responseUrl, countOfItemsInPayload, errorMessage, res) {
var response = null;
if (!_self._appId) {
response = parseResponse(res);
if (response && response.appId) {
_self._appId = response.appId;
}
}
if ((status < 200 || status >= 300) && status !== 0) {
if (status === 301 || status === 307 || status === 308) {
if (!_checkAndUpdateEndPointUrl(responseUrl)) {
_self[_DYN__ON_ERROR](payload, errorMessage);
return;
}
}
if (_offlineListener && !_offlineListener.isOnline()) {
if (!_isRetryDisabled) {
var offlineBackOffMultiplier = 10;
_resendPayload(payload, offlineBackOffMultiplier);
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, ". Offline - Response Code: ".concat(status, ". Offline status: ").concat(!_offlineListener.isOnline(), ". Will retry to send ").concat(payload.length, " items."));
}
return;
}
if (!_isRetryDisabled && _isRetriable(status)) {
_resendPayload(payload);
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, ". Response code " + status + ". Will retry to send " + payload[_DYN_LENGTH] + " items.");
} else {
_self[_DYN__ON_ERROR](payload, errorMessage);
}
} else {
_checkAndUpdateEndPointUrl(responseUrl);
if (status === 206) {
if (!response) {
response = parseResponse(res);
}
if (response && !_isRetryDisabled) {
_self[_DYN__ON_PARTIAL_SUCCESS](payload, response);
} else {
_self[_DYN__ON_ERROR](payload, errorMessage);
}
} else {
_consecutiveErrors = 0;
_self[_DYN__ON_SUCCESS](payload, countOfItemsInPayload);
}
}
}
function _checkAndUpdateEndPointUrl(responseUrl) {
if (_stamp_specific_redirects >= 10) {
return false;
}
if (!/* @__PURE__ */ isNullOrUndefined(responseUrl) && responseUrl !== "") {
if (responseUrl !== _endpointUrl) {
_endpointUrl = responseUrl;
++_stamp_specific_redirects;
return true;
}
}
return false;
}
function _doUnloadSend(payload, isAsync) {
if (_syncUnloadSender) {
_syncUnloadSender(payload, false);
} else {
var beaconInst = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST]([3], true);
return _doSend(beaconInst, payload, isAsync);
}
}
function _onBeaconRetry(payload, onComplete, canSend) {
var internalPayload = payload;
var data = internalPayload && internalPayload.oriPayload;
if (!_disableBeaconSplit) {
var droppedPayload = [];
for (var lp = 0; lp < data[_DYN_LENGTH]; lp++) {
var thePayload = data[lp];
var arr = [thePayload];
var item = _getPayload(arr);
if (!canSend(item, onComplete)) {
droppedPayload[_DYN_PUSH](thePayload);
} else {
_self._onSuccess(arr, arr[_DYN_LENGTH]);
}
}
if (droppedPayload[_DYN_LENGTH] > 0) {
_fallbackSend && _fallbackSend(droppedPayload, true);
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, ". Failed to send telemetry with Beacon API, retried with normal sender.");
}
} else {
_fallbackSend && _fallbackSend(data, true);
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, ". Failed to send telemetry with Beacon API, retried with normal sender.");
}
}
function _isStringArr(arr) {
try {
if (arr && arr[_DYN_LENGTH]) {
return isString(arr[0]);
}
} catch (e) {
}
return null;
}
function _fetchKeepAliveSender(payload, isAsync) {
var transport = null;
if (isArray(payload)) {
var payloadSize = payload[_DYN_LENGTH];
for (var lp = 0; lp < payload[_DYN_LENGTH]; lp++) {
payloadSize += payload[lp].item[_DYN_LENGTH];
}
var syncFetchPayload = _sendPostMgr.getSyncFetchPayload();
if (syncFetchPayload + payloadSize <= FetchSyncRequestSizeLimitBytes) {
transport = 2;
} else if (isBeaconsSupported()) {
transport = 3;
} else {
transport = 1;
_throwInternal(_self[_DYN_DIAG_LOG](), 2, 40, ". Failed to send telemetry with Beacon API, retried with xhrSender.");
}
var inst = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST]([transport], true);
return _doSend(inst, payload, isAsync);
}
return null;
}
function _resendPayload(payload, linearFactor) {
if (linearFactor === void 0) {
linearFactor = 1;
}
if (!payload || payload[_DYN_LENGTH] === 0) {
return;
}
var buffer = _self[_DYN__BUFFER];
buffer[_DYN_CLEAR_SENT](payload);
_consecutiveErrors++;
for (var _i = 0, payload_1 = payload; _i < payload_1.length; _i++) {
var item = payload_1[_i];
item.cnt = item.cnt || 0;
item.cnt++;
buffer[_DYN_ENQUEUE](item);
}
_setRetryTime(linearFactor);
_setupTimer();
}
function _setRetryTime(linearFactor) {
var SlotDelayInSeconds = 10;
var delayInSeconds;
if (_consecutiveErrors <= 1) {
delayInSeconds = SlotDelayInSeconds;
} else {
var backOffSlot = (Math.pow(2, _consecutiveErrors) - 1) / 2;
var backOffDelay = mathFloor(Math.random() * backOffSlot * SlotDelayInSeconds) + 1;
backOffDelay = linearFactor * backOffDelay;
delayInSeconds = mathMax(mathMin(backOffDelay, 3600), SlotDelayInSeconds);
}
var retryAfterTimeSpan = /* @__PURE__ */ utcNow() + delayInSeconds * 1e3;
_retryAt = retryAfterTimeSpan;
}
function _setupTimer() {
if (!_timeoutHandle && !_paused) {
var retryInterval = _retryAt ? mathMax(0, _retryAt - /* @__PURE__ */ utcNow()) : 0;
var timerValue = mathMax(_maxBatchInterval, retryInterval);
_timeoutHandle = scheduleTimeout(function() {
_timeoutHandle = null;
_self[_DYN_TRIGGER_SEND](true, null, 1);
}, timerValue);
}
}
function _clearScheduledTimer() {
_timeoutHandle && _timeoutHandle.cancel();
_timeoutHandle = null;
_retryAt = null;
}
function _isRetriable(statusCode) {
if (!/* @__PURE__ */ isNullOrUndefined(_retryCodes)) {
return _retryCodes[_DYN_LENGTH] && _retryCodes.indexOf(statusCode) > -1;
}
return statusCode === 401 || statusCode === 408 || statusCode === 429 || statusCode === 500 || statusCode === 502 || statusCode === 503 || statusCode === 504;
}
function _getNotifyMgr() {
var func = "getNotifyMgr";
var result;
var core = _self.core;
if (core) {
if (core[func]) {
result = core[func]();
} else {
result = core["_notificationManager"];
}
}
return result;
}
function _notifySendRequest(sendRequest, isAsync) {
var manager = _getNotifyMgr();
if (manager && manager.eventsSendRequest) {
try {
manager.eventsSendRequest(sendRequest, isAsync);
} catch (e) {
_throwInternal(_self[_DYN_DIAG_LOG](), 1, 74, "send request notification failed: " + getExceptionName(e), { exception: /* @__PURE__ */ dumpObj(e) });
}
}
}
function _validateInstrumentationKey(instrumentationKey, config) {
var disableValidation = config.disableInstrumentationKeyValidation;
var disableIKeyValidationFlag = /* @__PURE__ */ isNullOrUndefined(disableValidation) ? false : disableValidation;
if (disableIKeyValidationFlag) {
return true;
}
var UUID_Regex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
var regexp = new RegExp(UUID_Regex);
return regexp.test(instrumentationKey);
}
function _initDefaults() {
_self[_DYN__SENDER] = null;
_self[_DYN__BUFFER] = null;
_self._appId = null;
_self._sample = null;
_headers = {};
_offlineListener = null;
_consecutiveErrors = 0;
_retryAt = null;
_paused = false;
_timeoutHandle = null;
_serializer = null;
_stamp_specific_redirects = 0;
_syncFetchPayload = 0;
_syncUnloadSender = null;
_evtNamespace = null;
_endpointUrl = null;
_orgEndpointUrl = null;
_maxBatchSizeInBytes = 0;
_beaconSupported = false;
_customHeaders = null;
_disableTelemetry = false;
_instrumentationKey = null;
_convertUndefined = UNDEFINED_VALUE$1;
_isRetryDisabled = false;
_sessionStorageUsed = null;
_namePrefix = UNDEFINED_VALUE$1;
_disableXhr = false;
_fetchKeepAlive = false;
_disableBeaconSplit = false;
_xhrSend = null;
_fallbackSend = null;
_sendPostMgr = null;
objDefine(_self, "_senderConfig", {
g: function() {
return objExtend({}, defaultAppInsightsChannelConfig);
}
});
}
});
return _this;
}
Sender2.constructEnvelope = function(orig, iKey, logger2, convertUndefined) {
var envelope;
if (iKey !== orig.iKey && !/* @__PURE__ */ isNullOrUndefined(iKey)) {
envelope = __assignFn(__assignFn({}, orig), { iKey });
} else {
envelope = orig;
}
var creator = EnvelopeTypeCreator[envelope.baseType] || EventEnvelopeCreator;
return creator(logger2, envelope, convertUndefined);
};
return Sender2;
})(BaseTelemetryPlugin)
);
var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
var _DYN_CONNECTION_STRING = "connectionString";
var _DYN_ENDPOINT_URL = "endpointUrl";
var _DYN_USER_OVERRIDE_ENDPOI0 = "userOverrideEndpointUrl";
var _a, _b;
var UNDEFINED_VALUE = void 0;
var defaultConfigValues = (_a = {
diagnosticLogInterval: cfgDfValidate(_chkDiagLevel, 1e4)
}, _a[_DYN_CONNECTION_STRING] = UNDEFINED_VALUE, _a.endpointUrl = UNDEFINED_VALUE, _a[_DYN_INSTRUMENTATION_KEY] = UNDEFINED_VALUE, _a.featureOptIn = (_b = {}, _b["zipPayload"] = { mode: 1 }, _b), _a.extensionConfig = {}, _a);
function _chkDiagLevel(value) {
return value && value > 0;
}
var ApplicationInsights = (
/** @class */
(function() {
function ApplicationInsights2(config) {
var core = new AppInsightsCore();
var _config;
if (/* @__PURE__ */ isNullOrUndefined(config) || /* @__PURE__ */ isNullOrUndefined(config[_DYN_INSTRUMENTATION_KEY]) && /* @__PURE__ */ isNullOrUndefined(config[_DYN_CONNECTION_STRING])) {
throwError("Invalid input configuration");
}
dynamicProto(ApplicationInsights2, this, function(_self) {
objDefine(_self, "config", {
g: function() {
return _config;
}
});
_initialize();
_self.initialize = _initialize;
_self.track = _track;
proxyFunctions(_self, core, [
"flush",
"pollInternalLogs",
"stopPollingInternalLogs",
"unload",
"getPlugin",
"addPlugin",
"evtNamespace",
"addUnloadCb",
"onCfgChange",
"getTraceCtx",
"updateCfg",
"addTelemetryInitializer"
]);
function _initialize() {
var cfgHandler = createDynamicConfig(config || {}, defaultConfigValues);
_config = cfgHandler.cfg;
core.addUnloadHook(onConfigChange(cfgHandler, function() {
var configCs = _config[_DYN_CONNECTION_STRING];
if (/* @__PURE__ */ isPromiseLike(configCs)) {
var ikeyPromise = createSyncPromise(function(resolve3, reject) {
doAwaitResponse(configCs, function(res) {
var curCs = res.value;
var ikey = _config[_DYN_INSTRUMENTATION_KEY];
if (!res.rejected && curCs) {
_config[_DYN_CONNECTION_STRING] = curCs;
var resolvedCs = parseConnectionString(curCs);
ikey = resolvedCs.instrumentationkey || ikey;
}
resolve3(ikey);
});
});
var urlPromise = createSyncPromise(function(resolve3, reject) {
doAwaitResponse(configCs, function(res) {
var curCs = res.value;
var url = _config[_DYN_ENDPOINT_URL];
if (!res.rejected && curCs) {
var resolvedCs = parseConnectionString(curCs);
var ingest2 = resolvedCs.ingestionendpoint;
url = ingest2 ? ingest2 + DEFAULT_BREEZE_PATH : url;
}
resolve3(url);
});
});
_config[_DYN_INSTRUMENTATION_KEY] = ikeyPromise;
_config[_DYN_ENDPOINT_URL] = _config[_DYN_USER_OVERRIDE_ENDPOI0] || urlPromise;
}
if (isString(configCs)) {
var cs = parseConnectionString(configCs);
var ingest = cs.ingestionendpoint;
_config[_DYN_ENDPOINT_URL] = _config[_DYN_USER_OVERRIDE_ENDPOI0] ? _config[_DYN_USER_OVERRIDE_ENDPOI0] : ingest + DEFAULT_BREEZE_PATH;
_config[_DYN_INSTRUMENTATION_KEY] = cs.instrumentationkey || _config[_DYN_INSTRUMENTATION_KEY];
}
_config[_DYN_ENDPOINT_URL] = _config[_DYN_USER_OVERRIDE_ENDPOI0] ? _config[_DYN_USER_OVERRIDE_ENDPOI0] : _config[_DYN_ENDPOINT_URL];
}));
core.initialize(_config, [new Sender()]);
}
});
function _track(item) {
if (item) {
item.baseData = item.baseData || {};
item.baseType = item.baseType || "EventData";
}
core.track(item);
}
}
ApplicationInsights2.__ieDyn = 1;
return ApplicationInsights2;
})()
);
exports3.AppInsightsCore = AppInsightsCore;
exports3.ApplicationInsights = ApplicationInsights;
exports3.Sender = Sender;
exports3.SeverityLevel = SeverityLevel;
exports3.arrForEach = arrForEach;
exports3.isNullOrUndefined = isNullOrUndefined;
exports3.proxyFunctions = proxyFunctions;
exports3.throwError = throwError;
}));
}
});
// node_modules/@vscode/extension-telemetry/dist/node/common/appInsightsClientFactory.js
var require_appInsightsClientFactory = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/common/appInsightsClientFactory.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = exports2 && exports2.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.appInsightsClientFactory = void 0;
var applicationinsights_common_1 = require_applicationinsights_common();
var util_1 = require_util();
var appInsightsClientFactory = async (connectionString, machineId, sessionId, xhrOverride, replacementOptions) => {
let appInsightsClient;
try {
const basicAISDK = await Promise.resolve().then(() => __importStar(require_applicationinsights_web_basic()));
const extensionConfig = {};
if (xhrOverride) {
const channelConfig = {
alwaysUseXhrOverride: true,
httpXHROverride: xhrOverride
};
extensionConfig[applicationinsights_common_1.BreezeChannelIdentifier] = channelConfig;
}
let instrumentationKey;
if (!connectionString.startsWith("InstrumentationKey=")) {
instrumentationKey = connectionString;
}
const authConfig = instrumentationKey ? { instrumentationKey } : { connectionString };
appInsightsClient = new basicAISDK.ApplicationInsights({
...authConfig,
disableAjaxTracking: true,
disableExceptionTracking: true,
disableFetchTracking: true,
disableCorrelationHeaders: true,
disableCookiesUsage: true,
autoTrackPageVisitTime: false,
emitLineDelimitedJson: false,
disableInstrumentationKeyValidation: true,
extensionConfig
});
} catch (e) {
return Promise.reject(e);
}
const telemetryClient = {
logEvent: (eventName, data) => {
const properties = { ...data?.properties, ...data?.measurements };
if (replacementOptions?.length) {
util_1.TelemetryUtil.applyReplacements(properties, replacementOptions);
}
appInsightsClient?.track({
name: eventName,
data: properties,
baseType: "EventData",
ext: { user: { id: machineId, authId: machineId }, app: { sesId: sessionId } },
baseData: { name: eventName, properties: data?.properties, measurements: data?.measurements }
});
},
flush: async () => {
appInsightsClient?.flush(false);
},
dispose: async () => {
const unloadPromise = new Promise((resolve3) => {
appInsightsClient?.unload(true, () => {
resolve3();
appInsightsClient = void 0;
}, 1e3);
});
return unloadPromise;
}
};
return telemetryClient;
};
exports2.appInsightsClientFactory = appInsightsClientFactory;
}
});
// node_modules/@vscode/extension-telemetry/dist/node/common/baseTelemetryReporter.js
var require_baseTelemetryReporter = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/common/baseTelemetryReporter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.BaseTelemetryReporter = void 0;
var BaseTelemetryReporter = class {
constructor(telemetrySender, vscodeAPI, initializationOptions) {
this.telemetrySender = telemetrySender;
this.vscodeAPI = vscodeAPI;
this.userOptIn = false;
this.errorOptIn = false;
this.disposables = [];
this._onDidChangeTelemetryLevel = new this.vscodeAPI.EventEmitter();
this.onDidChangeTelemetryLevel = this._onDidChangeTelemetryLevel.event;
this.telemetryLogger = this.vscodeAPI.env.createTelemetryLogger(this.telemetrySender, initializationOptions);
this.updateUserOptIn();
this.telemetryLogger.onDidChangeEnableStates(() => {
this.updateUserOptIn();
});
}
/**
* Updates the user's telemetry opt-in status
*/
updateUserOptIn() {
this.errorOptIn = this.telemetryLogger.isErrorsEnabled;
this.userOptIn = this.telemetryLogger.isUsageEnabled;
if (this.telemetryLogger.isErrorsEnabled || this.telemetryLogger.isUsageEnabled) {
this.telemetrySender.instantiateSender();
}
this._onDidChangeTelemetryLevel.fire(this.telemetryLevel);
}
get telemetryLevel() {
if (this.errorOptIn && this.userOptIn) {
return "all";
} else if (this.errorOptIn) {
return "error";
} else {
return "off";
}
}
/**
* Internal function which logs telemetry events and takes extra options.
* @param eventName The name of the event
* @param properties The properties of the event
* @param measurements The measurements (numeric values) to send with the event
* @param sanitize Whether or not to sanitize to the properties and measures
* @param dangerous Whether or not to ignore telemetry level
*/
internalSendTelemetryEvent(eventName, properties, measurements, dangerous) {
if (dangerous) {
this.telemetrySender.sendEventData(eventName, { properties, measurements });
} else {
this.telemetryLogger.logUsage(eventName, { properties, measurements });
}
}
/**
* Given an event name, some properties, and measurements sends a telemetry event.
* Properties are sanitized on best-effort basis to remove sensitive data prior to sending.
* @param eventName The name of the event
* @param properties The properties to send with the event
* @param measurements The measurements (numeric values) to send with the event
*/
sendTelemetryEvent(eventName, properties, measurements) {
this.internalSendTelemetryEvent(eventName, properties, measurements, false);
}
/**
* Sends a raw (unsanitized) telemetry event with the given properties and measurements.
* NOTE: This will not be logged to the output channel due to API limitations.
* @param eventName The name of the event
* @param properties The set of properties to add to the event in the form of a string key value pair
* @param measurements The set of measurements to add to the event in the form of a string key number value pair
*/
sendRawTelemetryEvent(eventName, properties, measurements) {
const modifiedProperties = { ...properties };
for (const propertyKey of Object.keys(modifiedProperties ?? {})) {
const propertyValue = modifiedProperties[propertyKey];
if (typeof propertyKey === "string" && propertyValue !== void 0) {
modifiedProperties[propertyKey] = new this.vscodeAPI.TelemetryTrustedValue(typeof propertyValue === "string" ? propertyValue : propertyValue.value);
}
}
this.sendTelemetryEvent(eventName, modifiedProperties, measurements);
}
/**
* **DANGEROUS** Given an event name, some properties, and measurements sends a telemetry event without checking telemetry setting
* Do not use unless in a controlled environment i.e. sending telmetry from a CI pipeline or testing during development
* @param eventName The name of the event
* @param properties The properties to send with the event
* @param measurements The measurements (numeric values) to send with the event
* @param sanitize Whether or not to sanitize to the properties and measures, defaults to true
*/
sendDangerousTelemetryEvent(eventName, properties, measurements) {
this.telemetrySender.instantiateSender();
this.internalSendTelemetryEvent(eventName, properties, measurements, true);
}
/**
* Internal function which logs telemetry error events and takes extra options.
* @param eventName The name of the event
* @param properties The properties of the event
* @param measurements The measurements (numeric values) to send with the event
* @param sanitize Whether or not to sanitize to the properties and measures
* @param dangerous Whether or not to ignore telemetry level
*/
internalSendTelemetryErrorEvent(eventName, properties, measurements, dangerous) {
if (dangerous) {
this.telemetrySender.sendEventData(eventName, { properties, measurements });
} else {
this.telemetryLogger.logError(eventName, { properties, measurements });
}
}
/**
* Given an event name, some properties, and measurements sends an error event
* @param eventName The name of the event
* @param properties The properties to send with the event
* @param measurements The measurements (numeric values) to send with the event
*/
sendTelemetryErrorEvent(eventName, properties, measurements) {
this.internalSendTelemetryErrorEvent(eventName, properties, measurements, false);
}
/**
* **DANGEROUS** Given an event name, some properties, and measurements sends a telemetry error event without checking telemetry setting
* Do not use unless in a controlled environment i.e. sending telmetry from a CI pipeline or testing during development
* @param eventName The name of the event
* @param properties The properties to send with the event
* @param measurements The measurements (numeric values) to send with the event
* @param sanitize Whether or not to run the properties and measures through sanitiziation, defaults to true
*/
sendDangerousTelemetryErrorEvent(eventName, properties, measurements) {
this.telemetrySender.instantiateSender();
this.internalSendTelemetryErrorEvent(eventName, properties, measurements, true);
}
/**
* Disposes of the telemetry reporter
*/
async dispose() {
await this.telemetrySender.dispose();
this.telemetryLogger.dispose();
return Promise.all(this.disposables.map((d) => d.dispose()));
}
};
exports2.BaseTelemetryReporter = BaseTelemetryReporter;
}
});
// node_modules/@vscode/extension-telemetry/dist/node/common/baseTelemetrySender.js
var require_baseTelemetrySender = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/common/baseTelemetrySender.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.BaseTelemetrySender = void 0;
var InstantiationStatus;
(function(InstantiationStatus2) {
InstantiationStatus2[InstantiationStatus2["NOT_INSTANTIATED"] = 0] = "NOT_INSTANTIATED";
InstantiationStatus2[InstantiationStatus2["INSTANTIATING"] = 1] = "INSTANTIATING";
InstantiationStatus2[InstantiationStatus2["INSTANTIATED"] = 2] = "INSTANTIATED";
})(InstantiationStatus || (InstantiationStatus = {}));
var BaseTelemetrySender = class {
constructor(key, clientFactory) {
this._instantiationStatus = InstantiationStatus.NOT_INSTANTIATED;
this._eventQueue = [];
this._exceptionQueue = [];
this._clientFactory = clientFactory;
this._key = key;
}
/**
* Sends the event to the passed in telemetry client
* The sender does no telemetry level checks as those are done by the reporter.
* @param eventName The name of the event to log
* @param data The data contanied in the event
*/
sendEventData(eventName, data) {
if (!this._telemetryClient) {
if (this._instantiationStatus !== InstantiationStatus.INSTANTIATED) {
this._eventQueue.push({ eventName, data });
}
return;
}
this._telemetryClient.logEvent(eventName, data);
}
/**
* Sends an exception to the passed in telemetry client
* The sender does no telemetry level checks as those are done by the reporter.
* @param exception The exception to collect
* @param data Data associated with the exception
*/
sendErrorData(exception, data) {
if (!this._telemetryClient) {
if (this._instantiationStatus !== InstantiationStatus.INSTANTIATED) {
this._exceptionQueue.push({ exception, data });
}
return;
}
const errorData = { stack: exception.stack, message: exception.message, name: exception.name };
if (data) {
const errorProperties = data.properties || data;
data.properties = { ...errorProperties, ...errorData };
} else {
data = { properties: errorData };
}
this._telemetryClient.logEvent("unhandlederror", data);
}
/**
* Flushes the buffered telemetry data
*/
async flush() {
return this._telemetryClient?.flush();
}
async dispose() {
if (this._telemetryClient) {
await this._telemetryClient.dispose();
this._telemetryClient = void 0;
}
return;
}
/**
* Flushes the queued events that existed before the client was instantiated
*/
_flushQueues() {
this._eventQueue.forEach(({ eventName, data }) => this.sendEventData(eventName, data));
this._eventQueue = [];
this._exceptionQueue.forEach(({ exception, data }) => this.sendErrorData(exception, data));
this._exceptionQueue = [];
}
/**
* Instantiates the telemetry client to make the sender "active"
*/
instantiateSender() {
if (this._instantiationStatus !== InstantiationStatus.NOT_INSTANTIATED) {
return;
}
this._instantiationStatus = InstantiationStatus.INSTANTIATING;
this._clientFactory(this._key).then((client) => {
this._telemetryClient = client;
this._instantiationStatus = InstantiationStatus.INSTANTIATED;
this._flushQueues();
}).catch((err) => {
console.error(err);
this._instantiationStatus = InstantiationStatus.INSTANTIATED;
});
}
};
exports2.BaseTelemetrySender = BaseTelemetrySender;
}
});
// node_modules/@vscode/extension-telemetry/dist/node/node/telemetryReporter.js
var require_telemetryReporter = __commonJS({
"node_modules/@vscode/extension-telemetry/dist/node/node/telemetryReporter.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = exports2 && exports2.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports2, "__esModule", { value: true });
var https = __importStar(require("https"));
var os5 = __importStar(require("os"));
var vscode22 = __importStar(require("vscode"));
var _1dsClientFactory_1 = require_dsClientFactory();
var appInsightsClientFactory_1 = require_appInsightsClientFactory();
var baseTelemetryReporter_1 = require_baseTelemetryReporter();
var baseTelemetrySender_1 = require_baseTelemetrySender();
var util_1 = require_util();
function getXHROverride() {
const customHttpXHROverride = {
sendPOST: (payload, oncomplete) => {
const options = {
method: "POST",
headers: {
...payload.headers,
"Content-Type": "application/json",
"Content-Length": Buffer.byteLength(payload.data)
}
};
try {
const req = https.request(payload.urlString, options, (res) => {
res.on("data", function(responseData) {
oncomplete(res.statusCode ?? 200, res.headers, responseData.toString());
});
res.on("error", function() {
oncomplete(0, {});
});
});
req.write(payload.data, (err) => {
if (err) {
oncomplete(0, {});
}
});
req.end();
} catch {
oncomplete(0, {});
}
}
};
return customHttpXHROverride;
}
var TelemetryReporter2 = class extends baseTelemetryReporter_1.BaseTelemetryReporter {
constructor(connectionString, replacementOptions) {
let clientFactory = (connectionString2) => (0, appInsightsClientFactory_1.appInsightsClientFactory)(connectionString2, vscode22.env.machineId, vscode22.env.sessionId, getXHROverride(), replacementOptions);
if (util_1.TelemetryUtil.shouldUseOneDataSystemSDK(connectionString)) {
clientFactory = (key) => (0, _1dsClientFactory_1.oneDataSystemClientFactory)(key, vscode22, getXHROverride());
}
const osShim = {
release: os5.release(),
platform: os5.platform(),
architecture: os5.arch()
};
const sender = new baseTelemetrySender_1.BaseTelemetrySender(connectionString, clientFactory);
if (connectionString && connectionString.indexOf("AIF-") === 0) {
throw new Error("AIF keys are no longer supported. Please switch to 1DS keys for 1st party extensions");
}
super(sender, vscode22, { additionalCommonProperties: util_1.TelemetryUtil.getAdditionalCommonProperties(osShim) });
}
};
exports2.default = TelemetryReporter2;
}
});
// node_modules/vscode-languageclient/lib/common/utils/is.js
var require_is = __commonJS({
"node_modules/vscode-languageclient/lib/common/utils/is.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.asPromise = exports2.thenable = exports2.typedArray = exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
function boolean(value) {
return value === true || value === false;
}
exports2.boolean = boolean;
function string(value) {
return typeof value === "string" || value instanceof String;
}
exports2.string = string;
function number(value) {
return typeof value === "number" || value instanceof Number;
}
exports2.number = number;
function error(value) {
return value instanceof Error;
}
exports2.error = error;
function func(value) {
return typeof value === "function";
}
exports2.func = func;
function array(value) {
return Array.isArray(value);
}
exports2.array = array;
function stringArray(value) {
return array(value) && value.every((elem) => string(elem));
}
exports2.stringArray = stringArray;
function typedArray(value, check) {
return Array.isArray(value) && value.every(check);
}
exports2.typedArray = typedArray;
function thenable(value) {
return value && func(value.then);
}
exports2.thenable = thenable;
function asPromise(value) {
if (value instanceof Promise) {
return value;
} else if (thenable(value)) {
return new Promise((resolve3, reject) => {
value.then((resolved) => resolve3(resolved), (error2) => reject(error2));
});
} else {
return Promise.resolve(value);
}
}
exports2.asPromise = asPromise;
}
});
// node_modules/vscode-jsonrpc/lib/common/is.js
var require_is2 = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/is.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
function boolean(value) {
return value === true || value === false;
}
exports2.boolean = boolean;
function string(value) {
return typeof value === "string" || value instanceof String;
}
exports2.string = string;
function number(value) {
return typeof value === "number" || value instanceof Number;
}
exports2.number = number;
function error(value) {
return value instanceof Error;
}
exports2.error = error;
function func(value) {
return typeof value === "function";
}
exports2.func = func;
function array(value) {
return Array.isArray(value);
}
exports2.array = array;
function stringArray(value) {
return array(value) && value.every((elem) => string(elem));
}
exports2.stringArray = stringArray;
}
});
// node_modules/vscode-jsonrpc/lib/common/messages.js
var require_messages = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/messages.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.Message = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType = exports2.RequestType0 = exports2.AbstractMessageSignature = exports2.ParameterStructures = exports2.ResponseError = exports2.ErrorCodes = void 0;
var is = require_is2();
var ErrorCodes;
(function(ErrorCodes2) {
ErrorCodes2.ParseError = -32700;
ErrorCodes2.InvalidRequest = -32600;
ErrorCodes2.MethodNotFound = -32601;
ErrorCodes2.InvalidParams = -32602;
ErrorCodes2.InternalError = -32603;
ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
ErrorCodes2.serverErrorStart = -32099;
ErrorCodes2.MessageWriteError = -32099;
ErrorCodes2.MessageReadError = -32098;
ErrorCodes2.PendingResponseRejected = -32097;
ErrorCodes2.ConnectionInactive = -32096;
ErrorCodes2.ServerNotInitialized = -32002;
ErrorCodes2.UnknownErrorCode = -32001;
ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
ErrorCodes2.serverErrorEnd = -32e3;
})(ErrorCodes || (exports2.ErrorCodes = ErrorCodes = {}));
var ResponseError = class _ResponseError extends Error {
constructor(code, message, data) {
super(message);
this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
this.data = data;
Object.setPrototypeOf(this, _ResponseError.prototype);
}
toJson() {
const result = {
code: this.code,
message: this.message
};
if (this.data !== void 0) {
result.data = this.data;
}
return result;
}
};
exports2.ResponseError = ResponseError;
var ParameterStructures = class _ParameterStructures {
constructor(kind) {
this.kind = kind;
}
static is(value) {
return value === _ParameterStructures.auto || value === _ParameterStructures.byName || value === _ParameterStructures.byPosition;
}
toString() {
return this.kind;
}
};
exports2.ParameterStructures = ParameterStructures;
ParameterStructures.auto = new ParameterStructures("auto");
ParameterStructures.byPosition = new ParameterStructures("byPosition");
ParameterStructures.byName = new ParameterStructures("byName");
var AbstractMessageSignature = class {
constructor(method, numberOfParams) {
this.method = method;
this.numberOfParams = numberOfParams;
}
get parameterStructures() {
return ParameterStructures.auto;
}
};
exports2.AbstractMessageSignature = AbstractMessageSignature;
var RequestType03 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 0);
}
};
exports2.RequestType0 = RequestType03;
var RequestType6 = class extends AbstractMessageSignature {
constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
this._parameterStructures = _parameterStructures;
}
get parameterStructures() {
return this._parameterStructures;
}
};
exports2.RequestType = RequestType6;
var RequestType1 = class extends AbstractMessageSignature {
constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
this._parameterStructures = _parameterStructures;
}
get parameterStructures() {
return this._parameterStructures;
}
};
exports2.RequestType1 = RequestType1;
var RequestType22 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 2);
}
};
exports2.RequestType2 = RequestType22;
var RequestType32 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 3);
}
};
exports2.RequestType3 = RequestType32;
var RequestType42 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 4);
}
};
exports2.RequestType4 = RequestType42;
var RequestType52 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 5);
}
};
exports2.RequestType5 = RequestType52;
var RequestType62 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 6);
}
};
exports2.RequestType6 = RequestType62;
var RequestType7 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 7);
}
};
exports2.RequestType7 = RequestType7;
var RequestType8 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 8);
}
};
exports2.RequestType8 = RequestType8;
var RequestType9 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 9);
}
};
exports2.RequestType9 = RequestType9;
var NotificationType7 = class extends AbstractMessageSignature {
constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
this._parameterStructures = _parameterStructures;
}
get parameterStructures() {
return this._parameterStructures;
}
};
exports2.NotificationType = NotificationType7;
var NotificationType02 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 0);
}
};
exports2.NotificationType0 = NotificationType02;
var NotificationType1 = class extends AbstractMessageSignature {
constructor(method, _parameterStructures = ParameterStructures.auto) {
super(method, 1);
this._parameterStructures = _parameterStructures;
}
get parameterStructures() {
return this._parameterStructures;
}
};
exports2.NotificationType1 = NotificationType1;
var NotificationType22 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 2);
}
};
exports2.NotificationType2 = NotificationType22;
var NotificationType32 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 3);
}
};
exports2.NotificationType3 = NotificationType32;
var NotificationType42 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 4);
}
};
exports2.NotificationType4 = NotificationType42;
var NotificationType52 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 5);
}
};
exports2.NotificationType5 = NotificationType52;
var NotificationType62 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 6);
}
};
exports2.NotificationType6 = NotificationType62;
var NotificationType72 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 7);
}
};
exports2.NotificationType7 = NotificationType72;
var NotificationType8 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 8);
}
};
exports2.NotificationType8 = NotificationType8;
var NotificationType9 = class extends AbstractMessageSignature {
constructor(method) {
super(method, 9);
}
};
exports2.NotificationType9 = NotificationType9;
var Message2;
(function(Message3) {
function isRequest(message) {
const candidate = message;
return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
}
Message3.isRequest = isRequest;
function isNotification(message) {
const candidate = message;
return candidate && is.string(candidate.method) && message.id === void 0;
}
Message3.isNotification = isNotification;
function isResponse(message) {
const candidate = message;
return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
}
Message3.isResponse = isResponse;
})(Message2 || (exports2.Message = Message2 = {}));
}
});
// node_modules/vscode-jsonrpc/lib/common/linkedMap.js
var require_linkedMap = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/linkedMap.js"(exports2) {
"use strict";
var _a;
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.LRUCache = exports2.LinkedMap = exports2.Touch = void 0;
var Touch;
(function(Touch2) {
Touch2.None = 0;
Touch2.First = 1;
Touch2.AsOld = Touch2.First;
Touch2.Last = 2;
Touch2.AsNew = Touch2.Last;
})(Touch || (exports2.Touch = Touch = {}));
var LinkedMap = class {
constructor() {
this[_a] = "LinkedMap";
this._map = /* @__PURE__ */ new Map();
this._head = void 0;
this._tail = void 0;
this._size = 0;
this._state = 0;
}
clear() {
this._map.clear();
this._head = void 0;
this._tail = void 0;
this._size = 0;
this._state++;
}
isEmpty() {
return !this._head && !this._tail;
}
get size() {
return this._size;
}
get first() {
return this._head?.value;
}
get last() {
return this._tail?.value;
}
has(key) {
return this._map.has(key);
}
get(key, touch = Touch.None) {
const item = this._map.get(key);
if (!item) {
return void 0;
}
if (touch !== Touch.None) {
this.touch(item, touch);
}
return item.value;
}
set(key, value, touch = Touch.None) {
let item = this._map.get(key);
if (item) {
item.value = value;
if (touch !== Touch.None) {
this.touch(item, touch);
}
} else {
item = { key, value, next: void 0, previous: void 0 };
switch (touch) {
case Touch.None:
this.addItemLast(item);
break;
case Touch.First:
this.addItemFirst(item);
break;
case Touch.Last:
this.addItemLast(item);
break;
default:
this.addItemLast(item);
break;
}
this._map.set(key, item);
this._size++;
}
return this;
}
delete(key) {
return !!this.remove(key);
}
remove(key) {
const item = this._map.get(key);
if (!item) {
return void 0;
}
this._map.delete(key);
this.removeItem(item);
this._size--;
return item.value;
}
shift() {
if (!this._head && !this._tail) {
return void 0;
}
if (!this._head || !this._tail) {
throw new Error("Invalid list");
}
const item = this._head;
this._map.delete(item.key);
this.removeItem(item);
this._size--;
return item.value;
}
forEach(callbackfn, thisArg) {
const state = this._state;
let current = this._head;
while (current) {
if (thisArg) {
callbackfn.bind(thisArg)(current.value, current.key, this);
} else {
callbackfn(current.value, current.key, this);
}
if (this._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
current = current.next;
}
}
keys() {
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]: () => {
return iterator;
},
next: () => {
if (this._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: current.key, done: false };
current = current.next;
return result;
} else {
return { value: void 0, done: true };
}
}
};
return iterator;
}
values() {
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]: () => {
return iterator;
},
next: () => {
if (this._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: current.value, done: false };
current = current.next;
return result;
} else {
return { value: void 0, done: true };
}
}
};
return iterator;
}
entries() {
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]: () => {
return iterator;
},
next: () => {
if (this._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: [current.key, current.value], done: false };
current = current.next;
return result;
} else {
return { value: void 0, done: true };
}
}
};
return iterator;
}
[(_a = Symbol.toStringTag, Symbol.iterator)]() {
return this.entries();
}
trimOld(newSize) {
if (newSize >= this.size) {
return;
}
if (newSize === 0) {
this.clear();
return;
}
let current = this._head;
let currentSize = this.size;
while (current && currentSize > newSize) {
this._map.delete(current.key);
current = current.next;
currentSize--;
}
this._head = current;
this._size = currentSize;
if (current) {
current.previous = void 0;
}
this._state++;
}
addItemFirst(item) {
if (!this._head && !this._tail) {
this._tail = item;
} else if (!this._head) {
throw new Error("Invalid list");
} else {
item.next = this._head;
this._head.previous = item;
}
this._head = item;
this._state++;
}
addItemLast(item) {
if (!this._head && !this._tail) {
this._head = item;
} else if (!this._tail) {
throw new Error("Invalid list");
} else {
item.previous = this._tail;
this._tail.next = item;
}
this._tail = item;
this._state++;
}
removeItem(item) {
if (item === this._head && item === this._tail) {
this._head = void 0;
this._tail = void 0;
} else if (item === this._head) {
if (!item.next) {
throw new Error("Invalid list");
}
item.next.previous = void 0;
this._head = item.next;
} else if (item === this._tail) {
if (!item.previous) {
throw new Error("Invalid list");
}
item.previous.next = void 0;
this._tail = item.previous;
} else {
const next = item.next;
const previous = item.previous;
if (!next || !previous) {
throw new Error("Invalid list");
}
next.previous = previous;
previous.next = next;
}
item.next = void 0;
item.previous = void 0;
this._state++;
}
touch(item, touch) {
if (!this._head || !this._tail) {
throw new Error("Invalid list");
}
if (touch !== Touch.First && touch !== Touch.Last) {
return;
}
if (touch === Touch.First) {
if (item === this._head) {
return;
}
const next = item.next;
const previous = item.previous;
if (item === this._tail) {
previous.next = void 0;
this._tail = previous;
} else {
next.previous = previous;
previous.next = next;
}
item.previous = void 0;
item.next = this._head;
this._head.previous = item;
this._head = item;
this._state++;
} else if (touch === Touch.Last) {
if (item === this._tail) {
return;
}
const next = item.next;
const previous = item.previous;
if (item === this._head) {
next.previous = void 0;
this._head = next;
} else {
next.previous = previous;
previous.next = next;
}
item.next = void 0;
item.previous = this._tail;
this._tail.next = item;
this._tail = item;
this._state++;
}
}
toJSON() {
const data = [];
this.forEach((value, key) => {
data.push([key, value]);
});
return data;
}
fromJSON(data) {
this.clear();
for (const [key, value] of data) {
this.set(key, value);
}
}
};
exports2.LinkedMap = LinkedMap;
var LRUCache = class extends LinkedMap {
constructor(limit, ratio = 1) {
super();
this._limit = limit;
this._ratio = Math.min(Math.max(0, ratio), 1);
}
get limit() {
return this._limit;
}
set limit(limit) {
this._limit = limit;
this.checkTrim();
}
get ratio() {
return this._ratio;
}
set ratio(ratio) {
this._ratio = Math.min(Math.max(0, ratio), 1);
this.checkTrim();
}
get(key, touch = Touch.AsNew) {
return super.get(key, touch);
}
peek(key) {
return super.get(key, Touch.None);
}
set(key, value) {
super.set(key, value, Touch.Last);
this.checkTrim();
return this;
}
checkTrim() {
if (this.size > this._limit) {
this.trimOld(Math.round(this._limit * this._ratio));
}
}
};
exports2.LRUCache = LRUCache;
}
});
// node_modules/vscode-jsonrpc/lib/common/disposable.js
var require_disposable = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/disposable.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.Disposable = void 0;
var Disposable3;
(function(Disposable4) {
function create(func) {
return {
dispose: func
};
}
Disposable4.create = create;
})(Disposable3 || (exports2.Disposable = Disposable3 = {}));
}
});
// node_modules/vscode-jsonrpc/lib/common/ral.js
var require_ral = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/ral.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var _ral;
function RAL() {
if (_ral === void 0) {
throw new Error(`No runtime abstraction layer installed`);
}
return _ral;
}
(function(RAL2) {
function install(ral) {
if (ral === void 0) {
throw new Error(`No runtime abstraction layer provided`);
}
_ral = ral;
}
RAL2.install = install;
})(RAL || (RAL = {}));
exports2.default = RAL;
}
});
// node_modules/vscode-jsonrpc/lib/common/events.js
var require_events = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/events.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.Emitter = exports2.Event = void 0;
var ral_1 = require_ral();
var Event2;
(function(Event3) {
const _disposable = { dispose() {
} };
Event3.None = function() {
return _disposable;
};
})(Event2 || (exports2.Event = Event2 = {}));
var CallbackList = class {
add(callback, context = null, bucket) {
if (!this._callbacks) {
this._callbacks = [];
this._contexts = [];
}
this._callbacks.push(callback);
this._contexts.push(context);
if (Array.isArray(bucket)) {
bucket.push({ dispose: () => this.remove(callback, context) });
}
}
remove(callback, context = null) {
if (!this._callbacks) {
return;
}
let foundCallbackWithDifferentContext = false;
for (let i = 0, len = this._callbacks.length; i < len; i++) {
if (this._callbacks[i] === callback) {
if (this._contexts[i] === context) {
this._callbacks.splice(i, 1);
this._contexts.splice(i, 1);
return;
} else {
foundCallbackWithDifferentContext = true;
}
}
}
if (foundCallbackWithDifferentContext) {
throw new Error("When adding a listener with a context, you should remove it with the same context");
}
}
invoke(...args) {
if (!this._callbacks) {
return [];
}
const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
for (let i = 0, len = callbacks.length; i < len; i++) {
try {
ret.push(callbacks[i].apply(contexts[i], args));
} catch (e) {
(0, ral_1.default)().console.error(e);
}
}
return ret;
}
isEmpty() {
return !this._callbacks || this._callbacks.length === 0;
}
dispose() {
this._callbacks = void 0;
this._contexts = void 0;
}
};
var Emitter = class _Emitter {
constructor(_options) {
this._options = _options;
}
/**
* For the public to allow to subscribe
* to events from this Emitter
*/
get event() {
if (!this._event) {
this._event = (listener, thisArgs, disposables) => {
if (!this._callbacks) {
this._callbacks = new CallbackList();
}
if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
this._options.onFirstListenerAdd(this);
}
this._callbacks.add(listener, thisArgs);
const result = {
dispose: () => {
if (!this._callbacks) {
return;
}
this._callbacks.remove(listener, thisArgs);
result.dispose = _Emitter._noop;
if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
this._options.onLastListenerRemove(this);
}
}
};
if (Array.isArray(disposables)) {
disposables.push(result);
}
return result;
};
}
return this._event;
}
/**
* To be kept private to fire an event to
* subscribers
*/
fire(event) {
if (this._callbacks) {
this._callbacks.invoke.call(this._callbacks, event);
}
}
dispose() {
if (this._callbacks) {
this._callbacks.dispose();
this._callbacks = void 0;
}
}
};
exports2.Emitter = Emitter;
Emitter._noop = function() {
};
}
});
// node_modules/vscode-jsonrpc/lib/common/cancellation.js
var require_cancellation = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/cancellation.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CancellationTokenSource = exports2.CancellationToken = void 0;
var ral_1 = require_ral();
var Is = require_is2();
var events_1 = require_events();
var CancellationToken;
(function(CancellationToken2) {
CancellationToken2.None = Object.freeze({
isCancellationRequested: false,
onCancellationRequested: events_1.Event.None
});
CancellationToken2.Cancelled = Object.freeze({
isCancellationRequested: true,
onCancellationRequested: events_1.Event.None
});
function is(value) {
const candidate = value;
return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
}
CancellationToken2.is = is;
})(CancellationToken || (exports2.CancellationToken = CancellationToken = {}));
var shortcutEvent = Object.freeze(function(callback, context) {
const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
return { dispose() {
handle.dispose();
} };
});
var MutableToken = class {
constructor() {
this._isCancelled = false;
}
cancel() {
if (!this._isCancelled) {
this._isCancelled = true;
if (this._emitter) {
this._emitter.fire(void 0);
this.dispose();
}
}
}
get isCancellationRequested() {
return this._isCancelled;
}
get onCancellationRequested() {
if (this._isCancelled) {
return shortcutEvent;
}
if (!this._emitter) {
this._emitter = new events_1.Emitter();
}
return this._emitter.event;
}
dispose() {
if (this._emitter) {
this._emitter.dispose();
this._emitter = void 0;
}
}
};
var CancellationTokenSource2 = class {
get token() {
if (!this._token) {
this._token = new MutableToken();
}
return this._token;
}
cancel() {
if (!this._token) {
this._token = CancellationToken.Cancelled;
} else {
this._token.cancel();
}
}
dispose() {
if (!this._token) {
this._token = CancellationToken.None;
} else if (this._token instanceof MutableToken) {
this._token.dispose();
}
}
};
exports2.CancellationTokenSource = CancellationTokenSource2;
}
});
// node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
var require_sharedArrayCancellation = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SharedArrayReceiverStrategy = exports2.SharedArraySenderStrategy = void 0;
var cancellation_1 = require_cancellation();
var CancellationState;
(function(CancellationState2) {
CancellationState2.Continue = 0;
CancellationState2.Cancelled = 1;
})(CancellationState || (CancellationState = {}));
var SharedArraySenderStrategy = class {
constructor() {
this.buffers = /* @__PURE__ */ new Map();
}
enableCancellation(request) {
if (request.id === null) {
return;
}
const buffer = new SharedArrayBuffer(4);
const data = new Int32Array(buffer, 0, 1);
data[0] = CancellationState.Continue;
this.buffers.set(request.id, buffer);
request.$cancellationData = buffer;
}
async sendCancellation(_conn, id) {
const buffer = this.buffers.get(id);
if (buffer === void 0) {
return;
}
const data = new Int32Array(buffer, 0, 1);
Atomics.store(data, 0, CancellationState.Cancelled);
}
cleanup(id) {
this.buffers.delete(id);
}
dispose() {
this.buffers.clear();
}
};
exports2.SharedArraySenderStrategy = SharedArraySenderStrategy;
var SharedArrayBufferCancellationToken = class {
constructor(buffer) {
this.data = new Int32Array(buffer, 0, 1);
}
get isCancellationRequested() {
return Atomics.load(this.data, 0) === CancellationState.Cancelled;
}
get onCancellationRequested() {
throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
}
};
var SharedArrayBufferCancellationTokenSource = class {
constructor(buffer) {
this.token = new SharedArrayBufferCancellationToken(buffer);
}
cancel() {
}
dispose() {
}
};
var SharedArrayReceiverStrategy = class {
constructor() {
this.kind = "request";
}
createCancellationTokenSource(request) {
const buffer = request.$cancellationData;
if (buffer === void 0) {
return new cancellation_1.CancellationTokenSource();
}
return new SharedArrayBufferCancellationTokenSource(buffer);
}
};
exports2.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
}
});
// node_modules/vscode-jsonrpc/lib/common/semaphore.js
var require_semaphore = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/semaphore.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.Semaphore = void 0;
var ral_1 = require_ral();
var Semaphore = class {
constructor(capacity = 1) {
if (capacity <= 0) {
throw new Error("Capacity must be greater than 0");
}
this._capacity = capacity;
this._active = 0;
this._waiting = [];
}
lock(thunk) {
return new Promise((resolve3, reject) => {
this._waiting.push({ thunk, resolve: resolve3, reject });
this.runNext();
});
}
get active() {
return this._active;
}
runNext() {
if (this._waiting.length === 0 || this._active === this._capacity) {
return;
}
(0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
}
doRunNext() {
if (this._waiting.length === 0 || this._active === this._capacity) {
return;
}
const next = this._waiting.shift();
this._active++;
if (this._active > this._capacity) {
throw new Error(`To many thunks active`);
}
try {
const result = next.thunk();
if (result instanceof Promise) {
result.then((value) => {
this._active--;
next.resolve(value);
this.runNext();
}, (err) => {
this._active--;
next.reject(err);
this.runNext();
});
} else {
this._active--;
next.resolve(result);
this.runNext();
}
} catch (err) {
this._active--;
next.reject(err);
this.runNext();
}
}
};
exports2.Semaphore = Semaphore;
}
});
// node_modules/vscode-jsonrpc/lib/common/messageReader.js
var require_messageReader = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/messageReader.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = void 0;
var ral_1 = require_ral();
var Is = require_is2();
var events_1 = require_events();
var semaphore_1 = require_semaphore();
var MessageReader;
(function(MessageReader2) {
function is(value) {
let candidate = value;
return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) && Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
}
MessageReader2.is = is;
})(MessageReader || (exports2.MessageReader = MessageReader = {}));
var AbstractMessageReader = class {
constructor() {
this.errorEmitter = new events_1.Emitter();
this.closeEmitter = new events_1.Emitter();
this.partialMessageEmitter = new events_1.Emitter();
}
dispose() {
this.errorEmitter.dispose();
this.closeEmitter.dispose();
}
get onError() {
return this.errorEmitter.event;
}
fireError(error) {
this.errorEmitter.fire(this.asError(error));
}
get onClose() {
return this.closeEmitter.event;
}
fireClose() {
this.closeEmitter.fire(void 0);
}
get onPartialMessage() {
return this.partialMessageEmitter.event;
}
firePartialMessage(info) {
this.partialMessageEmitter.fire(info);
}
asError(error) {
if (error instanceof Error) {
return error;
} else {
return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
}
}
};
exports2.AbstractMessageReader = AbstractMessageReader;
var ResolvedMessageReaderOptions;
(function(ResolvedMessageReaderOptions2) {
function fromOptions(options) {
let charset;
let result;
let contentDecoder;
const contentDecoders = /* @__PURE__ */ new Map();
let contentTypeDecoder;
const contentTypeDecoders = /* @__PURE__ */ new Map();
if (options === void 0 || typeof options === "string") {
charset = options ?? "utf-8";
} else {
charset = options.charset ?? "utf-8";
if (options.contentDecoder !== void 0) {
contentDecoder = options.contentDecoder;
contentDecoders.set(contentDecoder.name, contentDecoder);
}
if (options.contentDecoders !== void 0) {
for (const decoder of options.contentDecoders) {
contentDecoders.set(decoder.name, decoder);
}
}
if (options.contentTypeDecoder !== void 0) {
contentTypeDecoder = options.contentTypeDecoder;
contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
}
if (options.contentTypeDecoders !== void 0) {
for (const decoder of options.contentTypeDecoders) {
contentTypeDecoders.set(decoder.name, decoder);
}
}
}
if (contentTypeDecoder === void 0) {
contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
}
return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
}
ResolvedMessageReaderOptions2.fromOptions = fromOptions;
})(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
var ReadableStreamMessageReader = class extends AbstractMessageReader {
constructor(readable, options) {
super();
this.readable = readable;
this.options = ResolvedMessageReaderOptions.fromOptions(options);
this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
this._partialMessageTimeout = 1e4;
this.nextMessageLength = -1;
this.messageToken = 0;
this.readSemaphore = new semaphore_1.Semaphore(1);
}
set partialMessageTimeout(timeout) {
this._partialMessageTimeout = timeout;
}
get partialMessageTimeout() {
return this._partialMessageTimeout;
}
listen(callback) {
this.nextMessageLength = -1;
this.messageToken = 0;
this.partialMessageTimer = void 0;
this.callback = callback;
const result = this.readable.onData((data) => {
this.onData(data);
});
this.readable.onError((error) => this.fireError(error));
this.readable.onClose(() => this.fireClose());
return result;
}
onData(data) {
try {
this.buffer.append(data);
while (true) {
if (this.nextMessageLength === -1) {
const headers = this.buffer.tryReadHeaders(true);
if (!headers) {
return;
}
const contentLength = headers.get("content-length");
if (!contentLength) {
this.fireError(new Error(`Header must provide a Content-Length property.
${JSON.stringify(Object.fromEntries(headers))}`));
return;
}
const length = parseInt(contentLength);
if (isNaN(length)) {
this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
return;
}
this.nextMessageLength = length;
}
const body = this.buffer.tryReadBody(this.nextMessageLength);
if (body === void 0) {
this.setPartialMessageTimer();
return;
}
this.clearPartialMessageTimer();
this.nextMessageLength = -1;
this.readSemaphore.lock(async () => {
const bytes = this.options.contentDecoder !== void 0 ? await this.options.contentDecoder.decode(body) : body;
const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
this.callback(message);
}).catch((error) => {
this.fireError(error);
});
}
} catch (error) {
this.fireError(error);
}
}
clearPartialMessageTimer() {
if (this.partialMessageTimer) {
this.partialMessageTimer.dispose();
this.partialMessageTimer = void 0;
}
}
setPartialMessageTimer() {
this.clearPartialMessageTimer();
if (this._partialMessageTimeout <= 0) {
return;
}
this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
this.partialMessageTimer = void 0;
if (token === this.messageToken) {
this.firePartialMessage({ messageToken: token, waitingTime: timeout });
this.setPartialMessageTimer();
}
}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
}
};
exports2.ReadableStreamMessageReader = ReadableStreamMessageReader;
}
});
// node_modules/vscode-jsonrpc/lib/common/messageWriter.js
var require_messageWriter = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/messageWriter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = void 0;
var ral_1 = require_ral();
var Is = require_is2();
var semaphore_1 = require_semaphore();
var events_1 = require_events();
var ContentLength = "Content-Length: ";
var CRLF = "\r\n";
var MessageWriter;
(function(MessageWriter2) {
function is(value) {
let candidate = value;
return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write);
}
MessageWriter2.is = is;
})(MessageWriter || (exports2.MessageWriter = MessageWriter = {}));
var AbstractMessageWriter = class {
constructor() {
this.errorEmitter = new events_1.Emitter();
this.closeEmitter = new events_1.Emitter();
}
dispose() {
this.errorEmitter.dispose();
this.closeEmitter.dispose();
}
get onError() {
return this.errorEmitter.event;
}
fireError(error, message, count) {
this.errorEmitter.fire([this.asError(error), message, count]);
}
get onClose() {
return this.closeEmitter.event;
}
fireClose() {
this.closeEmitter.fire(void 0);
}
asError(error) {
if (error instanceof Error) {
return error;
} else {
return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
}
}
};
exports2.AbstractMessageWriter = AbstractMessageWriter;
var ResolvedMessageWriterOptions;
(function(ResolvedMessageWriterOptions2) {
function fromOptions(options) {
if (options === void 0 || typeof options === "string") {
return { charset: options ?? "utf-8", contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
} else {
return { charset: options.charset ?? "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
}
}
ResolvedMessageWriterOptions2.fromOptions = fromOptions;
})(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
constructor(writable, options) {
super();
this.writable = writable;
this.options = ResolvedMessageWriterOptions.fromOptions(options);
this.errorCount = 0;
this.writeSemaphore = new semaphore_1.Semaphore(1);
this.writable.onError((error) => this.fireError(error));
this.writable.onClose(() => this.fireClose());
}
async write(msg) {
return this.writeSemaphore.lock(async () => {
const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
if (this.options.contentEncoder !== void 0) {
return this.options.contentEncoder.encode(buffer);
} else {
return buffer;
}
});
return payload.then((buffer) => {
const headers = [];
headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
headers.push(CRLF);
return this.doWrite(msg, headers, buffer);
}, (error) => {
this.fireError(error);
throw error;
});
});
}
async doWrite(msg, headers, data) {
try {
await this.writable.write(headers.join(""), "ascii");
return this.writable.write(data);
} catch (error) {
this.handleError(error, msg);
return Promise.reject(error);
}
}
handleError(error, msg) {
this.errorCount++;
this.fireError(error, msg, this.errorCount);
}
end() {
this.writable.end();
}
};
exports2.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
}
});
// node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
var require_messageBuffer = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/messageBuffer.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.AbstractMessageBuffer = void 0;
var CR = 13;
var LF = 10;
var CRLF = "\r\n";
var AbstractMessageBuffer = class {
constructor(encoding = "utf-8") {
this._encoding = encoding;
this._chunks = [];
this._totalLength = 0;
}
get encoding() {
return this._encoding;
}
append(chunk) {
const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
this._chunks.push(toAppend);
this._totalLength += toAppend.byteLength;
}
tryReadHeaders(lowerCaseKeys = false) {
if (this._chunks.length === 0) {
return void 0;
}
let state = 0;
let chunkIndex = 0;
let offset = 0;
let chunkBytesRead = 0;
row: while (chunkIndex < this._chunks.length) {
const chunk = this._chunks[chunkIndex];
offset = 0;
column: while (offset < chunk.length) {
const value = chunk[offset];
switch (value) {
case CR:
switch (state) {
case 0:
state = 1;
break;
case 2:
state = 3;
break;
default:
state = 0;
}
break;
case LF:
switch (state) {
case 1:
state = 2;
break;
case 3:
state = 4;
offset++;
break row;
default:
state = 0;
}
break;
default:
state = 0;
}
offset++;
}
chunkBytesRead += chunk.byteLength;
chunkIndex++;
}
if (state !== 4) {
return void 0;
}
const buffer = this._read(chunkBytesRead + offset);
const result = /* @__PURE__ */ new Map();
const headers = this.toString(buffer, "ascii").split(CRLF);
if (headers.length < 2) {
return result;
}
for (let i = 0; i < headers.length - 2; i++) {
const header = headers[i];
const index = header.indexOf(":");
if (index === -1) {
throw new Error(`Message header must separate key and value using ':'
${header}`);
}
const key = header.substr(0, index);
const value = header.substr(index + 1).trim();
result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
}
return result;
}
tryReadBody(length) {
if (this._totalLength < length) {
return void 0;
}
return this._read(length);
}
get numberOfBytes() {
return this._totalLength;
}
_read(byteCount) {
if (byteCount === 0) {
return this.emptyBuffer();
}
if (byteCount > this._totalLength) {
throw new Error(`Cannot read so many bytes!`);
}
if (this._chunks[0].byteLength === byteCount) {
const chunk = this._chunks[0];
this._chunks.shift();
this._totalLength -= byteCount;
return this.asNative(chunk);
}
if (this._chunks[0].byteLength > byteCount) {
const chunk = this._chunks[0];
const result2 = this.asNative(chunk, byteCount);
this._chunks[0] = chunk.slice(byteCount);
this._totalLength -= byteCount;
return result2;
}
const result = this.allocNative(byteCount);
let resultOffset = 0;
let chunkIndex = 0;
while (byteCount > 0) {
const chunk = this._chunks[chunkIndex];
if (chunk.byteLength > byteCount) {
const chunkPart = chunk.slice(0, byteCount);
result.set(chunkPart, resultOffset);
resultOffset += byteCount;
this._chunks[chunkIndex] = chunk.slice(byteCount);
this._totalLength -= byteCount;
byteCount -= byteCount;
} else {
result.set(chunk, resultOffset);
resultOffset += chunk.byteLength;
this._chunks.shift();
this._totalLength -= chunk.byteLength;
byteCount -= chunk.byteLength;
}
}
return result;
}
};
exports2.AbstractMessageBuffer = AbstractMessageBuffer;
}
});
// node_modules/vscode-jsonrpc/lib/common/connection.js
var require_connection = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/connection.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createMessageConnection = exports2.ConnectionOptions = exports2.MessageStrategy = exports2.CancellationStrategy = exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.RequestCancellationReceiverStrategy = exports2.IdCancellationReceiverStrategy = exports2.ConnectionStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.TraceValues = exports2.Trace = exports2.NullLogger = exports2.ProgressType = exports2.ProgressToken = void 0;
var ral_1 = require_ral();
var Is = require_is2();
var messages_1 = require_messages();
var linkedMap_1 = require_linkedMap();
var events_1 = require_events();
var cancellation_1 = require_cancellation();
var CancelNotification;
(function(CancelNotification2) {
CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
})(CancelNotification || (CancelNotification = {}));
var ProgressToken;
(function(ProgressToken2) {
function is(value) {
return typeof value === "string" || typeof value === "number";
}
ProgressToken2.is = is;
})(ProgressToken || (exports2.ProgressToken = ProgressToken = {}));
var ProgressNotification;
(function(ProgressNotification2) {
ProgressNotification2.type = new messages_1.NotificationType("$/progress");
})(ProgressNotification || (ProgressNotification = {}));
var ProgressType = class {
constructor() {
}
};
exports2.ProgressType = ProgressType;
var StarRequestHandler;
(function(StarRequestHandler2) {
function is(value) {
return Is.func(value);
}
StarRequestHandler2.is = is;
})(StarRequestHandler || (StarRequestHandler = {}));
exports2.NullLogger = Object.freeze({
error: () => {
},
warn: () => {
},
info: () => {
},
log: () => {
}
});
var Trace;
(function(Trace2) {
Trace2[Trace2["Off"] = 0] = "Off";
Trace2[Trace2["Messages"] = 1] = "Messages";
Trace2[Trace2["Compact"] = 2] = "Compact";
Trace2[Trace2["Verbose"] = 3] = "Verbose";
})(Trace || (exports2.Trace = Trace = {}));
var TraceValues;
(function(TraceValues2) {
TraceValues2.Off = "off";
TraceValues2.Messages = "messages";
TraceValues2.Compact = "compact";
TraceValues2.Verbose = "verbose";
})(TraceValues || (exports2.TraceValues = TraceValues = {}));
(function(Trace2) {
function fromString(value) {
if (!Is.string(value)) {
return Trace2.Off;
}
value = value.toLowerCase();
switch (value) {
case "off":
return Trace2.Off;
case "messages":
return Trace2.Messages;
case "compact":
return Trace2.Compact;
case "verbose":
return Trace2.Verbose;
default:
return Trace2.Off;
}
}
Trace2.fromString = fromString;
function toString(value) {
switch (value) {
case Trace2.Off:
return "off";
case Trace2.Messages:
return "messages";
case Trace2.Compact:
return "compact";
case Trace2.Verbose:
return "verbose";
default:
return "off";
}
}
Trace2.toString = toString;
})(Trace || (exports2.Trace = Trace = {}));
var TraceFormat;
(function(TraceFormat2) {
TraceFormat2["Text"] = "text";
TraceFormat2["JSON"] = "json";
})(TraceFormat || (exports2.TraceFormat = TraceFormat = {}));
(function(TraceFormat2) {
function fromString(value) {
if (!Is.string(value)) {
return TraceFormat2.Text;
}
value = value.toLowerCase();
if (value === "json") {
return TraceFormat2.JSON;
} else {
return TraceFormat2.Text;
}
}
TraceFormat2.fromString = fromString;
})(TraceFormat || (exports2.TraceFormat = TraceFormat = {}));
var SetTraceNotification;
(function(SetTraceNotification2) {
SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
})(SetTraceNotification || (exports2.SetTraceNotification = SetTraceNotification = {}));
var LogTraceNotification;
(function(LogTraceNotification2) {
LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
})(LogTraceNotification || (exports2.LogTraceNotification = LogTraceNotification = {}));
var ConnectionErrors;
(function(ConnectionErrors2) {
ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
})(ConnectionErrors || (exports2.ConnectionErrors = ConnectionErrors = {}));
var ConnectionError = class _ConnectionError extends Error {
constructor(code, message) {
super(message);
this.code = code;
Object.setPrototypeOf(this, _ConnectionError.prototype);
}
};
exports2.ConnectionError = ConnectionError;
var ConnectionStrategy;
(function(ConnectionStrategy2) {
function is(value) {
const candidate = value;
return candidate && Is.func(candidate.cancelUndispatched);
}
ConnectionStrategy2.is = is;
})(ConnectionStrategy || (exports2.ConnectionStrategy = ConnectionStrategy = {}));
var IdCancellationReceiverStrategy;
(function(IdCancellationReceiverStrategy2) {
function is(value) {
const candidate = value;
return candidate && (candidate.kind === void 0 || candidate.kind === "id") && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is.func(candidate.dispose));
}
IdCancellationReceiverStrategy2.is = is;
})(IdCancellationReceiverStrategy || (exports2.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
var RequestCancellationReceiverStrategy;
(function(RequestCancellationReceiverStrategy2) {
function is(value) {
const candidate = value;
return candidate && candidate.kind === "request" && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is.func(candidate.dispose));
}
RequestCancellationReceiverStrategy2.is = is;
})(RequestCancellationReceiverStrategy || (exports2.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
var CancellationReceiverStrategy;
(function(CancellationReceiverStrategy2) {
CancellationReceiverStrategy2.Message = Object.freeze({
createCancellationTokenSource(_) {
return new cancellation_1.CancellationTokenSource();
}
});
function is(value) {
return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
}
CancellationReceiverStrategy2.is = is;
})(CancellationReceiverStrategy || (exports2.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
var CancellationSenderStrategy;
(function(CancellationSenderStrategy2) {
CancellationSenderStrategy2.Message = Object.freeze({
sendCancellation(conn, id) {
return conn.sendNotification(CancelNotification.type, { id });
},
cleanup(_) {
}
});
function is(value) {
const candidate = value;
return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
}
CancellationSenderStrategy2.is = is;
})(CancellationSenderStrategy || (exports2.CancellationSenderStrategy = CancellationSenderStrategy = {}));
var CancellationStrategy;
(function(CancellationStrategy2) {
CancellationStrategy2.Message = Object.freeze({
receiver: CancellationReceiverStrategy.Message,
sender: CancellationSenderStrategy.Message
});
function is(value) {
const candidate = value;
return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
}
CancellationStrategy2.is = is;
})(CancellationStrategy || (exports2.CancellationStrategy = CancellationStrategy = {}));
var MessageStrategy;
(function(MessageStrategy2) {
function is(value) {
const candidate = value;
return candidate && Is.func(candidate.handleMessage);
}
MessageStrategy2.is = is;
})(MessageStrategy || (exports2.MessageStrategy = MessageStrategy = {}));
var ConnectionOptions;
(function(ConnectionOptions2) {
function is(value) {
const candidate = value;
return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
}
ConnectionOptions2.is = is;
})(ConnectionOptions || (exports2.ConnectionOptions = ConnectionOptions = {}));
var ConnectionState;
(function(ConnectionState2) {
ConnectionState2[ConnectionState2["New"] = 1] = "New";
ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
})(ConnectionState || (ConnectionState = {}));
function createMessageConnection(messageReader, messageWriter, _logger, options) {
const logger2 = _logger !== void 0 ? _logger : exports2.NullLogger;
let sequenceNumber = 0;
let notificationSequenceNumber = 0;
let unknownResponseSequenceNumber = 0;
const version = "2.0";
let starRequestHandler = void 0;
const requestHandlers = /* @__PURE__ */ new Map();
let starNotificationHandler = void 0;
const notificationHandlers = /* @__PURE__ */ new Map();
const progressHandlers = /* @__PURE__ */ new Map();
let timer;
let messageQueue = new linkedMap_1.LinkedMap();
let responsePromises = /* @__PURE__ */ new Map();
let knownCanceledRequests = /* @__PURE__ */ new Set();
let requestTokens = /* @__PURE__ */ new Map();
let trace = Trace.Off;
let traceFormat = TraceFormat.Text;
let tracer;
let state = ConnectionState.New;
const errorEmitter = new events_1.Emitter();
const closeEmitter = new events_1.Emitter();
const unhandledNotificationEmitter = new events_1.Emitter();
const unhandledProgressEmitter = new events_1.Emitter();
const disposeEmitter = new events_1.Emitter();
const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
function createRequestQueueKey(id) {
if (id === null) {
throw new Error(`Can't send requests with id null since the response can't be correlated.`);
}
return "req-" + id.toString();
}
function createResponseQueueKey(id) {
if (id === null) {
return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
} else {
return "res-" + id.toString();
}
}
function createNotificationQueueKey() {
return "not-" + (++notificationSequenceNumber).toString();
}
function addMessageToQueue(queue, message) {
if (messages_1.Message.isRequest(message)) {
queue.set(createRequestQueueKey(message.id), message);
} else if (messages_1.Message.isResponse(message)) {
queue.set(createResponseQueueKey(message.id), message);
} else {
queue.set(createNotificationQueueKey(), message);
}
}
function cancelUndispatched(_message) {
return void 0;
}
function isListening() {
return state === ConnectionState.Listening;
}
function isClosed() {
return state === ConnectionState.Closed;
}
function isDisposed() {
return state === ConnectionState.Disposed;
}
function closeHandler() {
if (state === ConnectionState.New || state === ConnectionState.Listening) {
state = ConnectionState.Closed;
closeEmitter.fire(void 0);
}
}
function readErrorHandler(error) {
errorEmitter.fire([error, void 0, void 0]);
}
function writeErrorHandler(data) {
errorEmitter.fire(data);
}
messageReader.onClose(closeHandler);
messageReader.onError(readErrorHandler);
messageWriter.onClose(closeHandler);
messageWriter.onError(writeErrorHandler);
function triggerMessageQueue() {
if (timer || messageQueue.size === 0) {
return;
}
timer = (0, ral_1.default)().timer.setImmediate(() => {
timer = void 0;
processMessageQueue();
});
}
function handleMessage(message) {
if (messages_1.Message.isRequest(message)) {
handleRequest(message);
} else if (messages_1.Message.isNotification(message)) {
handleNotification(message);
} else if (messages_1.Message.isResponse(message)) {
handleResponse(message);
} else {
handleInvalidMessage(message);
}
}
function processMessageQueue() {
if (messageQueue.size === 0) {
return;
}
const message = messageQueue.shift();
try {
const messageStrategy = options?.messageStrategy;
if (MessageStrategy.is(messageStrategy)) {
messageStrategy.handleMessage(message, handleMessage);
} else {
handleMessage(message);
}
} finally {
triggerMessageQueue();
}
}
const callback = (message) => {
try {
if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
const cancelId = message.params.id;
const key = createRequestQueueKey(cancelId);
const toCancel = messageQueue.get(key);
if (messages_1.Message.isRequest(toCancel)) {
const strategy = options?.connectionStrategy;
const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
if (response && (response.error !== void 0 || response.result !== void 0)) {
messageQueue.delete(key);
requestTokens.delete(cancelId);
response.id = toCancel.id;
traceSendingResponse(response, message.method, Date.now());
messageWriter.write(response).catch(() => logger2.error(`Sending response for canceled message failed.`));
return;
}
}
const cancellationToken = requestTokens.get(cancelId);
if (cancellationToken !== void 0) {
cancellationToken.cancel();
traceReceivedNotification(message);
return;
} else {
knownCanceledRequests.add(cancelId);
}
}
addMessageToQueue(messageQueue, message);
} finally {
triggerMessageQueue();
}
};
function handleRequest(requestMessage) {
if (isDisposed()) {
return;
}
function reply(resultOrError, method, startTime2) {
const message = {
jsonrpc: version,
id: requestMessage.id
};
if (resultOrError instanceof messages_1.ResponseError) {
message.error = resultOrError.toJson();
} else {
message.result = resultOrError === void 0 ? null : resultOrError;
}
traceSendingResponse(message, method, startTime2);
messageWriter.write(message).catch(() => logger2.error(`Sending response failed.`));
}
function replyError(error, method, startTime2) {
const message = {
jsonrpc: version,
id: requestMessage.id,
error: error.toJson()
};
traceSendingResponse(message, method, startTime2);
messageWriter.write(message).catch(() => logger2.error(`Sending response failed.`));
}
function replySuccess(result, method, startTime2) {
if (result === void 0) {
result = null;
}
const message = {
jsonrpc: version,
id: requestMessage.id,
result
};
traceSendingResponse(message, method, startTime2);
messageWriter.write(message).catch(() => logger2.error(`Sending response failed.`));
}
traceReceivedRequest(requestMessage);
const element = requestHandlers.get(requestMessage.method);
let type;
let requestHandler;
if (element) {
type = element.type;
requestHandler = element.handler;
}
const startTime = Date.now();
if (requestHandler || starRequestHandler) {
const tokenKey = requestMessage.id ?? String(Date.now());
const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
cancellationSource.cancel();
}
if (requestMessage.id !== null) {
requestTokens.set(tokenKey, cancellationSource);
}
try {
let handlerResult;
if (requestHandler) {
if (requestMessage.params === void 0) {
if (type !== void 0 && type.numberOfParams !== 0) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
return;
}
handlerResult = requestHandler(cancellationSource.token);
} else if (Array.isArray(requestMessage.params)) {
if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
return;
}
handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
} else {
if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
return;
}
handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
}
} else if (starRequestHandler) {
handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
}
const promise = handlerResult;
if (!handlerResult) {
requestTokens.delete(tokenKey);
replySuccess(handlerResult, requestMessage.method, startTime);
} else if (promise.then) {
promise.then((resultOrError) => {
requestTokens.delete(tokenKey);
reply(resultOrError, requestMessage.method, startTime);
}, (error) => {
requestTokens.delete(tokenKey);
if (error instanceof messages_1.ResponseError) {
replyError(error, requestMessage.method, startTime);
} else if (error && Is.string(error.message)) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
} else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
}
});
} else {
requestTokens.delete(tokenKey);
reply(handlerResult, requestMessage.method, startTime);
}
} catch (error) {
requestTokens.delete(tokenKey);
if (error instanceof messages_1.ResponseError) {
reply(error, requestMessage.method, startTime);
} else if (error && Is.string(error.message)) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
} else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
}
}
} else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
}
}
function handleResponse(responseMessage) {
if (isDisposed()) {
return;
}
if (responseMessage.id === null) {
if (responseMessage.error) {
logger2.error(`Received response message without id: Error is:
${JSON.stringify(responseMessage.error, void 0, 4)}`);
} else {
logger2.error(`Received response message without id. No further error information provided.`);
}
} else {
const key = responseMessage.id;
const responsePromise = responsePromises.get(key);
traceReceivedResponse(responseMessage, responsePromise);
if (responsePromise !== void 0) {
responsePromises.delete(key);
try {
if (responseMessage.error) {
const error = responseMessage.error;
responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
} else if (responseMessage.result !== void 0) {
responsePromise.resolve(responseMessage.result);
} else {
throw new Error("Should never happen.");
}
} catch (error) {
if (error.message) {
logger2.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
} else {
logger2.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
}
}
}
}
}
function handleNotification(message) {
if (isDisposed()) {
return;
}
let type = void 0;
let notificationHandler;
if (message.method === CancelNotification.type.method) {
const cancelId = message.params.id;
knownCanceledRequests.delete(cancelId);
traceReceivedNotification(message);
return;
} else {
const element = notificationHandlers.get(message.method);
if (element) {
notificationHandler = element.handler;
type = element.type;
}
}
if (notificationHandler || starNotificationHandler) {
try {
traceReceivedNotification(message);
if (notificationHandler) {
if (message.params === void 0) {
if (type !== void 0) {
if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
logger2.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
}
}
notificationHandler();
} else if (Array.isArray(message.params)) {
const params = message.params;
if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
notificationHandler({ token: params[0], value: params[1] });
} else {
if (type !== void 0) {
if (type.parameterStructures === messages_1.ParameterStructures.byName) {
logger2.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
}
if (type.numberOfParams !== message.params.length) {
logger2.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
}
}
notificationHandler(...params);
}
} else {
if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
logger2.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
}
notificationHandler(message.params);
}
} else if (starNotificationHandler) {
starNotificationHandler(message.method, message.params);
}
} catch (error) {
if (error.message) {
logger2.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
} else {
logger2.error(`Notification handler '${message.method}' failed unexpectedly.`);
}
}
} else {
unhandledNotificationEmitter.fire(message);
}
}
function handleInvalidMessage(message) {
if (!message) {
logger2.error("Received empty message.");
return;
}
logger2.error(`Received message which is neither a response nor a notification message:
${JSON.stringify(message, null, 4)}`);
const responseMessage = message;
if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
const key = responseMessage.id;
const responseHandler = responsePromises.get(key);
if (responseHandler) {
responseHandler.reject(new Error("The received response has neither a result nor an error property."));
}
}
}
function stringifyTrace(params) {
if (params === void 0 || params === null) {
return void 0;
}
switch (trace) {
case Trace.Verbose:
return JSON.stringify(params, null, 4);
case Trace.Compact:
return JSON.stringify(params);
default:
return void 0;
}
}
function traceSendingRequest(message) {
if (trace === Trace.Off || !tracer) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
data = `Params: ${stringifyTrace(message.params)}
`;
}
tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
} else {
logLSPMessage("send-request", message);
}
}
function traceSendingNotification(message) {
if (trace === Trace.Off || !tracer) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if (trace === Trace.Verbose || trace === Trace.Compact) {
if (message.params) {
data = `Params: ${stringifyTrace(message.params)}
`;
} else {
data = "No parameters provided.\n\n";
}
}
tracer.log(`Sending notification '${message.method}'.`, data);
} else {
logLSPMessage("send-notification", message);
}
}
function traceSendingResponse(message, method, startTime) {
if (trace === Trace.Off || !tracer) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if (trace === Trace.Verbose || trace === Trace.Compact) {
if (message.error && message.error.data) {
data = `Error data: ${stringifyTrace(message.error.data)}
`;
} else {
if (message.result) {
data = `Result: ${stringifyTrace(message.result)}
`;
} else if (message.error === void 0) {
data = "No result returned.\n\n";
}
}
}
tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
} else {
logLSPMessage("send-response", message);
}
}
function traceReceivedRequest(message) {
if (trace === Trace.Off || !tracer) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
data = `Params: ${stringifyTrace(message.params)}
`;
}
tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
} else {
logLSPMessage("receive-request", message);
}
}
function traceReceivedNotification(message) {
if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if (trace === Trace.Verbose || trace === Trace.Compact) {
if (message.params) {
data = `Params: ${stringifyTrace(message.params)}
`;
} else {
data = "No parameters provided.\n\n";
}
}
tracer.log(`Received notification '${message.method}'.`, data);
} else {
logLSPMessage("receive-notification", message);
}
}
function traceReceivedResponse(message, responsePromise) {
if (trace === Trace.Off || !tracer) {
return;
}
if (traceFormat === TraceFormat.Text) {
let data = void 0;
if (trace === Trace.Verbose || trace === Trace.Compact) {
if (message.error && message.error.data) {
data = `Error data: ${stringifyTrace(message.error.data)}
`;
} else {
if (message.result) {
data = `Result: ${stringifyTrace(message.result)}
`;
} else if (message.error === void 0) {
data = "No result returned.\n\n";
}
}
}
if (responsePromise) {
const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
} else {
tracer.log(`Received response ${message.id} without active response promise.`, data);
}
} else {
logLSPMessage("receive-response", message);
}
}
function logLSPMessage(type, message) {
if (!tracer || trace === Trace.Off) {
return;
}
const lspMessage = {
isLSPMessage: true,
type,
message,
timestamp: Date.now()
};
tracer.log(lspMessage);
}
function throwIfClosedOrDisposed() {
if (isClosed()) {
throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
}
if (isDisposed()) {
throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
}
}
function throwIfListening() {
if (isListening()) {
throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
}
}
function throwIfNotListening() {
if (!isListening()) {
throw new Error("Call listen() first.");
}
}
function undefinedToNull(param) {
if (param === void 0) {
return null;
} else {
return param;
}
}
function nullToUndefined(param) {
if (param === null) {
return void 0;
} else {
return param;
}
}
function isNamedParam(param) {
return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
}
function computeSingleParam(parameterStructures, param) {
switch (parameterStructures) {
case messages_1.ParameterStructures.auto:
if (isNamedParam(param)) {
return nullToUndefined(param);
} else {
return [undefinedToNull(param)];
}
case messages_1.ParameterStructures.byName:
if (!isNamedParam(param)) {
throw new Error(`Received parameters by name but param is not an object literal.`);
}
return nullToUndefined(param);
case messages_1.ParameterStructures.byPosition:
return [undefinedToNull(param)];
default:
throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
}
}
function computeMessageParams(type, params) {
let result;
const numberOfParams = type.numberOfParams;
switch (numberOfParams) {
case 0:
result = void 0;
break;
case 1:
result = computeSingleParam(type.parameterStructures, params[0]);
break;
default:
result = [];
for (let i = 0; i < params.length && i < numberOfParams; i++) {
result.push(undefinedToNull(params[i]));
}
if (params.length < numberOfParams) {
for (let i = params.length; i < numberOfParams; i++) {
result.push(null);
}
}
break;
}
return result;
}
const connection = {
sendNotification: (type, ...args) => {
throwIfClosedOrDisposed();
let method;
let messageParams;
if (Is.string(type)) {
method = type;
const first = args[0];
let paramStart = 0;
let parameterStructures = messages_1.ParameterStructures.auto;
if (messages_1.ParameterStructures.is(first)) {
paramStart = 1;
parameterStructures = first;
}
let paramEnd = args.length;
const numberOfParams = paramEnd - paramStart;
switch (numberOfParams) {
case 0:
messageParams = void 0;
break;
case 1:
messageParams = computeSingleParam(parameterStructures, args[paramStart]);
break;
default:
if (parameterStructures === messages_1.ParameterStructures.byName) {
throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
}
messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
break;
}
} else {
const params = args;
method = type.method;
messageParams = computeMessageParams(type, params);
}
const notificationMessage = {
jsonrpc: version,
method,
params: messageParams
};
traceSendingNotification(notificationMessage);
return messageWriter.write(notificationMessage).catch((error) => {
logger2.error(`Sending notification failed.`);
throw error;
});
},
onNotification: (type, handler) => {
throwIfClosedOrDisposed();
let method;
if (Is.func(type)) {
starNotificationHandler = type;
} else if (handler) {
if (Is.string(type)) {
method = type;
notificationHandlers.set(type, { type: void 0, handler });
} else {
method = type.method;
notificationHandlers.set(type.method, { type, handler });
}
}
return {
dispose: () => {
if (method !== void 0) {
notificationHandlers.delete(method);
} else {
starNotificationHandler = void 0;
}
}
};
},
onProgress: (_type, token, handler) => {
if (progressHandlers.has(token)) {
throw new Error(`Progress handler for token ${token} already registered`);
}
progressHandlers.set(token, handler);
return {
dispose: () => {
progressHandlers.delete(token);
}
};
},
sendProgress: (_type, token, value) => {
return connection.sendNotification(ProgressNotification.type, { token, value });
},
onUnhandledProgress: unhandledProgressEmitter.event,
sendRequest: (type, ...args) => {
throwIfClosedOrDisposed();
throwIfNotListening();
let method;
let messageParams;
let token = void 0;
if (Is.string(type)) {
method = type;
const first = args[0];
const last = args[args.length - 1];
let paramStart = 0;
let parameterStructures = messages_1.ParameterStructures.auto;
if (messages_1.ParameterStructures.is(first)) {
paramStart = 1;
parameterStructures = first;
}
let paramEnd = args.length;
if (cancellation_1.CancellationToken.is(last)) {
paramEnd = paramEnd - 1;
token = last;
}
const numberOfParams = paramEnd - paramStart;
switch (numberOfParams) {
case 0:
messageParams = void 0;
break;
case 1:
messageParams = computeSingleParam(parameterStructures, args[paramStart]);
break;
default:
if (parameterStructures === messages_1.ParameterStructures.byName) {
throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
}
messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
break;
}
} else {
const params = args;
method = type.method;
messageParams = computeMessageParams(type, params);
const numberOfParams = type.numberOfParams;
token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
}
const id = sequenceNumber++;
let disposable;
if (token) {
disposable = token.onCancellationRequested(() => {
const p = cancellationStrategy.sender.sendCancellation(connection, id);
if (p === void 0) {
logger2.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
return Promise.resolve();
} else {
return p.catch(() => {
logger2.log(`Sending cancellation messages for id ${id} failed`);
});
}
});
}
const requestMessage = {
jsonrpc: version,
id,
method,
params: messageParams
};
traceSendingRequest(requestMessage);
if (typeof cancellationStrategy.sender.enableCancellation === "function") {
cancellationStrategy.sender.enableCancellation(requestMessage);
}
return new Promise(async (resolve3, reject) => {
const resolveWithCleanup = (r) => {
resolve3(r);
cancellationStrategy.sender.cleanup(id);
disposable?.dispose();
};
const rejectWithCleanup = (r) => {
reject(r);
cancellationStrategy.sender.cleanup(id);
disposable?.dispose();
};
const responsePromise = { method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
try {
await messageWriter.write(requestMessage);
responsePromises.set(id, responsePromise);
} catch (error) {
logger2.error(`Sending request failed.`);
responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
throw error;
}
});
},
onRequest: (type, handler) => {
throwIfClosedOrDisposed();
let method = null;
if (StarRequestHandler.is(type)) {
method = void 0;
starRequestHandler = type;
} else if (Is.string(type)) {
method = null;
if (handler !== void 0) {
method = type;
requestHandlers.set(type, { handler, type: void 0 });
}
} else {
if (handler !== void 0) {
method = type.method;
requestHandlers.set(type.method, { type, handler });
}
}
return {
dispose: () => {
if (method === null) {
return;
}
if (method !== void 0) {
requestHandlers.delete(method);
} else {
starRequestHandler = void 0;
}
}
};
},
hasPendingResponse: () => {
return responsePromises.size > 0;
},
trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
let _sendNotification = false;
let _traceFormat = TraceFormat.Text;
if (sendNotificationOrTraceOptions !== void 0) {
if (Is.boolean(sendNotificationOrTraceOptions)) {
_sendNotification = sendNotificationOrTraceOptions;
} else {
_sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
_traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
}
}
trace = _value;
traceFormat = _traceFormat;
if (trace === Trace.Off) {
tracer = void 0;
} else {
tracer = _tracer;
}
if (_sendNotification && !isClosed() && !isDisposed()) {
await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
}
},
onError: errorEmitter.event,
onClose: closeEmitter.event,
onUnhandledNotification: unhandledNotificationEmitter.event,
onDispose: disposeEmitter.event,
end: () => {
messageWriter.end();
},
dispose: () => {
if (isDisposed()) {
return;
}
state = ConnectionState.Disposed;
disposeEmitter.fire(void 0);
const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
for (const promise of responsePromises.values()) {
promise.reject(error);
}
responsePromises = /* @__PURE__ */ new Map();
requestTokens = /* @__PURE__ */ new Map();
knownCanceledRequests = /* @__PURE__ */ new Set();
messageQueue = new linkedMap_1.LinkedMap();
if (Is.func(messageWriter.dispose)) {
messageWriter.dispose();
}
if (Is.func(messageReader.dispose)) {
messageReader.dispose();
}
},
listen: () => {
throwIfClosedOrDisposed();
throwIfListening();
state = ConnectionState.Listening;
messageReader.listen(callback);
},
inspect: () => {
(0, ral_1.default)().console.log("inspect");
}
};
connection.onNotification(LogTraceNotification.type, (params) => {
if (trace === Trace.Off || !tracer) {
return;
}
const verbose = trace === Trace.Verbose || trace === Trace.Compact;
tracer.log(params.message, verbose ? params.verbose : void 0);
});
connection.onNotification(ProgressNotification.type, (params) => {
const handler = progressHandlers.get(params.token);
if (handler) {
handler(params.value);
} else {
unhandledProgressEmitter.fire(params);
}
});
return connection;
}
exports2.createMessageConnection = createMessageConnection;
}
});
// node_modules/vscode-jsonrpc/lib/common/api.js
var require_api = __commonJS({
"node_modules/vscode-jsonrpc/lib/common/api.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProgressType = exports2.ProgressToken = exports2.createMessageConnection = exports2.NullLogger = exports2.ConnectionOptions = exports2.ConnectionStrategy = exports2.AbstractMessageBuffer = exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = exports2.SharedArrayReceiverStrategy = exports2.SharedArraySenderStrategy = exports2.CancellationToken = exports2.CancellationTokenSource = exports2.Emitter = exports2.Event = exports2.Disposable = exports2.LRUCache = exports2.Touch = exports2.LinkedMap = exports2.ParameterStructures = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.ErrorCodes = exports2.ResponseError = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType0 = exports2.RequestType = exports2.Message = exports2.RAL = void 0;
exports2.MessageStrategy = exports2.CancellationStrategy = exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.TraceValues = exports2.Trace = void 0;
var messages_1 = require_messages();
Object.defineProperty(exports2, "Message", { enumerable: true, get: function() {
return messages_1.Message;
} });
Object.defineProperty(exports2, "RequestType", { enumerable: true, get: function() {
return messages_1.RequestType;
} });
Object.defineProperty(exports2, "RequestType0", { enumerable: true, get: function() {
return messages_1.RequestType0;
} });
Object.defineProperty(exports2, "RequestType1", { enumerable: true, get: function() {
return messages_1.RequestType1;
} });
Object.defineProperty(exports2, "RequestType2", { enumerable: true, get: function() {
return messages_1.RequestType2;
} });
Object.defineProperty(exports2, "RequestType3", { enumerable: true, get: function() {
return messages_1.RequestType3;
} });
Object.defineProperty(exports2, "RequestType4", { enumerable: true, get: function() {
return messages_1.RequestType4;
} });
Object.defineProperty(exports2, "RequestType5", { enumerable: true, get: function() {
return messages_1.RequestType5;
} });
Object.defineProperty(exports2, "RequestType6", { enumerable: true, get: function() {
return messages_1.RequestType6;
} });
Object.defineProperty(exports2, "RequestType7", { enumerable: true, get: function() {
return messages_1.RequestType7;
} });
Object.defineProperty(exports2, "RequestType8", { enumerable: true, get: function() {
return messages_1.RequestType8;
} });
Object.defineProperty(exports2, "RequestType9", { enumerable: true, get: function() {
return messages_1.RequestType9;
} });
Object.defineProperty(exports2, "ResponseError", { enumerable: true, get: function() {
return messages_1.ResponseError;
} });
Object.defineProperty(exports2, "ErrorCodes", { enumerable: true, get: function() {
return messages_1.ErrorCodes;
} });
Object.defineProperty(exports2, "NotificationType", { enumerable: true, get: function() {
return messages_1.NotificationType;
} });
Object.defineProperty(exports2, "NotificationType0", { enumerable: true, get: function() {
return messages_1.NotificationType0;
} });
Object.defineProperty(exports2, "NotificationType1", { enumerable: true, get: function() {
return messages_1.NotificationType1;
} });
Object.defineProperty(exports2, "NotificationType2", { enumerable: true, get: function() {
return messages_1.NotificationType2;
} });
Object.defineProperty(exports2, "NotificationType3", { enumerable: true, get: function() {
return messages_1.NotificationType3;
} });
Object.defineProperty(exports2, "NotificationType4", { enumerable: true, get: function() {
return messages_1.NotificationType4;
} });
Object.defineProperty(exports2, "NotificationType5", { enumerable: true, get: function() {
return messages_1.NotificationType5;
} });
Object.defineProperty(exports2, "NotificationType6", { enumerable: true, get: function() {
return messages_1.NotificationType6;
} });
Object.defineProperty(exports2, "NotificationType7", { enumerable: true, get: function() {
return messages_1.NotificationType7;
} });
Object.defineProperty(exports2, "NotificationType8", { enumerable: true, get: function() {
return messages_1.NotificationType8;
} });
Object.defineProperty(exports2, "NotificationType9", { enumerable: true, get: function() {
return messages_1.NotificationType9;
} });
Object.defineProperty(exports2, "ParameterStructures", { enumerable: true, get: function() {
return messages_1.ParameterStructures;
} });
var linkedMap_1 = require_linkedMap();
Object.defineProperty(exports2, "LinkedMap", { enumerable: true, get: function() {
return linkedMap_1.LinkedMap;
} });
Object.defineProperty(exports2, "LRUCache", { enumerable: true, get: function() {
return linkedMap_1.LRUCache;
} });
Object.defineProperty(exports2, "Touch", { enumerable: true, get: function() {
return linkedMap_1.Touch;
} });
var disposable_1 = require_disposable();
Object.defineProperty(exports2, "Disposable", { enumerable: true, get: function() {
return disposable_1.Disposable;
} });
var events_1 = require_events();
Object.defineProperty(exports2, "Event", { enumerable: true, get: function() {
return events_1.Event;
} });
Object.defineProperty(exports2, "Emitter", { enumerable: true, get: function() {
return events_1.Emitter;
} });
var cancellation_1 = require_cancellation();
Object.defineProperty(exports2, "CancellationTokenSource", { enumerable: true, get: function() {
return cancellation_1.CancellationTokenSource;
} });
Object.defineProperty(exports2, "CancellationToken", { enumerable: true, get: function() {
return cancellation_1.CancellationToken;
} });
var sharedArrayCancellation_1 = require_sharedArrayCancellation();
Object.defineProperty(exports2, "SharedArraySenderStrategy", { enumerable: true, get: function() {
return sharedArrayCancellation_1.SharedArraySenderStrategy;
} });
Object.defineProperty(exports2, "SharedArrayReceiverStrategy", { enumerable: true, get: function() {
return sharedArrayCancellation_1.SharedArrayReceiverStrategy;
} });
var messageReader_1 = require_messageReader();
Object.defineProperty(exports2, "MessageReader", { enumerable: true, get: function() {
return messageReader_1.MessageReader;
} });
Object.defineProperty(exports2, "AbstractMessageReader", { enumerable: true, get: function() {
return messageReader_1.AbstractMessageReader;
} });
Object.defineProperty(exports2, "ReadableStreamMessageReader", { enumerable: true, get: function() {
return messageReader_1.ReadableStreamMessageReader;
} });
var messageWriter_1 = require_messageWriter();
Object.defineProperty(exports2, "MessageWriter", { enumerable: true, get: function() {
return messageWriter_1.MessageWriter;
} });
Object.defineProperty(exports2, "AbstractMessageWriter", { enumerable: true, get: function() {
return messageWriter_1.AbstractMessageWriter;
} });
Object.defineProperty(exports2, "WriteableStreamMessageWriter", { enumerable: true, get: function() {
return messageWriter_1.WriteableStreamMessageWriter;
} });
var messageBuffer_1 = require_messageBuffer();
Object.defineProperty(exports2, "AbstractMessageBuffer", { enumerable: true, get: function() {
return messageBuffer_1.AbstractMessageBuffer;
} });
var connection_1 = require_connection();
Object.defineProperty(exports2, "ConnectionStrategy", { enumerable: true, get: function() {
return connection_1.ConnectionStrategy;
} });
Object.defineProperty(exports2, "ConnectionOptions", { enumerable: true, get: function() {
return connection_1.ConnectionOptions;
} });
Object.defineProperty(exports2, "NullLogger", { enumerable: true, get: function() {
return connection_1.NullLogger;
} });
Object.defineProperty(exports2, "createMessageConnection", { enumerable: true, get: function() {
return connection_1.createMessageConnection;
} });
Object.defineProperty(exports2, "ProgressToken", { enumerable: true, get: function() {
return connection_1.ProgressToken;
} });
Object.defineProperty(exports2, "ProgressType", { enumerable: true, get: function() {
return connection_1.ProgressType;
} });
Object.defineProperty(exports2, "Trace", { enumerable: true, get: function() {
return connection_1.Trace;
} });
Object.defineProperty(exports2, "TraceValues", { enumerable: true, get: function() {
return connection_1.TraceValues;
} });
Object.defineProperty(exports2, "TraceFormat", { enumerable: true, get: function() {
return connection_1.TraceFormat;
} });
Object.defineProperty(exports2, "SetTraceNotification", { enumerable: true, get: function() {
return connection_1.SetTraceNotification;
} });
Object.defineProperty(exports2, "LogTraceNotification", { enumerable: true, get: function() {
return connection_1.LogTraceNotification;
} });
Object.defineProperty(exports2, "ConnectionErrors", { enumerable: true, get: function() {
return connection_1.ConnectionErrors;
} });
Object.defineProperty(exports2, "ConnectionError", { enumerable: true, get: function() {
return connection_1.ConnectionError;
} });
Object.defineProperty(exports2, "CancellationReceiverStrategy", { enumerable: true, get: function() {
return connection_1.CancellationReceiverStrategy;
} });
Object.defineProperty(exports2, "CancellationSenderStrategy", { enumerable: true, get: function() {
return connection_1.CancellationSenderStrategy;
} });
Object.defineProperty(exports2, "CancellationStrategy", { enumerable: true, get: function() {
return connection_1.CancellationStrategy;
} });
Object.defineProperty(exports2, "MessageStrategy", { enumerable: true, get: function() {
return connection_1.MessageStrategy;
} });
var ral_1 = require_ral();
exports2.RAL = ral_1.default;
}
});
// node_modules/vscode-jsonrpc/lib/node/ril.js
var require_ril = __commonJS({
"node_modules/vscode-jsonrpc/lib/node/ril.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var util_1 = require("util");
var api_1 = require_api();
var MessageBuffer = class _MessageBuffer extends api_1.AbstractMessageBuffer {
constructor(encoding = "utf-8") {
super(encoding);
}
emptyBuffer() {
return _MessageBuffer.emptyBuffer;
}
fromString(value, encoding) {
return Buffer.from(value, encoding);
}
toString(value, encoding) {
if (value instanceof Buffer) {
return value.toString(encoding);
} else {
return new util_1.TextDecoder(encoding).decode(value);
}
}
asNative(buffer, length) {
if (length === void 0) {
return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
} else {
return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
}
}
allocNative(length) {
return Buffer.allocUnsafe(length);
}
};
MessageBuffer.emptyBuffer = Buffer.allocUnsafe(0);
var ReadableStreamWrapper = class {
constructor(stream) {
this.stream = stream;
}
onClose(listener) {
this.stream.on("close", listener);
return api_1.Disposable.create(() => this.stream.off("close", listener));
}
onError(listener) {
this.stream.on("error", listener);
return api_1.Disposable.create(() => this.stream.off("error", listener));
}
onEnd(listener) {
this.stream.on("end", listener);
return api_1.Disposable.create(() => this.stream.off("end", listener));
}
onData(listener) {
this.stream.on("data", listener);
return api_1.Disposable.create(() => this.stream.off("data", listener));
}
};
var WritableStreamWrapper = class {
constructor(stream) {
this.stream = stream;
}
onClose(listener) {
this.stream.on("close", listener);
return api_1.Disposable.create(() => this.stream.off("close", listener));
}
onError(listener) {
this.stream.on("error", listener);
return api_1.Disposable.create(() => this.stream.off("error", listener));
}
onEnd(listener) {
this.stream.on("end", listener);
return api_1.Disposable.create(() => this.stream.off("end", listener));
}
write(data, encoding) {
return new Promise((resolve3, reject) => {
const callback = (error) => {
if (error === void 0 || error === null) {
resolve3();
} else {
reject(error);
}
};
if (typeof data === "string") {
this.stream.write(data, encoding, callback);
} else {
this.stream.write(data, callback);
}
});
}
end() {
this.stream.end();
}
};
var _ril = Object.freeze({
messageBuffer: Object.freeze({
create: (encoding) => new MessageBuffer(encoding)
}),
applicationJson: Object.freeze({
encoder: Object.freeze({
name: "application/json",
encode: (msg, options) => {
try {
return Promise.resolve(Buffer.from(JSON.stringify(msg, void 0, 0), options.charset));
} catch (err) {
return Promise.reject(err);
}
}
}),
decoder: Object.freeze({
name: "application/json",
decode: (buffer, options) => {
try {
if (buffer instanceof Buffer) {
return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
} else {
return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
}
} catch (err) {
return Promise.reject(err);
}
}
})
}),
stream: Object.freeze({
asReadableStream: (stream) => new ReadableStreamWrapper(stream),
asWritableStream: (stream) => new WritableStreamWrapper(stream)
}),
console,
timer: Object.freeze({
setTimeout(callback, ms, ...args) {
const handle = setTimeout(callback, ms, ...args);
return { dispose: () => clearTimeout(handle) };
},
setImmediate(callback, ...args) {
const handle = setImmediate(callback, ...args);
return { dispose: () => clearImmediate(handle) };
},
setInterval(callback, ms, ...args) {
const handle = setInterval(callback, ms, ...args);
return { dispose: () => clearInterval(handle) };
}
})
});
function RIL() {
return _ril;
}
(function(RIL2) {
function install() {
api_1.RAL.install(_ril);
}
RIL2.install = install;
})(RIL || (RIL = {}));
exports2.default = RIL;
}
});
// node_modules/vscode-jsonrpc/lib/node/main.js
var require_main = __commonJS({
"node_modules/vscode-jsonrpc/lib/node/main.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createMessageConnection = exports2.createServerSocketTransport = exports2.createClientSocketTransport = exports2.createServerPipeTransport = exports2.createClientPipeTransport = exports2.generateRandomPipeName = exports2.StreamMessageWriter = exports2.StreamMessageReader = exports2.SocketMessageWriter = exports2.SocketMessageReader = exports2.PortMessageWriter = exports2.PortMessageReader = exports2.IPCMessageWriter = exports2.IPCMessageReader = void 0;
var ril_1 = require_ril();
ril_1.default.install();
var path11 = require("path");
var os5 = require("os");
var crypto_1 = require("crypto");
var net_1 = require("net");
var api_1 = require_api();
__exportStar(require_api(), exports2);
var IPCMessageReader = class extends api_1.AbstractMessageReader {
constructor(process3) {
super();
this.process = process3;
let eventEmitter = this.process;
eventEmitter.on("error", (error) => this.fireError(error));
eventEmitter.on("close", () => this.fireClose());
}
listen(callback) {
this.process.on("message", callback);
return api_1.Disposable.create(() => this.process.off("message", callback));
}
};
exports2.IPCMessageReader = IPCMessageReader;
var IPCMessageWriter = class extends api_1.AbstractMessageWriter {
constructor(process3) {
super();
this.process = process3;
this.errorCount = 0;
const eventEmitter = this.process;
eventEmitter.on("error", (error) => this.fireError(error));
eventEmitter.on("close", () => this.fireClose);
}
write(msg) {
try {
if (typeof this.process.send === "function") {
this.process.send(msg, void 0, void 0, (error) => {
if (error) {
this.errorCount++;
this.handleError(error, msg);
} else {
this.errorCount = 0;
}
});
}
return Promise.resolve();
} catch (error) {
this.handleError(error, msg);
return Promise.reject(error);
}
}
handleError(error, msg) {
this.errorCount++;
this.fireError(error, msg, this.errorCount);
}
end() {
}
};
exports2.IPCMessageWriter = IPCMessageWriter;
var PortMessageReader = class extends api_1.AbstractMessageReader {
constructor(port) {
super();
this.onData = new api_1.Emitter();
port.on("close", () => this.fireClose);
port.on("error", (error) => this.fireError(error));
port.on("message", (message) => {
this.onData.fire(message);
});
}
listen(callback) {
return this.onData.event(callback);
}
};
exports2.PortMessageReader = PortMessageReader;
var PortMessageWriter = class extends api_1.AbstractMessageWriter {
constructor(port) {
super();
this.port = port;
this.errorCount = 0;
port.on("close", () => this.fireClose());
port.on("error", (error) => this.fireError(error));
}
write(msg) {
try {
this.port.postMessage(msg);
return Promise.resolve();
} catch (error) {
this.handleError(error, msg);
return Promise.reject(error);
}
}
handleError(error, msg) {
this.errorCount++;
this.fireError(error, msg, this.errorCount);
}
end() {
}
};
exports2.PortMessageWriter = PortMessageWriter;
var SocketMessageReader = class extends api_1.ReadableStreamMessageReader {
constructor(socket, encoding = "utf-8") {
super((0, ril_1.default)().stream.asReadableStream(socket), encoding);
}
};
exports2.SocketMessageReader = SocketMessageReader;
var SocketMessageWriter = class extends api_1.WriteableStreamMessageWriter {
constructor(socket, options) {
super((0, ril_1.default)().stream.asWritableStream(socket), options);
this.socket = socket;
}
dispose() {
super.dispose();
this.socket.destroy();
}
};
exports2.SocketMessageWriter = SocketMessageWriter;
var StreamMessageReader = class extends api_1.ReadableStreamMessageReader {
constructor(readable, encoding) {
super((0, ril_1.default)().stream.asReadableStream(readable), encoding);
}
};
exports2.StreamMessageReader = StreamMessageReader;
var StreamMessageWriter = class extends api_1.WriteableStreamMessageWriter {
constructor(writable, options) {
super((0, ril_1.default)().stream.asWritableStream(writable), options);
}
};
exports2.StreamMessageWriter = StreamMessageWriter;
var XDG_RUNTIME_DIR = process.env["XDG_RUNTIME_DIR"];
var safeIpcPathLengths = /* @__PURE__ */ new Map([
["linux", 107],
["darwin", 103]
]);
function generateRandomPipeName() {
const randomSuffix = (0, crypto_1.randomBytes)(21).toString("hex");
if (process.platform === "win32") {
return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
}
let result;
if (XDG_RUNTIME_DIR) {
result = path11.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
} else {
result = path11.join(os5.tmpdir(), `vscode-${randomSuffix}.sock`);
}
const limit = safeIpcPathLengths.get(process.platform);
if (limit !== void 0 && result.length > limit) {
(0, ril_1.default)().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
}
return result;
}
exports2.generateRandomPipeName = generateRandomPipeName;
function createClientPipeTransport(pipeName, encoding = "utf-8") {
let connectResolve;
const connected = new Promise((resolve3, _reject) => {
connectResolve = resolve3;
});
return new Promise((resolve3, reject) => {
let server = (0, net_1.createServer)((socket) => {
server.close();
connectResolve([
new SocketMessageReader(socket, encoding),
new SocketMessageWriter(socket, encoding)
]);
});
server.on("error", reject);
server.listen(pipeName, () => {
server.removeListener("error", reject);
resolve3({
onConnected: () => {
return connected;
}
});
});
});
}
exports2.createClientPipeTransport = createClientPipeTransport;
function createServerPipeTransport(pipeName, encoding = "utf-8") {
const socket = (0, net_1.createConnection)(pipeName);
return [
new SocketMessageReader(socket, encoding),
new SocketMessageWriter(socket, encoding)
];
}
exports2.createServerPipeTransport = createServerPipeTransport;
function createClientSocketTransport(port, encoding = "utf-8") {
let connectResolve;
const connected = new Promise((resolve3, _reject) => {
connectResolve = resolve3;
});
return new Promise((resolve3, reject) => {
const server = (0, net_1.createServer)((socket) => {
server.close();
connectResolve([
new SocketMessageReader(socket, encoding),
new SocketMessageWriter(socket, encoding)
]);
});
server.on("error", reject);
server.listen(port, "127.0.0.1", () => {
server.removeListener("error", reject);
resolve3({
onConnected: () => {
return connected;
}
});
});
});
}
exports2.createClientSocketTransport = createClientSocketTransport;
function createServerSocketTransport(port, encoding = "utf-8") {
const socket = (0, net_1.createConnection)(port, "127.0.0.1");
return [
new SocketMessageReader(socket, encoding),
new SocketMessageWriter(socket, encoding)
];
}
exports2.createServerSocketTransport = createServerSocketTransport;
function isReadableStream(value) {
const candidate = value;
return candidate.read !== void 0 && candidate.addListener !== void 0;
}
function isWritableStream(value) {
const candidate = value;
return candidate.write !== void 0 && candidate.addListener !== void 0;
}
function createMessageConnection(input, output, logger2, options) {
if (!logger2) {
logger2 = api_1.NullLogger;
}
const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
if (api_1.ConnectionStrategy.is(options)) {
options = { connectionStrategy: options };
}
return (0, api_1.createMessageConnection)(reader, writer, logger2, options);
}
exports2.createMessageConnection = createMessageConnection;
}
});
// node_modules/vscode-jsonrpc/node.js
var require_node = __commonJS({
"node_modules/vscode-jsonrpc/node.js"(exports2, module2) {
"use strict";
module2.exports = require_main();
}
});
// node_modules/vscode-languageserver-types/lib/umd/main.js
var require_main2 = __commonJS({
"node_modules/vscode-languageserver-types/lib/umd/main.js"(exports2, module2) {
(function(factory) {
if (typeof module2 === "object" && typeof module2.exports === "object") {
var v = factory(require, exports2);
if (v !== void 0) module2.exports = v;
} else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function(require2, exports3) {
"use strict";
Object.defineProperty(exports3, "__esModule", { value: true });
exports3.TextDocument = exports3.EOL = exports3.WorkspaceFolder = exports3.InlineCompletionContext = exports3.SelectedCompletionInfo = exports3.InlineCompletionTriggerKind = exports3.InlineCompletionList = exports3.InlineCompletionItem = exports3.StringValue = exports3.InlayHint = exports3.InlayHintLabelPart = exports3.InlayHintKind = exports3.InlineValueContext = exports3.InlineValueEvaluatableExpression = exports3.InlineValueVariableLookup = exports3.InlineValueText = exports3.SemanticTokens = exports3.SemanticTokenModifiers = exports3.SemanticTokenTypes = exports3.SelectionRange = exports3.DocumentLink = exports3.FormattingOptions = exports3.CodeLens = exports3.CodeAction = exports3.CodeActionContext = exports3.CodeActionTriggerKind = exports3.CodeActionKind = exports3.DocumentSymbol = exports3.WorkspaceSymbol = exports3.SymbolInformation = exports3.SymbolTag = exports3.SymbolKind = exports3.DocumentHighlight = exports3.DocumentHighlightKind = exports3.SignatureInformation = exports3.ParameterInformation = exports3.Hover = exports3.MarkedString = exports3.CompletionList = exports3.CompletionItem = exports3.CompletionItemLabelDetails = exports3.InsertTextMode = exports3.InsertReplaceEdit = exports3.CompletionItemTag = exports3.InsertTextFormat = exports3.CompletionItemKind = exports3.MarkupContent = exports3.MarkupKind = exports3.TextDocumentItem = exports3.OptionalVersionedTextDocumentIdentifier = exports3.VersionedTextDocumentIdentifier = exports3.TextDocumentIdentifier = exports3.WorkspaceChange = exports3.WorkspaceEdit = exports3.DeleteFile = exports3.RenameFile = exports3.CreateFile = exports3.TextDocumentEdit = exports3.AnnotatedTextEdit = exports3.ChangeAnnotationIdentifier = exports3.ChangeAnnotation = exports3.TextEdit = exports3.Command = exports3.Diagnostic = exports3.CodeDescription = exports3.DiagnosticTag = exports3.DiagnosticSeverity = exports3.DiagnosticRelatedInformation = exports3.FoldingRange = exports3.FoldingRangeKind = exports3.ColorPresentation = exports3.ColorInformation = exports3.Color = exports3.LocationLink = exports3.Location = exports3.Range = exports3.Position = exports3.uinteger = exports3.integer = exports3.URI = exports3.DocumentUri = void 0;
var DocumentUri;
(function(DocumentUri2) {
function is(value) {
return typeof value === "string";
}
DocumentUri2.is = is;
})(DocumentUri || (exports3.DocumentUri = DocumentUri = {}));
var URI;
(function(URI2) {
function is(value) {
return typeof value === "string";
}
URI2.is = is;
})(URI || (exports3.URI = URI = {}));
var integer2;
(function(integer3) {
integer3.MIN_VALUE = -2147483648;
integer3.MAX_VALUE = 2147483647;
function is(value) {
return typeof value === "number" && integer3.MIN_VALUE <= value && value <= integer3.MAX_VALUE;
}
integer3.is = is;
})(integer2 || (exports3.integer = integer2 = {}));
var uinteger;
(function(uinteger2) {
uinteger2.MIN_VALUE = 0;
uinteger2.MAX_VALUE = 2147483647;
function is(value) {
return typeof value === "number" && uinteger2.MIN_VALUE <= value && value <= uinteger2.MAX_VALUE;
}
uinteger2.is = is;
})(uinteger || (exports3.uinteger = uinteger = {}));
var Position3;
(function(Position4) {
function create(line, character) {
if (line === Number.MAX_VALUE) {
line = uinteger.MAX_VALUE;
}
if (character === Number.MAX_VALUE) {
character = uinteger.MAX_VALUE;
}
return { line, character };
}
Position4.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
}
Position4.is = is;
})(Position3 || (exports3.Position = Position3 = {}));
var Range5;
(function(Range6) {
function create(one, two, three, four) {
if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
return { start: Position3.create(one, two), end: Position3.create(three, four) };
} else if (Position3.is(one) && Position3.is(two)) {
return { start: one, end: two };
} else {
throw new Error("Range#create called with invalid arguments[".concat(one, ", ").concat(two, ", ").concat(three, ", ").concat(four, "]"));
}
}
Range6.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Position3.is(candidate.start) && Position3.is(candidate.end);
}
Range6.is = is;
})(Range5 || (exports3.Range = Range5 = {}));
var Location;
(function(Location2) {
function create(uri, range) {
return { uri, range };
}
Location2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Range5.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
}
Location2.is = is;
})(Location || (exports3.Location = Location = {}));
var LocationLink;
(function(LocationLink2) {
function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
}
LocationLink2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Range5.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range5.is(candidate.targetSelectionRange) && (Range5.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
}
LocationLink2.is = is;
})(LocationLink || (exports3.LocationLink = LocationLink = {}));
var Color;
(function(Color2) {
function create(red, green, blue, alpha) {
return {
red,
green,
blue,
alpha
};
}
Color2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
}
Color2.is = is;
})(Color || (exports3.Color = Color = {}));
var ColorInformation;
(function(ColorInformation2) {
function create(range, color) {
return {
range,
color
};
}
ColorInformation2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Range5.is(candidate.range) && Color.is(candidate.color);
}
ColorInformation2.is = is;
})(ColorInformation || (exports3.ColorInformation = ColorInformation = {}));
var ColorPresentation;
(function(ColorPresentation2) {
function create(label, textEdit, additionalTextEdits) {
return {
label,
textEdit,
additionalTextEdits
};
}
ColorPresentation2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit2.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit2.is));
}
ColorPresentation2.is = is;
})(ColorPresentation || (exports3.ColorPresentation = ColorPresentation = {}));
var FoldingRangeKind;
(function(FoldingRangeKind2) {
FoldingRangeKind2.Comment = "comment";
FoldingRangeKind2.Imports = "imports";
FoldingRangeKind2.Region = "region";
})(FoldingRangeKind || (exports3.FoldingRangeKind = FoldingRangeKind = {}));
var FoldingRange;
(function(FoldingRange2) {
function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
var result = {
startLine,
endLine
};
if (Is.defined(startCharacter)) {
result.startCharacter = startCharacter;
}
if (Is.defined(endCharacter)) {
result.endCharacter = endCharacter;
}
if (Is.defined(kind)) {
result.kind = kind;
}
if (Is.defined(collapsedText)) {
result.collapsedText = collapsedText;
}
return result;
}
FoldingRange2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
}
FoldingRange2.is = is;
})(FoldingRange || (exports3.FoldingRange = FoldingRange = {}));
var DiagnosticRelatedInformation;
(function(DiagnosticRelatedInformation2) {
function create(location2, message) {
return {
location: location2,
message
};
}
DiagnosticRelatedInformation2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
}
DiagnosticRelatedInformation2.is = is;
})(DiagnosticRelatedInformation || (exports3.DiagnosticRelatedInformation = DiagnosticRelatedInformation = {}));
var DiagnosticSeverity;
(function(DiagnosticSeverity2) {
DiagnosticSeverity2.Error = 1;
DiagnosticSeverity2.Warning = 2;
DiagnosticSeverity2.Information = 3;
DiagnosticSeverity2.Hint = 4;
})(DiagnosticSeverity || (exports3.DiagnosticSeverity = DiagnosticSeverity = {}));
var DiagnosticTag;
(function(DiagnosticTag2) {
DiagnosticTag2.Unnecessary = 1;
DiagnosticTag2.Deprecated = 2;
})(DiagnosticTag || (exports3.DiagnosticTag = DiagnosticTag = {}));
var CodeDescription;
(function(CodeDescription2) {
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.href);
}
CodeDescription2.is = is;
})(CodeDescription || (exports3.CodeDescription = CodeDescription = {}));
var Diagnostic;
(function(Diagnostic2) {
function create(range, message, severity, code, source, relatedInformation) {
var result = { range, message };
if (Is.defined(severity)) {
result.severity = severity;
}
if (Is.defined(code)) {
result.code = code;
}
if (Is.defined(source)) {
result.source = source;
}
if (Is.defined(relatedInformation)) {
result.relatedInformation = relatedInformation;
}
return result;
}
Diagnostic2.create = create;
function is(value) {
var _a;
var candidate = value;
return Is.defined(candidate) && Range5.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
}
Diagnostic2.is = is;
})(Diagnostic || (exports3.Diagnostic = Diagnostic = {}));
var Command2;
(function(Command3) {
function create(title, command) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
var result = { title, command };
if (Is.defined(args) && args.length > 0) {
result.arguments = args;
}
return result;
}
Command3.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
}
Command3.is = is;
})(Command2 || (exports3.Command = Command2 = {}));
var TextEdit2;
(function(TextEdit3) {
function replace(range, newText) {
return { range, newText };
}
TextEdit3.replace = replace;
function insert(position, newText) {
return { range: { start: position, end: position }, newText };
}
TextEdit3.insert = insert;
function del(range) {
return { range, newText: "" };
}
TextEdit3.del = del;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range5.is(candidate.range);
}
TextEdit3.is = is;
})(TextEdit2 || (exports3.TextEdit = TextEdit2 = {}));
var ChangeAnnotation;
(function(ChangeAnnotation2) {
function create(label, needsConfirmation, description) {
var result = { label };
if (needsConfirmation !== void 0) {
result.needsConfirmation = needsConfirmation;
}
if (description !== void 0) {
result.description = description;
}
return result;
}
ChangeAnnotation2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
}
ChangeAnnotation2.is = is;
})(ChangeAnnotation || (exports3.ChangeAnnotation = ChangeAnnotation = {}));
var ChangeAnnotationIdentifier;
(function(ChangeAnnotationIdentifier2) {
function is(value) {
var candidate = value;
return Is.string(candidate);
}
ChangeAnnotationIdentifier2.is = is;
})(ChangeAnnotationIdentifier || (exports3.ChangeAnnotationIdentifier = ChangeAnnotationIdentifier = {}));
var AnnotatedTextEdit;
(function(AnnotatedTextEdit2) {
function replace(range, newText, annotation) {
return { range, newText, annotationId: annotation };
}
AnnotatedTextEdit2.replace = replace;
function insert(position, newText, annotation) {
return { range: { start: position, end: position }, newText, annotationId: annotation };
}
AnnotatedTextEdit2.insert = insert;
function del(range, annotation) {
return { range, newText: "", annotationId: annotation };
}
AnnotatedTextEdit2.del = del;
function is(value) {
var candidate = value;
return TextEdit2.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
AnnotatedTextEdit2.is = is;
})(AnnotatedTextEdit || (exports3.AnnotatedTextEdit = AnnotatedTextEdit = {}));
var TextDocumentEdit;
(function(TextDocumentEdit2) {
function create(textDocument, edits) {
return { textDocument, edits };
}
TextDocumentEdit2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
}
TextDocumentEdit2.is = is;
})(TextDocumentEdit || (exports3.TextDocumentEdit = TextDocumentEdit = {}));
var CreateFile;
(function(CreateFile2) {
function create(uri, options, annotation) {
var result = {
kind: "create",
uri
};
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
CreateFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
CreateFile2.is = is;
})(CreateFile || (exports3.CreateFile = CreateFile = {}));
var RenameFile;
(function(RenameFile2) {
function create(oldUri, newUri, options, annotation) {
var result = {
kind: "rename",
oldUri,
newUri
};
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
RenameFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
RenameFile2.is = is;
})(RenameFile || (exports3.RenameFile = RenameFile = {}));
var DeleteFile;
(function(DeleteFile2) {
function create(uri, options, annotation) {
var result = {
kind: "delete",
uri
};
if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
DeleteFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
DeleteFile2.is = is;
})(DeleteFile || (exports3.DeleteFile = DeleteFile = {}));
var WorkspaceEdit2;
(function(WorkspaceEdit3) {
function is(value) {
var candidate = value;
return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every(function(change) {
if (Is.string(change.kind)) {
return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
} else {
return TextDocumentEdit.is(change);
}
}));
}
WorkspaceEdit3.is = is;
})(WorkspaceEdit2 || (exports3.WorkspaceEdit = WorkspaceEdit2 = {}));
var TextEditChangeImpl = (
/** @class */
(function() {
function TextEditChangeImpl2(edits, changeAnnotations) {
this.edits = edits;
this.changeAnnotations = changeAnnotations;
}
TextEditChangeImpl2.prototype.insert = function(position, newText, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit2.insert(position, newText);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.insert(position, newText, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.insert(position, newText, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.replace = function(range, newText, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit2.replace(range, newText);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.replace(range, newText, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.replace(range, newText, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.delete = function(range, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit2.del(range);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.del(range, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.del(range, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.add = function(edit) {
this.edits.push(edit);
};
TextEditChangeImpl2.prototype.all = function() {
return this.edits;
};
TextEditChangeImpl2.prototype.clear = function() {
this.edits.splice(0, this.edits.length);
};
TextEditChangeImpl2.prototype.assertChangeAnnotations = function(value) {
if (value === void 0) {
throw new Error("Text edit change is not configured to manage change annotations.");
}
};
return TextEditChangeImpl2;
})()
);
var ChangeAnnotations = (
/** @class */
(function() {
function ChangeAnnotations2(annotations) {
this._annotations = annotations === void 0 ? /* @__PURE__ */ Object.create(null) : annotations;
this._counter = 0;
this._size = 0;
}
ChangeAnnotations2.prototype.all = function() {
return this._annotations;
};
Object.defineProperty(ChangeAnnotations2.prototype, "size", {
get: function() {
return this._size;
},
enumerable: false,
configurable: true
});
ChangeAnnotations2.prototype.manage = function(idOrAnnotation, annotation) {
var id;
if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
id = idOrAnnotation;
} else {
id = this.nextId();
annotation = idOrAnnotation;
}
if (this._annotations[id] !== void 0) {
throw new Error("Id ".concat(id, " is already in use."));
}
if (annotation === void 0) {
throw new Error("No annotation provided for id ".concat(id));
}
this._annotations[id] = annotation;
this._size++;
return id;
};
ChangeAnnotations2.prototype.nextId = function() {
this._counter++;
return this._counter.toString();
};
return ChangeAnnotations2;
})()
);
var WorkspaceChange = (
/** @class */
(function() {
function WorkspaceChange2(workspaceEdit) {
var _this = this;
this._textEditChanges = /* @__PURE__ */ Object.create(null);
if (workspaceEdit !== void 0) {
this._workspaceEdit = workspaceEdit;
if (workspaceEdit.documentChanges) {
this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
workspaceEdit.changeAnnotations = this._changeAnnotations.all();
workspaceEdit.documentChanges.forEach(function(change) {
if (TextDocumentEdit.is(change)) {
var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
_this._textEditChanges[change.textDocument.uri] = textEditChange;
}
});
} else if (workspaceEdit.changes) {
Object.keys(workspaceEdit.changes).forEach(function(key) {
var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
_this._textEditChanges[key] = textEditChange;
});
}
} else {
this._workspaceEdit = {};
}
}
Object.defineProperty(WorkspaceChange2.prototype, "edit", {
/**
* Returns the underlying {@link WorkspaceEdit} literal
* use to be returned from a workspace edit operation like rename.
*/
get: function() {
this.initDocumentChanges();
if (this._changeAnnotations !== void 0) {
if (this._changeAnnotations.size === 0) {
this._workspaceEdit.changeAnnotations = void 0;
} else {
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
}
}
return this._workspaceEdit;
},
enumerable: false,
configurable: true
});
WorkspaceChange2.prototype.getTextEditChange = function(key) {
if (OptionalVersionedTextDocumentIdentifier.is(key)) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var textDocument = { uri: key.uri, version: key.version };
var result = this._textEditChanges[textDocument.uri];
if (!result) {
var edits = [];
var textDocumentEdit = {
textDocument,
edits
};
this._workspaceEdit.documentChanges.push(textDocumentEdit);
result = new TextEditChangeImpl(edits, this._changeAnnotations);
this._textEditChanges[textDocument.uri] = result;
}
return result;
} else {
this.initChanges();
if (this._workspaceEdit.changes === void 0) {
throw new Error("Workspace edit is not configured for normal text edit changes.");
}
var result = this._textEditChanges[key];
if (!result) {
var edits = [];
this._workspaceEdit.changes[key] = edits;
result = new TextEditChangeImpl(edits);
this._textEditChanges[key] = result;
}
return result;
}
};
WorkspaceChange2.prototype.initDocumentChanges = function() {
if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
this._changeAnnotations = new ChangeAnnotations();
this._workspaceEdit.documentChanges = [];
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
}
};
WorkspaceChange2.prototype.initChanges = function() {
if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
}
};
WorkspaceChange2.prototype.createFile = function(uri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = CreateFile.create(uri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = CreateFile.create(uri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = RenameFile.create(oldUri, newUri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = RenameFile.create(oldUri, newUri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
WorkspaceChange2.prototype.deleteFile = function(uri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = DeleteFile.create(uri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = DeleteFile.create(uri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
return WorkspaceChange2;
})()
);
exports3.WorkspaceChange = WorkspaceChange;
var TextDocumentIdentifier2;
(function(TextDocumentIdentifier3) {
function create(uri) {
return { uri };
}
TextDocumentIdentifier3.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri);
}
TextDocumentIdentifier3.is = is;
})(TextDocumentIdentifier2 || (exports3.TextDocumentIdentifier = TextDocumentIdentifier2 = {}));
var VersionedTextDocumentIdentifier;
(function(VersionedTextDocumentIdentifier2) {
function create(uri, version) {
return { uri, version };
}
VersionedTextDocumentIdentifier2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
}
VersionedTextDocumentIdentifier2.is = is;
})(VersionedTextDocumentIdentifier || (exports3.VersionedTextDocumentIdentifier = VersionedTextDocumentIdentifier = {}));
var OptionalVersionedTextDocumentIdentifier;
(function(OptionalVersionedTextDocumentIdentifier2) {
function create(uri, version) {
return { uri, version };
}
OptionalVersionedTextDocumentIdentifier2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
}
OptionalVersionedTextDocumentIdentifier2.is = is;
})(OptionalVersionedTextDocumentIdentifier || (exports3.OptionalVersionedTextDocumentIdentifier = OptionalVersionedTextDocumentIdentifier = {}));
var TextDocumentItem;
(function(TextDocumentItem2) {
function create(uri, languageId, version, text) {
return { uri, languageId, version, text };
}
TextDocumentItem2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
}
TextDocumentItem2.is = is;
})(TextDocumentItem || (exports3.TextDocumentItem = TextDocumentItem = {}));
var MarkupKind;
(function(MarkupKind2) {
MarkupKind2.PlainText = "plaintext";
MarkupKind2.Markdown = "markdown";
function is(value) {
var candidate = value;
return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
}
MarkupKind2.is = is;
})(MarkupKind || (exports3.MarkupKind = MarkupKind = {}));
var MarkupContent;
(function(MarkupContent2) {
function is(value) {
var candidate = value;
return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
}
MarkupContent2.is = is;
})(MarkupContent || (exports3.MarkupContent = MarkupContent = {}));
var CompletionItemKind;
(function(CompletionItemKind2) {
CompletionItemKind2.Text = 1;
CompletionItemKind2.Method = 2;
CompletionItemKind2.Function = 3;
CompletionItemKind2.Constructor = 4;
CompletionItemKind2.Field = 5;
CompletionItemKind2.Variable = 6;
CompletionItemKind2.Class = 7;
CompletionItemKind2.Interface = 8;
CompletionItemKind2.Module = 9;
CompletionItemKind2.Property = 10;
CompletionItemKind2.Unit = 11;
CompletionItemKind2.Value = 12;
CompletionItemKind2.Enum = 13;
CompletionItemKind2.Keyword = 14;
CompletionItemKind2.Snippet = 15;
CompletionItemKind2.Color = 16;
CompletionItemKind2.File = 17;
CompletionItemKind2.Reference = 18;
CompletionItemKind2.Folder = 19;
CompletionItemKind2.EnumMember = 20;
CompletionItemKind2.Constant = 21;
CompletionItemKind2.Struct = 22;
CompletionItemKind2.Event = 23;
CompletionItemKind2.Operator = 24;
CompletionItemKind2.TypeParameter = 25;
})(CompletionItemKind || (exports3.CompletionItemKind = CompletionItemKind = {}));
var InsertTextFormat;
(function(InsertTextFormat2) {
InsertTextFormat2.PlainText = 1;
InsertTextFormat2.Snippet = 2;
})(InsertTextFormat || (exports3.InsertTextFormat = InsertTextFormat = {}));
var CompletionItemTag;
(function(CompletionItemTag2) {
CompletionItemTag2.Deprecated = 1;
})(CompletionItemTag || (exports3.CompletionItemTag = CompletionItemTag = {}));
var InsertReplaceEdit;
(function(InsertReplaceEdit2) {
function create(newText, insert, replace) {
return { newText, insert, replace };
}
InsertReplaceEdit2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.newText) && Range5.is(candidate.insert) && Range5.is(candidate.replace);
}
InsertReplaceEdit2.is = is;
})(InsertReplaceEdit || (exports3.InsertReplaceEdit = InsertReplaceEdit = {}));
var InsertTextMode;
(function(InsertTextMode2) {
InsertTextMode2.asIs = 1;
InsertTextMode2.adjustIndentation = 2;
})(InsertTextMode || (exports3.InsertTextMode = InsertTextMode = {}));
var CompletionItemLabelDetails;
(function(CompletionItemLabelDetails2) {
function is(value) {
var candidate = value;
return candidate && (Is.string(candidate.detail) || candidate.detail === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
}
CompletionItemLabelDetails2.is = is;
})(CompletionItemLabelDetails || (exports3.CompletionItemLabelDetails = CompletionItemLabelDetails = {}));
var CompletionItem;
(function(CompletionItem2) {
function create(label) {
return { label };
}
CompletionItem2.create = create;
})(CompletionItem || (exports3.CompletionItem = CompletionItem = {}));
var CompletionList;
(function(CompletionList2) {
function create(items, isIncomplete) {
return { items: items ? items : [], isIncomplete: !!isIncomplete };
}
CompletionList2.create = create;
})(CompletionList || (exports3.CompletionList = CompletionList = {}));
var MarkedString;
(function(MarkedString2) {
function fromPlainText(plainText) {
return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
}
MarkedString2.fromPlainText = fromPlainText;
function is(value) {
var candidate = value;
return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
}
MarkedString2.is = is;
})(MarkedString || (exports3.MarkedString = MarkedString = {}));
var Hover;
(function(Hover2) {
function is(value) {
var candidate = value;
return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range5.is(value.range));
}
Hover2.is = is;
})(Hover || (exports3.Hover = Hover = {}));
var ParameterInformation;
(function(ParameterInformation2) {
function create(label, documentation) {
return documentation ? { label, documentation } : { label };
}
ParameterInformation2.create = create;
})(ParameterInformation || (exports3.ParameterInformation = ParameterInformation = {}));
var SignatureInformation;
(function(SignatureInformation2) {
function create(label, documentation) {
var parameters = [];
for (var _i = 2; _i < arguments.length; _i++) {
parameters[_i - 2] = arguments[_i];
}
var result = { label };
if (Is.defined(documentation)) {
result.documentation = documentation;
}
if (Is.defined(parameters)) {
result.parameters = parameters;
} else {
result.parameters = [];
}
return result;
}
SignatureInformation2.create = create;
})(SignatureInformation || (exports3.SignatureInformation = SignatureInformation = {}));
var DocumentHighlightKind;
(function(DocumentHighlightKind2) {
DocumentHighlightKind2.Text = 1;
DocumentHighlightKind2.Read = 2;
DocumentHighlightKind2.Write = 3;
})(DocumentHighlightKind || (exports3.DocumentHighlightKind = DocumentHighlightKind = {}));
var DocumentHighlight;
(function(DocumentHighlight2) {
function create(range, kind) {
var result = { range };
if (Is.number(kind)) {
result.kind = kind;
}
return result;
}
DocumentHighlight2.create = create;
})(DocumentHighlight || (exports3.DocumentHighlight = DocumentHighlight = {}));
var SymbolKind;
(function(SymbolKind2) {
SymbolKind2.File = 1;
SymbolKind2.Module = 2;
SymbolKind2.Namespace = 3;
SymbolKind2.Package = 4;
SymbolKind2.Class = 5;
SymbolKind2.Method = 6;
SymbolKind2.Property = 7;
SymbolKind2.Field = 8;
SymbolKind2.Constructor = 9;
SymbolKind2.Enum = 10;
SymbolKind2.Interface = 11;
SymbolKind2.Function = 12;
SymbolKind2.Variable = 13;
SymbolKind2.Constant = 14;
SymbolKind2.String = 15;
SymbolKind2.Number = 16;
SymbolKind2.Boolean = 17;
SymbolKind2.Array = 18;
SymbolKind2.Object = 19;
SymbolKind2.Key = 20;
SymbolKind2.Null = 21;
SymbolKind2.EnumMember = 22;
SymbolKind2.Struct = 23;
SymbolKind2.Event = 24;
SymbolKind2.Operator = 25;
SymbolKind2.TypeParameter = 26;
})(SymbolKind || (exports3.SymbolKind = SymbolKind = {}));
var SymbolTag;
(function(SymbolTag2) {
SymbolTag2.Deprecated = 1;
})(SymbolTag || (exports3.SymbolTag = SymbolTag = {}));
var SymbolInformation;
(function(SymbolInformation2) {
function create(name, kind, range, uri, containerName) {
var result = {
name,
kind,
location: { uri, range }
};
if (containerName) {
result.containerName = containerName;
}
return result;
}
SymbolInformation2.create = create;
})(SymbolInformation || (exports3.SymbolInformation = SymbolInformation = {}));
var WorkspaceSymbol;
(function(WorkspaceSymbol2) {
function create(name, kind, uri, range) {
return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
}
WorkspaceSymbol2.create = create;
})(WorkspaceSymbol || (exports3.WorkspaceSymbol = WorkspaceSymbol = {}));
var DocumentSymbol;
(function(DocumentSymbol2) {
function create(name, detail, kind, range, selectionRange, children) {
var result = {
name,
detail,
kind,
range,
selectionRange
};
if (children !== void 0) {
result.children = children;
}
return result;
}
DocumentSymbol2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range5.is(candidate.range) && Range5.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
}
DocumentSymbol2.is = is;
})(DocumentSymbol || (exports3.DocumentSymbol = DocumentSymbol = {}));
var CodeActionKind;
(function(CodeActionKind2) {
CodeActionKind2.Empty = "";
CodeActionKind2.QuickFix = "quickfix";
CodeActionKind2.Refactor = "refactor";
CodeActionKind2.RefactorExtract = "refactor.extract";
CodeActionKind2.RefactorInline = "refactor.inline";
CodeActionKind2.RefactorRewrite = "refactor.rewrite";
CodeActionKind2.Source = "source";
CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
CodeActionKind2.SourceFixAll = "source.fixAll";
})(CodeActionKind || (exports3.CodeActionKind = CodeActionKind = {}));
var CodeActionTriggerKind;
(function(CodeActionTriggerKind2) {
CodeActionTriggerKind2.Invoked = 1;
CodeActionTriggerKind2.Automatic = 2;
})(CodeActionTriggerKind || (exports3.CodeActionTriggerKind = CodeActionTriggerKind = {}));
var CodeActionContext;
(function(CodeActionContext2) {
function create(diagnostics, only, triggerKind) {
var result = { diagnostics };
if (only !== void 0 && only !== null) {
result.only = only;
}
if (triggerKind !== void 0 && triggerKind !== null) {
result.triggerKind = triggerKind;
}
return result;
}
CodeActionContext2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
}
CodeActionContext2.is = is;
})(CodeActionContext || (exports3.CodeActionContext = CodeActionContext = {}));
var CodeAction;
(function(CodeAction2) {
function create(title, kindOrCommandOrEdit, kind) {
var result = { title };
var checkKind = true;
if (typeof kindOrCommandOrEdit === "string") {
checkKind = false;
result.kind = kindOrCommandOrEdit;
} else if (Command2.is(kindOrCommandOrEdit)) {
result.command = kindOrCommandOrEdit;
} else {
result.edit = kindOrCommandOrEdit;
}
if (checkKind && kind !== void 0) {
result.kind = kind;
}
return result;
}
CodeAction2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command2.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit2.is(candidate.edit));
}
CodeAction2.is = is;
})(CodeAction || (exports3.CodeAction = CodeAction = {}));
var CodeLens;
(function(CodeLens2) {
function create(range, data) {
var result = { range };
if (Is.defined(data)) {
result.data = data;
}
return result;
}
CodeLens2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range5.is(candidate.range) && (Is.undefined(candidate.command) || Command2.is(candidate.command));
}
CodeLens2.is = is;
})(CodeLens || (exports3.CodeLens = CodeLens = {}));
var FormattingOptions;
(function(FormattingOptions2) {
function create(tabSize, insertSpaces) {
return { tabSize, insertSpaces };
}
FormattingOptions2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
}
FormattingOptions2.is = is;
})(FormattingOptions || (exports3.FormattingOptions = FormattingOptions = {}));
var DocumentLink;
(function(DocumentLink2) {
function create(range, target, data) {
return { range, target, data };
}
DocumentLink2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range5.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
}
DocumentLink2.is = is;
})(DocumentLink || (exports3.DocumentLink = DocumentLink = {}));
var SelectionRange;
(function(SelectionRange2) {
function create(range, parent) {
return { range, parent };
}
SelectionRange2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Range5.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
}
SelectionRange2.is = is;
})(SelectionRange || (exports3.SelectionRange = SelectionRange = {}));
var SemanticTokenTypes;
(function(SemanticTokenTypes2) {
SemanticTokenTypes2["namespace"] = "namespace";
SemanticTokenTypes2["type"] = "type";
SemanticTokenTypes2["class"] = "class";
SemanticTokenTypes2["enum"] = "enum";
SemanticTokenTypes2["interface"] = "interface";
SemanticTokenTypes2["struct"] = "struct";
SemanticTokenTypes2["typeParameter"] = "typeParameter";
SemanticTokenTypes2["parameter"] = "parameter";
SemanticTokenTypes2["variable"] = "variable";
SemanticTokenTypes2["property"] = "property";
SemanticTokenTypes2["enumMember"] = "enumMember";
SemanticTokenTypes2["event"] = "event";
SemanticTokenTypes2["function"] = "function";
SemanticTokenTypes2["method"] = "method";
SemanticTokenTypes2["macro"] = "macro";
SemanticTokenTypes2["keyword"] = "keyword";
SemanticTokenTypes2["modifier"] = "modifier";
SemanticTokenTypes2["comment"] = "comment";
SemanticTokenTypes2["string"] = "string";
SemanticTokenTypes2["number"] = "number";
SemanticTokenTypes2["regexp"] = "regexp";
SemanticTokenTypes2["operator"] = "operator";
SemanticTokenTypes2["decorator"] = "decorator";
})(SemanticTokenTypes || (exports3.SemanticTokenTypes = SemanticTokenTypes = {}));
var SemanticTokenModifiers;
(function(SemanticTokenModifiers2) {
SemanticTokenModifiers2["declaration"] = "declaration";
SemanticTokenModifiers2["definition"] = "definition";
SemanticTokenModifiers2["readonly"] = "readonly";
SemanticTokenModifiers2["static"] = "static";
SemanticTokenModifiers2["deprecated"] = "deprecated";
SemanticTokenModifiers2["abstract"] = "abstract";
SemanticTokenModifiers2["async"] = "async";
SemanticTokenModifiers2["modification"] = "modification";
SemanticTokenModifiers2["documentation"] = "documentation";
SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
})(SemanticTokenModifiers || (exports3.SemanticTokenModifiers = SemanticTokenModifiers = {}));
var SemanticTokens;
(function(SemanticTokens2) {
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
}
SemanticTokens2.is = is;
})(SemanticTokens || (exports3.SemanticTokens = SemanticTokens = {}));
var InlineValueText;
(function(InlineValueText2) {
function create(range, text) {
return { range, text };
}
InlineValueText2.create = create;
function is(value) {
var candidate = value;
return candidate !== void 0 && candidate !== null && Range5.is(candidate.range) && Is.string(candidate.text);
}
InlineValueText2.is = is;
})(InlineValueText || (exports3.InlineValueText = InlineValueText = {}));
var InlineValueVariableLookup;
(function(InlineValueVariableLookup2) {
function create(range, variableName, caseSensitiveLookup) {
return { range, variableName, caseSensitiveLookup };
}
InlineValueVariableLookup2.create = create;
function is(value) {
var candidate = value;
return candidate !== void 0 && candidate !== null && Range5.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === void 0);
}
InlineValueVariableLookup2.is = is;
})(InlineValueVariableLookup || (exports3.InlineValueVariableLookup = InlineValueVariableLookup = {}));
var InlineValueEvaluatableExpression;
(function(InlineValueEvaluatableExpression2) {
function create(range, expression) {
return { range, expression };
}
InlineValueEvaluatableExpression2.create = create;
function is(value) {
var candidate = value;
return candidate !== void 0 && candidate !== null && Range5.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === void 0);
}
InlineValueEvaluatableExpression2.is = is;
})(InlineValueEvaluatableExpression || (exports3.InlineValueEvaluatableExpression = InlineValueEvaluatableExpression = {}));
var InlineValueContext;
(function(InlineValueContext2) {
function create(frameId, stoppedLocation) {
return { frameId, stoppedLocation };
}
InlineValueContext2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range5.is(value.stoppedLocation);
}
InlineValueContext2.is = is;
})(InlineValueContext || (exports3.InlineValueContext = InlineValueContext = {}));
var InlayHintKind;
(function(InlayHintKind2) {
InlayHintKind2.Type = 1;
InlayHintKind2.Parameter = 2;
function is(value) {
return value === 1 || value === 2;
}
InlayHintKind2.is = is;
})(InlayHintKind || (exports3.InlayHintKind = InlayHintKind = {}));
var InlayHintLabelPart;
(function(InlayHintLabelPart2) {
function create(value) {
return { value };
}
InlayHintLabelPart2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === void 0 || Location.is(candidate.location)) && (candidate.command === void 0 || Command2.is(candidate.command));
}
InlayHintLabelPart2.is = is;
})(InlayHintLabelPart || (exports3.InlayHintLabelPart = InlayHintLabelPart = {}));
var InlayHint;
(function(InlayHint2) {
function create(position, label, kind) {
var result = { position, label };
if (kind !== void 0) {
result.kind = kind;
}
return result;
}
InlayHint2.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Position3.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === void 0 || InlayHintKind.is(candidate.kind)) && candidate.textEdits === void 0 || Is.typedArray(candidate.textEdits, TextEdit2.is) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is.boolean(candidate.paddingRight));
}
InlayHint2.is = is;
})(InlayHint || (exports3.InlayHint = InlayHint = {}));
var StringValue;
(function(StringValue2) {
function createSnippet(value) {
return { kind: "snippet", value };
}
StringValue2.createSnippet = createSnippet;
})(StringValue || (exports3.StringValue = StringValue = {}));
var InlineCompletionItem;
(function(InlineCompletionItem2) {
function create(insertText, filterText, range, command) {
return { insertText, filterText, range, command };
}
InlineCompletionItem2.create = create;
})(InlineCompletionItem || (exports3.InlineCompletionItem = InlineCompletionItem = {}));
var InlineCompletionList;
(function(InlineCompletionList2) {
function create(items) {
return { items };
}
InlineCompletionList2.create = create;
})(InlineCompletionList || (exports3.InlineCompletionList = InlineCompletionList = {}));
var InlineCompletionTriggerKind;
(function(InlineCompletionTriggerKind2) {
InlineCompletionTriggerKind2.Invoked = 0;
InlineCompletionTriggerKind2.Automatic = 1;
})(InlineCompletionTriggerKind || (exports3.InlineCompletionTriggerKind = InlineCompletionTriggerKind = {}));
var SelectedCompletionInfo;
(function(SelectedCompletionInfo2) {
function create(range, text) {
return { range, text };
}
SelectedCompletionInfo2.create = create;
})(SelectedCompletionInfo || (exports3.SelectedCompletionInfo = SelectedCompletionInfo = {}));
var InlineCompletionContext;
(function(InlineCompletionContext2) {
function create(triggerKind, selectedCompletionInfo) {
return { triggerKind, selectedCompletionInfo };
}
InlineCompletionContext2.create = create;
})(InlineCompletionContext || (exports3.InlineCompletionContext = InlineCompletionContext = {}));
var WorkspaceFolder;
(function(WorkspaceFolder2) {
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
}
WorkspaceFolder2.is = is;
})(WorkspaceFolder || (exports3.WorkspaceFolder = WorkspaceFolder = {}));
exports3.EOL = ["\n", "\r\n", "\r"];
var TextDocument;
(function(TextDocument2) {
function create(uri, languageId, version, content) {
return new FullTextDocument(uri, languageId, version, content);
}
TextDocument2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
}
TextDocument2.is = is;
function applyEdits(document, edits) {
var text = document.getText();
var sortedEdits = mergeSort(edits, function(a, b) {
var diff = a.range.start.line - b.range.start.line;
if (diff === 0) {
return a.range.start.character - b.range.start.character;
}
return diff;
});
var lastModifiedOffset = text.length;
for (var i = sortedEdits.length - 1; i >= 0; i--) {
var e = sortedEdits[i];
var startOffset = document.offsetAt(e.range.start);
var endOffset = document.offsetAt(e.range.end);
if (endOffset <= lastModifiedOffset) {
text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
} else {
throw new Error("Overlapping edit");
}
lastModifiedOffset = startOffset;
}
return text;
}
TextDocument2.applyEdits = applyEdits;
function mergeSort(data, compare) {
if (data.length <= 1) {
return data;
}
var p = data.length / 2 | 0;
var left = data.slice(0, p);
var right = data.slice(p);
mergeSort(left, compare);
mergeSort(right, compare);
var leftIdx = 0;
var rightIdx = 0;
var i = 0;
while (leftIdx < left.length && rightIdx < right.length) {
var ret = compare(left[leftIdx], right[rightIdx]);
if (ret <= 0) {
data[i++] = left[leftIdx++];
} else {
data[i++] = right[rightIdx++];
}
}
while (leftIdx < left.length) {
data[i++] = left[leftIdx++];
}
while (rightIdx < right.length) {
data[i++] = right[rightIdx++];
}
return data;
}
})(TextDocument || (exports3.TextDocument = TextDocument = {}));
var FullTextDocument = (
/** @class */
(function() {
function FullTextDocument2(uri, languageId, version, content) {
this._uri = uri;
this._languageId = languageId;
this._version = version;
this._content = content;
this._lineOffsets = void 0;
}
Object.defineProperty(FullTextDocument2.prototype, "uri", {
get: function() {
return this._uri;
},
enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "languageId", {
get: function() {
return this._languageId;
},
enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "version", {
get: function() {
return this._version;
},
enumerable: false,
configurable: true
});
FullTextDocument2.prototype.getText = function(range) {
if (range) {
var start = this.offsetAt(range.start);
var end = this.offsetAt(range.end);
return this._content.substring(start, end);
}
return this._content;
};
FullTextDocument2.prototype.update = function(event, version) {
this._content = event.text;
this._version = version;
this._lineOffsets = void 0;
};
FullTextDocument2.prototype.getLineOffsets = function() {
if (this._lineOffsets === void 0) {
var lineOffsets = [];
var text = this._content;
var isLineStart = true;
for (var i = 0; i < text.length; i++) {
if (isLineStart) {
lineOffsets.push(i);
isLineStart = false;
}
var ch = text.charAt(i);
isLineStart = ch === "\r" || ch === "\n";
if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
i++;
}
}
if (isLineStart && text.length > 0) {
lineOffsets.push(text.length);
}
this._lineOffsets = lineOffsets;
}
return this._lineOffsets;
};
FullTextDocument2.prototype.positionAt = function(offset) {
offset = Math.max(Math.min(offset, this._content.length), 0);
var lineOffsets = this.getLineOffsets();
var low = 0, high = lineOffsets.length;
if (high === 0) {
return Position3.create(0, offset);
}
while (low < high) {
var mid = Math.floor((low + high) / 2);
if (lineOffsets[mid] > offset) {
high = mid;
} else {
low = mid + 1;
}
}
var line = low - 1;
return Position3.create(line, offset - lineOffsets[line]);
};
FullTextDocument2.prototype.offsetAt = function(position) {
var lineOffsets = this.getLineOffsets();
if (position.line >= lineOffsets.length) {
return this._content.length;
} else if (position.line < 0) {
return 0;
}
var lineOffset = lineOffsets[position.line];
var nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
};
Object.defineProperty(FullTextDocument2.prototype, "lineCount", {
get: function() {
return this.getLineOffsets().length;
},
enumerable: false,
configurable: true
});
return FullTextDocument2;
})()
);
var Is;
(function(Is2) {
var toString = Object.prototype.toString;
function defined(value) {
return typeof value !== "undefined";
}
Is2.defined = defined;
function undefined2(value) {
return typeof value === "undefined";
}
Is2.undefined = undefined2;
function boolean(value) {
return value === true || value === false;
}
Is2.boolean = boolean;
function string(value) {
return toString.call(value) === "[object String]";
}
Is2.string = string;
function number(value) {
return toString.call(value) === "[object Number]";
}
Is2.number = number;
function numberRange(value, min, max) {
return toString.call(value) === "[object Number]" && min <= value && value <= max;
}
Is2.numberRange = numberRange;
function integer3(value) {
return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
}
Is2.integer = integer3;
function uinteger2(value) {
return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
}
Is2.uinteger = uinteger2;
function func(value) {
return toString.call(value) === "[object Function]";
}
Is2.func = func;
function objectLiteral(value) {
return value !== null && typeof value === "object";
}
Is2.objectLiteral = objectLiteral;
function typedArray(value, check) {
return Array.isArray(value) && value.every(check);
}
Is2.typedArray = typedArray;
})(Is || (Is = {}));
});
}
});
// node_modules/vscode-languageserver-protocol/lib/common/messages.js
var require_messages2 = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/messages.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProtocolNotificationType = exports2.ProtocolNotificationType0 = exports2.ProtocolRequestType = exports2.ProtocolRequestType0 = exports2.RegistrationType = exports2.MessageDirection = void 0;
var vscode_jsonrpc_1 = require_main();
var MessageDirection;
(function(MessageDirection2) {
MessageDirection2["clientToServer"] = "clientToServer";
MessageDirection2["serverToClient"] = "serverToClient";
MessageDirection2["both"] = "both";
})(MessageDirection || (exports2.MessageDirection = MessageDirection = {}));
var RegistrationType = class {
constructor(method) {
this.method = method;
}
};
exports2.RegistrationType = RegistrationType;
var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
constructor(method) {
super(method);
}
};
exports2.ProtocolRequestType0 = ProtocolRequestType0;
var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
constructor(method) {
super(method, vscode_jsonrpc_1.ParameterStructures.byName);
}
};
exports2.ProtocolRequestType = ProtocolRequestType;
var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
constructor(method) {
super(method);
}
};
exports2.ProtocolNotificationType0 = ProtocolNotificationType0;
var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
constructor(method) {
super(method, vscode_jsonrpc_1.ParameterStructures.byName);
}
};
exports2.ProtocolNotificationType = ProtocolNotificationType;
}
});
// node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
var require_is3 = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/utils/is.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.objectLiteral = exports2.typedArray = exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
function boolean(value) {
return value === true || value === false;
}
exports2.boolean = boolean;
function string(value) {
return typeof value === "string" || value instanceof String;
}
exports2.string = string;
function number(value) {
return typeof value === "number" || value instanceof Number;
}
exports2.number = number;
function error(value) {
return value instanceof Error;
}
exports2.error = error;
function func(value) {
return typeof value === "function";
}
exports2.func = func;
function array(value) {
return Array.isArray(value);
}
exports2.array = array;
function stringArray(value) {
return array(value) && value.every((elem) => string(elem));
}
exports2.stringArray = stringArray;
function typedArray(value, check) {
return Array.isArray(value) && value.every(check);
}
exports2.typedArray = typedArray;
function objectLiteral(value) {
return value !== null && typeof value === "object";
}
exports2.objectLiteral = objectLiteral;
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
var require_protocol_implementation = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ImplementationRequest = void 0;
var messages_1 = require_messages2();
var ImplementationRequest;
(function(ImplementationRequest2) {
ImplementationRequest2.method = "textDocument/implementation";
ImplementationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
})(ImplementationRequest || (exports2.ImplementationRequest = ImplementationRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
var require_protocol_typeDefinition = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TypeDefinitionRequest = void 0;
var messages_1 = require_messages2();
var TypeDefinitionRequest;
(function(TypeDefinitionRequest2) {
TypeDefinitionRequest2.method = "textDocument/typeDefinition";
TypeDefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
})(TypeDefinitionRequest || (exports2.TypeDefinitionRequest = TypeDefinitionRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js
var require_protocol_workspaceFolder = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = void 0;
var messages_1 = require_messages2();
var WorkspaceFoldersRequest;
(function(WorkspaceFoldersRequest2) {
WorkspaceFoldersRequest2.method = "workspace/workspaceFolders";
WorkspaceFoldersRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0(WorkspaceFoldersRequest2.method);
})(WorkspaceFoldersRequest || (exports2.WorkspaceFoldersRequest = WorkspaceFoldersRequest = {}));
var DidChangeWorkspaceFoldersNotification;
(function(DidChangeWorkspaceFoldersNotification2) {
DidChangeWorkspaceFoldersNotification2.method = "workspace/didChangeWorkspaceFolders";
DidChangeWorkspaceFoldersNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWorkspaceFoldersNotification2.method);
})(DidChangeWorkspaceFoldersNotification || (exports2.DidChangeWorkspaceFoldersNotification = DidChangeWorkspaceFoldersNotification = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
var require_protocol_configuration = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ConfigurationRequest = void 0;
var messages_1 = require_messages2();
var ConfigurationRequest;
(function(ConfigurationRequest2) {
ConfigurationRequest2.method = "workspace/configuration";
ConfigurationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
ConfigurationRequest2.type = new messages_1.ProtocolRequestType(ConfigurationRequest2.method);
})(ConfigurationRequest || (exports2.ConfigurationRequest = ConfigurationRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
var require_protocol_colorProvider = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ColorPresentationRequest = exports2.DocumentColorRequest = void 0;
var messages_1 = require_messages2();
var DocumentColorRequest;
(function(DocumentColorRequest2) {
DocumentColorRequest2.method = "textDocument/documentColor";
DocumentColorRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
})(DocumentColorRequest || (exports2.DocumentColorRequest = DocumentColorRequest = {}));
var ColorPresentationRequest;
(function(ColorPresentationRequest2) {
ColorPresentationRequest2.method = "textDocument/colorPresentation";
ColorPresentationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
ColorPresentationRequest2.type = new messages_1.ProtocolRequestType(ColorPresentationRequest2.method);
})(ColorPresentationRequest || (exports2.ColorPresentationRequest = ColorPresentationRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
var require_protocol_foldingRange = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.FoldingRangeRefreshRequest = exports2.FoldingRangeRequest = void 0;
var messages_1 = require_messages2();
var FoldingRangeRequest;
(function(FoldingRangeRequest2) {
FoldingRangeRequest2.method = "textDocument/foldingRange";
FoldingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
})(FoldingRangeRequest || (exports2.FoldingRangeRequest = FoldingRangeRequest = {}));
var FoldingRangeRefreshRequest;
(function(FoldingRangeRefreshRequest2) {
FoldingRangeRefreshRequest2.method = `workspace/foldingRange/refresh`;
FoldingRangeRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
FoldingRangeRefreshRequest2.type = new messages_1.ProtocolRequestType0(FoldingRangeRefreshRequest2.method);
})(FoldingRangeRefreshRequest || (exports2.FoldingRangeRefreshRequest = FoldingRangeRefreshRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
var require_protocol_declaration = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DeclarationRequest = void 0;
var messages_1 = require_messages2();
var DeclarationRequest;
(function(DeclarationRequest2) {
DeclarationRequest2.method = "textDocument/declaration";
DeclarationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
})(DeclarationRequest || (exports2.DeclarationRequest = DeclarationRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
var require_protocol_selectionRange = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SelectionRangeRequest = void 0;
var messages_1 = require_messages2();
var SelectionRangeRequest;
(function(SelectionRangeRequest2) {
SelectionRangeRequest2.method = "textDocument/selectionRange";
SelectionRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
})(SelectionRangeRequest || (exports2.SelectionRangeRequest = SelectionRangeRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
var require_protocol_progress = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = void 0;
var vscode_jsonrpc_1 = require_main();
var messages_1 = require_messages2();
var WorkDoneProgress;
(function(WorkDoneProgress2) {
WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
function is(value) {
return value === WorkDoneProgress2.type;
}
WorkDoneProgress2.is = is;
})(WorkDoneProgress || (exports2.WorkDoneProgress = WorkDoneProgress = {}));
var WorkDoneProgressCreateRequest;
(function(WorkDoneProgressCreateRequest2) {
WorkDoneProgressCreateRequest2.method = "window/workDoneProgress/create";
WorkDoneProgressCreateRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest2.method);
})(WorkDoneProgressCreateRequest || (exports2.WorkDoneProgressCreateRequest = WorkDoneProgressCreateRequest = {}));
var WorkDoneProgressCancelNotification;
(function(WorkDoneProgressCancelNotification2) {
WorkDoneProgressCancelNotification2.method = "window/workDoneProgress/cancel";
WorkDoneProgressCancelNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification2.method);
})(WorkDoneProgressCancelNotification || (exports2.WorkDoneProgressCancelNotification = WorkDoneProgressCancelNotification = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
var require_protocol_callHierarchy = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.CallHierarchyPrepareRequest = void 0;
var messages_1 = require_messages2();
var CallHierarchyPrepareRequest;
(function(CallHierarchyPrepareRequest2) {
CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
CallHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
})(CallHierarchyPrepareRequest || (exports2.CallHierarchyPrepareRequest = CallHierarchyPrepareRequest = {}));
var CallHierarchyIncomingCallsRequest;
(function(CallHierarchyIncomingCallsRequest2) {
CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
CallHierarchyIncomingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
})(CallHierarchyIncomingCallsRequest || (exports2.CallHierarchyIncomingCallsRequest = CallHierarchyIncomingCallsRequest = {}));
var CallHierarchyOutgoingCallsRequest;
(function(CallHierarchyOutgoingCallsRequest2) {
CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
CallHierarchyOutgoingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
})(CallHierarchyOutgoingCallsRequest || (exports2.CallHierarchyOutgoingCallsRequest = CallHierarchyOutgoingCallsRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js
var require_protocol_semanticTokens = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.SemanticTokensRegistrationType = exports2.TokenFormat = void 0;
var messages_1 = require_messages2();
var TokenFormat;
(function(TokenFormat2) {
TokenFormat2.Relative = "relative";
})(TokenFormat || (exports2.TokenFormat = TokenFormat = {}));
var SemanticTokensRegistrationType;
(function(SemanticTokensRegistrationType2) {
SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
})(SemanticTokensRegistrationType || (exports2.SemanticTokensRegistrationType = SemanticTokensRegistrationType = {}));
var SemanticTokensRequest;
(function(SemanticTokensRequest2) {
SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
SemanticTokensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
SemanticTokensRequest2.registrationMethod = SemanticTokensRegistrationType.method;
})(SemanticTokensRequest || (exports2.SemanticTokensRequest = SemanticTokensRequest = {}));
var SemanticTokensDeltaRequest;
(function(SemanticTokensDeltaRequest2) {
SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
SemanticTokensDeltaRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
SemanticTokensDeltaRequest2.registrationMethod = SemanticTokensRegistrationType.method;
})(SemanticTokensDeltaRequest || (exports2.SemanticTokensDeltaRequest = SemanticTokensDeltaRequest = {}));
var SemanticTokensRangeRequest;
(function(SemanticTokensRangeRequest2) {
SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
SemanticTokensRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
SemanticTokensRangeRequest2.registrationMethod = SemanticTokensRegistrationType.method;
})(SemanticTokensRangeRequest || (exports2.SemanticTokensRangeRequest = SemanticTokensRangeRequest = {}));
var SemanticTokensRefreshRequest;
(function(SemanticTokensRefreshRequest2) {
SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
SemanticTokensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
})(SemanticTokensRefreshRequest || (exports2.SemanticTokensRefreshRequest = SemanticTokensRefreshRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
var require_protocol_showDocument = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ShowDocumentRequest = void 0;
var messages_1 = require_messages2();
var ShowDocumentRequest;
(function(ShowDocumentRequest2) {
ShowDocumentRequest2.method = "window/showDocument";
ShowDocumentRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
})(ShowDocumentRequest || (exports2.ShowDocumentRequest = ShowDocumentRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
var require_protocol_linkedEditingRange = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.LinkedEditingRangeRequest = void 0;
var messages_1 = require_messages2();
var LinkedEditingRangeRequest;
(function(LinkedEditingRangeRequest2) {
LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
LinkedEditingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
})(LinkedEditingRangeRequest || (exports2.LinkedEditingRangeRequest = LinkedEditingRangeRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
var require_protocol_fileOperations = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.DidRenameFilesNotification = exports2.WillRenameFilesRequest = exports2.DidCreateFilesNotification = exports2.WillCreateFilesRequest = exports2.FileOperationPatternKind = void 0;
var messages_1 = require_messages2();
var FileOperationPatternKind;
(function(FileOperationPatternKind2) {
FileOperationPatternKind2.file = "file";
FileOperationPatternKind2.folder = "folder";
})(FileOperationPatternKind || (exports2.FileOperationPatternKind = FileOperationPatternKind = {}));
var WillCreateFilesRequest;
(function(WillCreateFilesRequest2) {
WillCreateFilesRequest2.method = "workspace/willCreateFiles";
WillCreateFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
})(WillCreateFilesRequest || (exports2.WillCreateFilesRequest = WillCreateFilesRequest = {}));
var DidCreateFilesNotification;
(function(DidCreateFilesNotification2) {
DidCreateFilesNotification2.method = "workspace/didCreateFiles";
DidCreateFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
})(DidCreateFilesNotification || (exports2.DidCreateFilesNotification = DidCreateFilesNotification = {}));
var WillRenameFilesRequest;
(function(WillRenameFilesRequest2) {
WillRenameFilesRequest2.method = "workspace/willRenameFiles";
WillRenameFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
})(WillRenameFilesRequest || (exports2.WillRenameFilesRequest = WillRenameFilesRequest = {}));
var DidRenameFilesNotification;
(function(DidRenameFilesNotification2) {
DidRenameFilesNotification2.method = "workspace/didRenameFiles";
DidRenameFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
})(DidRenameFilesNotification || (exports2.DidRenameFilesNotification = DidRenameFilesNotification = {}));
var DidDeleteFilesNotification;
(function(DidDeleteFilesNotification2) {
DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
DidDeleteFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
})(DidDeleteFilesNotification || (exports2.DidDeleteFilesNotification = DidDeleteFilesNotification = {}));
var WillDeleteFilesRequest;
(function(WillDeleteFilesRequest2) {
WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
WillDeleteFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
})(WillDeleteFilesRequest || (exports2.WillDeleteFilesRequest = WillDeleteFilesRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
var require_protocol_moniker = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = void 0;
var messages_1 = require_messages2();
var UniquenessLevel;
(function(UniquenessLevel2) {
UniquenessLevel2.document = "document";
UniquenessLevel2.project = "project";
UniquenessLevel2.group = "group";
UniquenessLevel2.scheme = "scheme";
UniquenessLevel2.global = "global";
})(UniquenessLevel || (exports2.UniquenessLevel = UniquenessLevel = {}));
var MonikerKind;
(function(MonikerKind2) {
MonikerKind2.$import = "import";
MonikerKind2.$export = "export";
MonikerKind2.local = "local";
})(MonikerKind || (exports2.MonikerKind = MonikerKind = {}));
var MonikerRequest;
(function(MonikerRequest2) {
MonikerRequest2.method = "textDocument/moniker";
MonikerRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
})(MonikerRequest || (exports2.MonikerRequest = MonikerRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js
var require_protocol_typeHierarchy = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TypeHierarchySubtypesRequest = exports2.TypeHierarchySupertypesRequest = exports2.TypeHierarchyPrepareRequest = void 0;
var messages_1 = require_messages2();
var TypeHierarchyPrepareRequest;
(function(TypeHierarchyPrepareRequest2) {
TypeHierarchyPrepareRequest2.method = "textDocument/prepareTypeHierarchy";
TypeHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
TypeHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchyPrepareRequest2.method);
})(TypeHierarchyPrepareRequest || (exports2.TypeHierarchyPrepareRequest = TypeHierarchyPrepareRequest = {}));
var TypeHierarchySupertypesRequest;
(function(TypeHierarchySupertypesRequest2) {
TypeHierarchySupertypesRequest2.method = "typeHierarchy/supertypes";
TypeHierarchySupertypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
TypeHierarchySupertypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySupertypesRequest2.method);
})(TypeHierarchySupertypesRequest || (exports2.TypeHierarchySupertypesRequest = TypeHierarchySupertypesRequest = {}));
var TypeHierarchySubtypesRequest;
(function(TypeHierarchySubtypesRequest2) {
TypeHierarchySubtypesRequest2.method = "typeHierarchy/subtypes";
TypeHierarchySubtypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
TypeHierarchySubtypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySubtypesRequest2.method);
})(TypeHierarchySubtypesRequest || (exports2.TypeHierarchySubtypesRequest = TypeHierarchySubtypesRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js
var require_protocol_inlineValue = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlineValueRefreshRequest = exports2.InlineValueRequest = void 0;
var messages_1 = require_messages2();
var InlineValueRequest;
(function(InlineValueRequest2) {
InlineValueRequest2.method = "textDocument/inlineValue";
InlineValueRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
InlineValueRequest2.type = new messages_1.ProtocolRequestType(InlineValueRequest2.method);
})(InlineValueRequest || (exports2.InlineValueRequest = InlineValueRequest = {}));
var InlineValueRefreshRequest;
(function(InlineValueRefreshRequest2) {
InlineValueRefreshRequest2.method = `workspace/inlineValue/refresh`;
InlineValueRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
InlineValueRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlineValueRefreshRequest2.method);
})(InlineValueRefreshRequest || (exports2.InlineValueRefreshRequest = InlineValueRefreshRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js
var require_protocol_inlayHint = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlayHintRefreshRequest = exports2.InlayHintResolveRequest = exports2.InlayHintRequest = void 0;
var messages_1 = require_messages2();
var InlayHintRequest;
(function(InlayHintRequest2) {
InlayHintRequest2.method = "textDocument/inlayHint";
InlayHintRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
InlayHintRequest2.type = new messages_1.ProtocolRequestType(InlayHintRequest2.method);
})(InlayHintRequest || (exports2.InlayHintRequest = InlayHintRequest = {}));
var InlayHintResolveRequest;
(function(InlayHintResolveRequest2) {
InlayHintResolveRequest2.method = "inlayHint/resolve";
InlayHintResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
InlayHintResolveRequest2.type = new messages_1.ProtocolRequestType(InlayHintResolveRequest2.method);
})(InlayHintResolveRequest || (exports2.InlayHintResolveRequest = InlayHintResolveRequest = {}));
var InlayHintRefreshRequest;
(function(InlayHintRefreshRequest2) {
InlayHintRefreshRequest2.method = `workspace/inlayHint/refresh`;
InlayHintRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
InlayHintRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlayHintRefreshRequest2.method);
})(InlayHintRefreshRequest || (exports2.InlayHintRefreshRequest = InlayHintRefreshRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js
var require_protocol_diagnostic = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagnosticRefreshRequest = exports2.WorkspaceDiagnosticRequest = exports2.DocumentDiagnosticRequest = exports2.DocumentDiagnosticReportKind = exports2.DiagnosticServerCancellationData = void 0;
var vscode_jsonrpc_1 = require_main();
var Is = require_is3();
var messages_1 = require_messages2();
var DiagnosticServerCancellationData;
(function(DiagnosticServerCancellationData2) {
function is(value) {
const candidate = value;
return candidate && Is.boolean(candidate.retriggerRequest);
}
DiagnosticServerCancellationData2.is = is;
})(DiagnosticServerCancellationData || (exports2.DiagnosticServerCancellationData = DiagnosticServerCancellationData = {}));
var DocumentDiagnosticReportKind;
(function(DocumentDiagnosticReportKind2) {
DocumentDiagnosticReportKind2.Full = "full";
DocumentDiagnosticReportKind2.Unchanged = "unchanged";
})(DocumentDiagnosticReportKind || (exports2.DocumentDiagnosticReportKind = DocumentDiagnosticReportKind = {}));
var DocumentDiagnosticRequest;
(function(DocumentDiagnosticRequest2) {
DocumentDiagnosticRequest2.method = "textDocument/diagnostic";
DocumentDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentDiagnosticRequest2.type = new messages_1.ProtocolRequestType(DocumentDiagnosticRequest2.method);
DocumentDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
})(DocumentDiagnosticRequest || (exports2.DocumentDiagnosticRequest = DocumentDiagnosticRequest = {}));
var WorkspaceDiagnosticRequest;
(function(WorkspaceDiagnosticRequest2) {
WorkspaceDiagnosticRequest2.method = "workspace/diagnostic";
WorkspaceDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WorkspaceDiagnosticRequest2.type = new messages_1.ProtocolRequestType(WorkspaceDiagnosticRequest2.method);
WorkspaceDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
})(WorkspaceDiagnosticRequest || (exports2.WorkspaceDiagnosticRequest = WorkspaceDiagnosticRequest = {}));
var DiagnosticRefreshRequest;
(function(DiagnosticRefreshRequest2) {
DiagnosticRefreshRequest2.method = `workspace/diagnostic/refresh`;
DiagnosticRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
DiagnosticRefreshRequest2.type = new messages_1.ProtocolRequestType0(DiagnosticRefreshRequest2.method);
})(DiagnosticRefreshRequest || (exports2.DiagnosticRefreshRequest = DiagnosticRefreshRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js
var require_protocol_notebook = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DidCloseNotebookDocumentNotification = exports2.DidSaveNotebookDocumentNotification = exports2.DidChangeNotebookDocumentNotification = exports2.NotebookCellArrayChange = exports2.DidOpenNotebookDocumentNotification = exports2.NotebookDocumentSyncRegistrationType = exports2.NotebookDocument = exports2.NotebookCell = exports2.ExecutionSummary = exports2.NotebookCellKind = void 0;
var vscode_languageserver_types_1 = require_main2();
var Is = require_is3();
var messages_1 = require_messages2();
var NotebookCellKind;
(function(NotebookCellKind2) {
NotebookCellKind2.Markup = 1;
NotebookCellKind2.Code = 2;
function is(value) {
return value === 1 || value === 2;
}
NotebookCellKind2.is = is;
})(NotebookCellKind || (exports2.NotebookCellKind = NotebookCellKind = {}));
var ExecutionSummary;
(function(ExecutionSummary2) {
function create(executionOrder, success) {
const result = { executionOrder };
if (success === true || success === false) {
result.success = success;
}
return result;
}
ExecutionSummary2.create = create;
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.executionOrder) && (candidate.success === void 0 || Is.boolean(candidate.success));
}
ExecutionSummary2.is = is;
function equals(one, other) {
if (one === other) {
return true;
}
if (one === null || one === void 0 || other === null || other === void 0) {
return false;
}
return one.executionOrder === other.executionOrder && one.success === other.success;
}
ExecutionSummary2.equals = equals;
})(ExecutionSummary || (exports2.ExecutionSummary = ExecutionSummary = {}));
var NotebookCell;
(function(NotebookCell2) {
function create(kind, document) {
return { kind, document };
}
NotebookCell2.create = create;
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && NotebookCellKind.is(candidate.kind) && vscode_languageserver_types_1.DocumentUri.is(candidate.document) && (candidate.metadata === void 0 || Is.objectLiteral(candidate.metadata));
}
NotebookCell2.is = is;
function diff(one, two) {
const result = /* @__PURE__ */ new Set();
if (one.document !== two.document) {
result.add("document");
}
if (one.kind !== two.kind) {
result.add("kind");
}
if (one.executionSummary !== two.executionSummary) {
result.add("executionSummary");
}
if ((one.metadata !== void 0 || two.metadata !== void 0) && !equalsMetadata(one.metadata, two.metadata)) {
result.add("metadata");
}
if ((one.executionSummary !== void 0 || two.executionSummary !== void 0) && !ExecutionSummary.equals(one.executionSummary, two.executionSummary)) {
result.add("executionSummary");
}
return result;
}
NotebookCell2.diff = diff;
function equalsMetadata(one, other) {
if (one === other) {
return true;
}
if (one === null || one === void 0 || other === null || other === void 0) {
return false;
}
if (typeof one !== typeof other) {
return false;
}
if (typeof one !== "object") {
return false;
}
const oneArray = Array.isArray(one);
const otherArray = Array.isArray(other);
if (oneArray !== otherArray) {
return false;
}
if (oneArray && otherArray) {
if (one.length !== other.length) {
return false;
}
for (let i = 0; i < one.length; i++) {
if (!equalsMetadata(one[i], other[i])) {
return false;
}
}
}
if (Is.objectLiteral(one) && Is.objectLiteral(other)) {
const oneKeys = Object.keys(one);
const otherKeys = Object.keys(other);
if (oneKeys.length !== otherKeys.length) {
return false;
}
oneKeys.sort();
otherKeys.sort();
if (!equalsMetadata(oneKeys, otherKeys)) {
return false;
}
for (let i = 0; i < oneKeys.length; i++) {
const prop = oneKeys[i];
if (!equalsMetadata(one[prop], other[prop])) {
return false;
}
}
}
return true;
}
})(NotebookCell || (exports2.NotebookCell = NotebookCell = {}));
var NotebookDocument;
(function(NotebookDocument2) {
function create(uri, notebookType, version, cells) {
return { uri, notebookType, version, cells };
}
NotebookDocument2.create = create;
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.uri) && vscode_languageserver_types_1.integer.is(candidate.version) && Is.typedArray(candidate.cells, NotebookCell.is);
}
NotebookDocument2.is = is;
})(NotebookDocument || (exports2.NotebookDocument = NotebookDocument = {}));
var NotebookDocumentSyncRegistrationType;
(function(NotebookDocumentSyncRegistrationType2) {
NotebookDocumentSyncRegistrationType2.method = "notebookDocument/sync";
NotebookDocumentSyncRegistrationType2.messageDirection = messages_1.MessageDirection.clientToServer;
NotebookDocumentSyncRegistrationType2.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType2.method);
})(NotebookDocumentSyncRegistrationType || (exports2.NotebookDocumentSyncRegistrationType = NotebookDocumentSyncRegistrationType = {}));
var DidOpenNotebookDocumentNotification;
(function(DidOpenNotebookDocumentNotification2) {
DidOpenNotebookDocumentNotification2.method = "notebookDocument/didOpen";
DidOpenNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidOpenNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification2.method);
DidOpenNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
})(DidOpenNotebookDocumentNotification || (exports2.DidOpenNotebookDocumentNotification = DidOpenNotebookDocumentNotification = {}));
var NotebookCellArrayChange;
(function(NotebookCellArrayChange2) {
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.start) && vscode_languageserver_types_1.uinteger.is(candidate.deleteCount) && (candidate.cells === void 0 || Is.typedArray(candidate.cells, NotebookCell.is));
}
NotebookCellArrayChange2.is = is;
function create(start, deleteCount, cells) {
const result = { start, deleteCount };
if (cells !== void 0) {
result.cells = cells;
}
return result;
}
NotebookCellArrayChange2.create = create;
})(NotebookCellArrayChange || (exports2.NotebookCellArrayChange = NotebookCellArrayChange = {}));
var DidChangeNotebookDocumentNotification;
(function(DidChangeNotebookDocumentNotification2) {
DidChangeNotebookDocumentNotification2.method = "notebookDocument/didChange";
DidChangeNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidChangeNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification2.method);
DidChangeNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
})(DidChangeNotebookDocumentNotification || (exports2.DidChangeNotebookDocumentNotification = DidChangeNotebookDocumentNotification = {}));
var DidSaveNotebookDocumentNotification;
(function(DidSaveNotebookDocumentNotification2) {
DidSaveNotebookDocumentNotification2.method = "notebookDocument/didSave";
DidSaveNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidSaveNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification2.method);
DidSaveNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
})(DidSaveNotebookDocumentNotification || (exports2.DidSaveNotebookDocumentNotification = DidSaveNotebookDocumentNotification = {}));
var DidCloseNotebookDocumentNotification;
(function(DidCloseNotebookDocumentNotification2) {
DidCloseNotebookDocumentNotification2.method = "notebookDocument/didClose";
DidCloseNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidCloseNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification2.method);
DidCloseNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
})(DidCloseNotebookDocumentNotification || (exports2.DidCloseNotebookDocumentNotification = DidCloseNotebookDocumentNotification = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js
var require_protocol_inlineCompletion = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlineCompletionRequest = void 0;
var messages_1 = require_messages2();
var InlineCompletionRequest;
(function(InlineCompletionRequest2) {
InlineCompletionRequest2.method = "textDocument/inlineCompletion";
InlineCompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
InlineCompletionRequest2.type = new messages_1.ProtocolRequestType(InlineCompletionRequest2.method);
})(InlineCompletionRequest || (exports2.InlineCompletionRequest = InlineCompletionRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/protocol.js
var require_protocol = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/protocol.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WorkspaceSymbolRequest = exports2.CodeActionResolveRequest = exports2.CodeActionRequest = exports2.DocumentSymbolRequest = exports2.DocumentHighlightRequest = exports2.ReferencesRequest = exports2.DefinitionRequest = exports2.SignatureHelpRequest = exports2.SignatureHelpTriggerKind = exports2.HoverRequest = exports2.CompletionResolveRequest = exports2.CompletionRequest = exports2.CompletionTriggerKind = exports2.PublishDiagnosticsNotification = exports2.WatchKind = exports2.RelativePattern = exports2.FileChangeType = exports2.DidChangeWatchedFilesNotification = exports2.WillSaveTextDocumentWaitUntilRequest = exports2.WillSaveTextDocumentNotification = exports2.TextDocumentSaveReason = exports2.DidSaveTextDocumentNotification = exports2.DidCloseTextDocumentNotification = exports2.DidChangeTextDocumentNotification = exports2.TextDocumentContentChangeEvent = exports2.DidOpenTextDocumentNotification = exports2.TextDocumentSyncKind = exports2.TelemetryEventNotification = exports2.LogMessageNotification = exports2.ShowMessageRequest = exports2.ShowMessageNotification = exports2.MessageType = exports2.DidChangeConfigurationNotification = exports2.ExitNotification = exports2.ShutdownRequest = exports2.InitializedNotification = exports2.InitializeErrorCodes = exports2.InitializeRequest = exports2.WorkDoneProgressOptions = exports2.TextDocumentRegistrationOptions = exports2.StaticRegistrationOptions = exports2.PositionEncodingKind = exports2.FailureHandlingKind = exports2.ResourceOperationKind = exports2.UnregistrationRequest = exports2.RegistrationRequest = exports2.DocumentSelector = exports2.NotebookCellTextDocumentFilter = exports2.NotebookDocumentFilter = exports2.TextDocumentFilter = void 0;
exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.WillRenameFilesRequest = exports2.DidRenameFilesNotification = exports2.WillCreateFilesRequest = exports2.DidCreateFilesNotification = exports2.FileOperationPatternKind = exports2.LinkedEditingRangeRequest = exports2.ShowDocumentRequest = exports2.SemanticTokensRegistrationType = exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.TokenFormat = exports2.CallHierarchyPrepareRequest = exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = exports2.SelectionRangeRequest = exports2.DeclarationRequest = exports2.FoldingRangeRefreshRequest = exports2.FoldingRangeRequest = exports2.ColorPresentationRequest = exports2.DocumentColorRequest = exports2.ConfigurationRequest = exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = exports2.TypeDefinitionRequest = exports2.ImplementationRequest = exports2.ApplyWorkspaceEditRequest = exports2.ExecuteCommandRequest = exports2.PrepareRenameRequest = exports2.RenameRequest = exports2.PrepareSupportDefaultBehavior = exports2.DocumentOnTypeFormattingRequest = exports2.DocumentRangesFormattingRequest = exports2.DocumentRangeFormattingRequest = exports2.DocumentFormattingRequest = exports2.DocumentLinkResolveRequest = exports2.DocumentLinkRequest = exports2.CodeLensRefreshRequest = exports2.CodeLensResolveRequest = exports2.CodeLensRequest = exports2.WorkspaceSymbolResolveRequest = void 0;
exports2.InlineCompletionRequest = exports2.DidCloseNotebookDocumentNotification = exports2.DidSaveNotebookDocumentNotification = exports2.DidChangeNotebookDocumentNotification = exports2.NotebookCellArrayChange = exports2.DidOpenNotebookDocumentNotification = exports2.NotebookDocumentSyncRegistrationType = exports2.NotebookDocument = exports2.NotebookCell = exports2.ExecutionSummary = exports2.NotebookCellKind = exports2.DiagnosticRefreshRequest = exports2.WorkspaceDiagnosticRequest = exports2.DocumentDiagnosticRequest = exports2.DocumentDiagnosticReportKind = exports2.DiagnosticServerCancellationData = exports2.InlayHintRefreshRequest = exports2.InlayHintResolveRequest = exports2.InlayHintRequest = exports2.InlineValueRefreshRequest = exports2.InlineValueRequest = exports2.TypeHierarchySupertypesRequest = exports2.TypeHierarchySubtypesRequest = exports2.TypeHierarchyPrepareRequest = void 0;
var messages_1 = require_messages2();
var vscode_languageserver_types_1 = require_main2();
var Is = require_is3();
var protocol_implementation_1 = require_protocol_implementation();
Object.defineProperty(exports2, "ImplementationRequest", { enumerable: true, get: function() {
return protocol_implementation_1.ImplementationRequest;
} });
var protocol_typeDefinition_1 = require_protocol_typeDefinition();
Object.defineProperty(exports2, "TypeDefinitionRequest", { enumerable: true, get: function() {
return protocol_typeDefinition_1.TypeDefinitionRequest;
} });
var protocol_workspaceFolder_1 = require_protocol_workspaceFolder();
Object.defineProperty(exports2, "WorkspaceFoldersRequest", { enumerable: true, get: function() {
return protocol_workspaceFolder_1.WorkspaceFoldersRequest;
} });
Object.defineProperty(exports2, "DidChangeWorkspaceFoldersNotification", { enumerable: true, get: function() {
return protocol_workspaceFolder_1.DidChangeWorkspaceFoldersNotification;
} });
var protocol_configuration_1 = require_protocol_configuration();
Object.defineProperty(exports2, "ConfigurationRequest", { enumerable: true, get: function() {
return protocol_configuration_1.ConfigurationRequest;
} });
var protocol_colorProvider_1 = require_protocol_colorProvider();
Object.defineProperty(exports2, "DocumentColorRequest", { enumerable: true, get: function() {
return protocol_colorProvider_1.DocumentColorRequest;
} });
Object.defineProperty(exports2, "ColorPresentationRequest", { enumerable: true, get: function() {
return protocol_colorProvider_1.ColorPresentationRequest;
} });
var protocol_foldingRange_1 = require_protocol_foldingRange();
Object.defineProperty(exports2, "FoldingRangeRequest", { enumerable: true, get: function() {
return protocol_foldingRange_1.FoldingRangeRequest;
} });
Object.defineProperty(exports2, "FoldingRangeRefreshRequest", { enumerable: true, get: function() {
return protocol_foldingRange_1.FoldingRangeRefreshRequest;
} });
var protocol_declaration_1 = require_protocol_declaration();
Object.defineProperty(exports2, "DeclarationRequest", { enumerable: true, get: function() {
return protocol_declaration_1.DeclarationRequest;
} });
var protocol_selectionRange_1 = require_protocol_selectionRange();
Object.defineProperty(exports2, "SelectionRangeRequest", { enumerable: true, get: function() {
return protocol_selectionRange_1.SelectionRangeRequest;
} });
var protocol_progress_1 = require_protocol_progress();
Object.defineProperty(exports2, "WorkDoneProgress", { enumerable: true, get: function() {
return protocol_progress_1.WorkDoneProgress;
} });
Object.defineProperty(exports2, "WorkDoneProgressCreateRequest", { enumerable: true, get: function() {
return protocol_progress_1.WorkDoneProgressCreateRequest;
} });
Object.defineProperty(exports2, "WorkDoneProgressCancelNotification", { enumerable: true, get: function() {
return protocol_progress_1.WorkDoneProgressCancelNotification;
} });
var protocol_callHierarchy_1 = require_protocol_callHierarchy();
Object.defineProperty(exports2, "CallHierarchyIncomingCallsRequest", { enumerable: true, get: function() {
return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest;
} });
Object.defineProperty(exports2, "CallHierarchyOutgoingCallsRequest", { enumerable: true, get: function() {
return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest;
} });
Object.defineProperty(exports2, "CallHierarchyPrepareRequest", { enumerable: true, get: function() {
return protocol_callHierarchy_1.CallHierarchyPrepareRequest;
} });
var protocol_semanticTokens_1 = require_protocol_semanticTokens();
Object.defineProperty(exports2, "TokenFormat", { enumerable: true, get: function() {
return protocol_semanticTokens_1.TokenFormat;
} });
Object.defineProperty(exports2, "SemanticTokensRequest", { enumerable: true, get: function() {
return protocol_semanticTokens_1.SemanticTokensRequest;
} });
Object.defineProperty(exports2, "SemanticTokensDeltaRequest", { enumerable: true, get: function() {
return protocol_semanticTokens_1.SemanticTokensDeltaRequest;
} });
Object.defineProperty(exports2, "SemanticTokensRangeRequest", { enumerable: true, get: function() {
return protocol_semanticTokens_1.SemanticTokensRangeRequest;
} });
Object.defineProperty(exports2, "SemanticTokensRefreshRequest", { enumerable: true, get: function() {
return protocol_semanticTokens_1.SemanticTokensRefreshRequest;
} });
Object.defineProperty(exports2, "SemanticTokensRegistrationType", { enumerable: true, get: function() {
return protocol_semanticTokens_1.SemanticTokensRegistrationType;
} });
var protocol_showDocument_1 = require_protocol_showDocument();
Object.defineProperty(exports2, "ShowDocumentRequest", { enumerable: true, get: function() {
return protocol_showDocument_1.ShowDocumentRequest;
} });
var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange();
Object.defineProperty(exports2, "LinkedEditingRangeRequest", { enumerable: true, get: function() {
return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
} });
var protocol_fileOperations_1 = require_protocol_fileOperations();
Object.defineProperty(exports2, "FileOperationPatternKind", { enumerable: true, get: function() {
return protocol_fileOperations_1.FileOperationPatternKind;
} });
Object.defineProperty(exports2, "DidCreateFilesNotification", { enumerable: true, get: function() {
return protocol_fileOperations_1.DidCreateFilesNotification;
} });
Object.defineProperty(exports2, "WillCreateFilesRequest", { enumerable: true, get: function() {
return protocol_fileOperations_1.WillCreateFilesRequest;
} });
Object.defineProperty(exports2, "DidRenameFilesNotification", { enumerable: true, get: function() {
return protocol_fileOperations_1.DidRenameFilesNotification;
} });
Object.defineProperty(exports2, "WillRenameFilesRequest", { enumerable: true, get: function() {
return protocol_fileOperations_1.WillRenameFilesRequest;
} });
Object.defineProperty(exports2, "DidDeleteFilesNotification", { enumerable: true, get: function() {
return protocol_fileOperations_1.DidDeleteFilesNotification;
} });
Object.defineProperty(exports2, "WillDeleteFilesRequest", { enumerable: true, get: function() {
return protocol_fileOperations_1.WillDeleteFilesRequest;
} });
var protocol_moniker_1 = require_protocol_moniker();
Object.defineProperty(exports2, "UniquenessLevel", { enumerable: true, get: function() {
return protocol_moniker_1.UniquenessLevel;
} });
Object.defineProperty(exports2, "MonikerKind", { enumerable: true, get: function() {
return protocol_moniker_1.MonikerKind;
} });
Object.defineProperty(exports2, "MonikerRequest", { enumerable: true, get: function() {
return protocol_moniker_1.MonikerRequest;
} });
var protocol_typeHierarchy_1 = require_protocol_typeHierarchy();
Object.defineProperty(exports2, "TypeHierarchyPrepareRequest", { enumerable: true, get: function() {
return protocol_typeHierarchy_1.TypeHierarchyPrepareRequest;
} });
Object.defineProperty(exports2, "TypeHierarchySubtypesRequest", { enumerable: true, get: function() {
return protocol_typeHierarchy_1.TypeHierarchySubtypesRequest;
} });
Object.defineProperty(exports2, "TypeHierarchySupertypesRequest", { enumerable: true, get: function() {
return protocol_typeHierarchy_1.TypeHierarchySupertypesRequest;
} });
var protocol_inlineValue_1 = require_protocol_inlineValue();
Object.defineProperty(exports2, "InlineValueRequest", { enumerable: true, get: function() {
return protocol_inlineValue_1.InlineValueRequest;
} });
Object.defineProperty(exports2, "InlineValueRefreshRequest", { enumerable: true, get: function() {
return protocol_inlineValue_1.InlineValueRefreshRequest;
} });
var protocol_inlayHint_1 = require_protocol_inlayHint();
Object.defineProperty(exports2, "InlayHintRequest", { enumerable: true, get: function() {
return protocol_inlayHint_1.InlayHintRequest;
} });
Object.defineProperty(exports2, "InlayHintResolveRequest", { enumerable: true, get: function() {
return protocol_inlayHint_1.InlayHintResolveRequest;
} });
Object.defineProperty(exports2, "InlayHintRefreshRequest", { enumerable: true, get: function() {
return protocol_inlayHint_1.InlayHintRefreshRequest;
} });
var protocol_diagnostic_1 = require_protocol_diagnostic();
Object.defineProperty(exports2, "DiagnosticServerCancellationData", { enumerable: true, get: function() {
return protocol_diagnostic_1.DiagnosticServerCancellationData;
} });
Object.defineProperty(exports2, "DocumentDiagnosticReportKind", { enumerable: true, get: function() {
return protocol_diagnostic_1.DocumentDiagnosticReportKind;
} });
Object.defineProperty(exports2, "DocumentDiagnosticRequest", { enumerable: true, get: function() {
return protocol_diagnostic_1.DocumentDiagnosticRequest;
} });
Object.defineProperty(exports2, "WorkspaceDiagnosticRequest", { enumerable: true, get: function() {
return protocol_diagnostic_1.WorkspaceDiagnosticRequest;
} });
Object.defineProperty(exports2, "DiagnosticRefreshRequest", { enumerable: true, get: function() {
return protocol_diagnostic_1.DiagnosticRefreshRequest;
} });
var protocol_notebook_1 = require_protocol_notebook();
Object.defineProperty(exports2, "NotebookCellKind", { enumerable: true, get: function() {
return protocol_notebook_1.NotebookCellKind;
} });
Object.defineProperty(exports2, "ExecutionSummary", { enumerable: true, get: function() {
return protocol_notebook_1.ExecutionSummary;
} });
Object.defineProperty(exports2, "NotebookCell", { enumerable: true, get: function() {
return protocol_notebook_1.NotebookCell;
} });
Object.defineProperty(exports2, "NotebookDocument", { enumerable: true, get: function() {
return protocol_notebook_1.NotebookDocument;
} });
Object.defineProperty(exports2, "NotebookDocumentSyncRegistrationType", { enumerable: true, get: function() {
return protocol_notebook_1.NotebookDocumentSyncRegistrationType;
} });
Object.defineProperty(exports2, "DidOpenNotebookDocumentNotification", { enumerable: true, get: function() {
return protocol_notebook_1.DidOpenNotebookDocumentNotification;
} });
Object.defineProperty(exports2, "NotebookCellArrayChange", { enumerable: true, get: function() {
return protocol_notebook_1.NotebookCellArrayChange;
} });
Object.defineProperty(exports2, "DidChangeNotebookDocumentNotification", { enumerable: true, get: function() {
return protocol_notebook_1.DidChangeNotebookDocumentNotification;
} });
Object.defineProperty(exports2, "DidSaveNotebookDocumentNotification", { enumerable: true, get: function() {
return protocol_notebook_1.DidSaveNotebookDocumentNotification;
} });
Object.defineProperty(exports2, "DidCloseNotebookDocumentNotification", { enumerable: true, get: function() {
return protocol_notebook_1.DidCloseNotebookDocumentNotification;
} });
var protocol_inlineCompletion_1 = require_protocol_inlineCompletion();
Object.defineProperty(exports2, "InlineCompletionRequest", { enumerable: true, get: function() {
return protocol_inlineCompletion_1.InlineCompletionRequest;
} });
var TextDocumentFilter;
(function(TextDocumentFilter2) {
function is(value) {
const candidate = value;
return Is.string(candidate) || (Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern));
}
TextDocumentFilter2.is = is;
})(TextDocumentFilter || (exports2.TextDocumentFilter = TextDocumentFilter = {}));
var NotebookDocumentFilter;
(function(NotebookDocumentFilter2) {
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && (Is.string(candidate.notebookType) || Is.string(candidate.scheme) || Is.string(candidate.pattern));
}
NotebookDocumentFilter2.is = is;
})(NotebookDocumentFilter || (exports2.NotebookDocumentFilter = NotebookDocumentFilter = {}));
var NotebookCellTextDocumentFilter;
(function(NotebookCellTextDocumentFilter2) {
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && (Is.string(candidate.notebook) || NotebookDocumentFilter.is(candidate.notebook)) && (candidate.language === void 0 || Is.string(candidate.language));
}
NotebookCellTextDocumentFilter2.is = is;
})(NotebookCellTextDocumentFilter || (exports2.NotebookCellTextDocumentFilter = NotebookCellTextDocumentFilter = {}));
var DocumentSelector3;
(function(DocumentSelector4) {
function is(value) {
if (!Array.isArray(value)) {
return false;
}
for (let elem of value) {
if (!Is.string(elem) && !TextDocumentFilter.is(elem) && !NotebookCellTextDocumentFilter.is(elem)) {
return false;
}
}
return true;
}
DocumentSelector4.is = is;
})(DocumentSelector3 || (exports2.DocumentSelector = DocumentSelector3 = {}));
var RegistrationRequest;
(function(RegistrationRequest2) {
RegistrationRequest2.method = "client/registerCapability";
RegistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
RegistrationRequest2.type = new messages_1.ProtocolRequestType(RegistrationRequest2.method);
})(RegistrationRequest || (exports2.RegistrationRequest = RegistrationRequest = {}));
var UnregistrationRequest;
(function(UnregistrationRequest2) {
UnregistrationRequest2.method = "client/unregisterCapability";
UnregistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
UnregistrationRequest2.type = new messages_1.ProtocolRequestType(UnregistrationRequest2.method);
})(UnregistrationRequest || (exports2.UnregistrationRequest = UnregistrationRequest = {}));
var ResourceOperationKind;
(function(ResourceOperationKind2) {
ResourceOperationKind2.Create = "create";
ResourceOperationKind2.Rename = "rename";
ResourceOperationKind2.Delete = "delete";
})(ResourceOperationKind || (exports2.ResourceOperationKind = ResourceOperationKind = {}));
var FailureHandlingKind;
(function(FailureHandlingKind2) {
FailureHandlingKind2.Abort = "abort";
FailureHandlingKind2.Transactional = "transactional";
FailureHandlingKind2.TextOnlyTransactional = "textOnlyTransactional";
FailureHandlingKind2.Undo = "undo";
})(FailureHandlingKind || (exports2.FailureHandlingKind = FailureHandlingKind = {}));
var PositionEncodingKind;
(function(PositionEncodingKind2) {
PositionEncodingKind2.UTF8 = "utf-8";
PositionEncodingKind2.UTF16 = "utf-16";
PositionEncodingKind2.UTF32 = "utf-32";
})(PositionEncodingKind || (exports2.PositionEncodingKind = PositionEncodingKind = {}));
var StaticRegistrationOptions;
(function(StaticRegistrationOptions2) {
function hasId(value) {
const candidate = value;
return candidate && Is.string(candidate.id) && candidate.id.length > 0;
}
StaticRegistrationOptions2.hasId = hasId;
})(StaticRegistrationOptions || (exports2.StaticRegistrationOptions = StaticRegistrationOptions = {}));
var TextDocumentRegistrationOptions;
(function(TextDocumentRegistrationOptions2) {
function is(value) {
const candidate = value;
return candidate && (candidate.documentSelector === null || DocumentSelector3.is(candidate.documentSelector));
}
TextDocumentRegistrationOptions2.is = is;
})(TextDocumentRegistrationOptions || (exports2.TextDocumentRegistrationOptions = TextDocumentRegistrationOptions = {}));
var WorkDoneProgressOptions;
(function(WorkDoneProgressOptions2) {
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && (candidate.workDoneProgress === void 0 || Is.boolean(candidate.workDoneProgress));
}
WorkDoneProgressOptions2.is = is;
function hasWorkDoneProgress(value) {
const candidate = value;
return candidate && Is.boolean(candidate.workDoneProgress);
}
WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress;
})(WorkDoneProgressOptions || (exports2.WorkDoneProgressOptions = WorkDoneProgressOptions = {}));
var InitializeRequest;
(function(InitializeRequest2) {
InitializeRequest2.method = "initialize";
InitializeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
InitializeRequest2.type = new messages_1.ProtocolRequestType(InitializeRequest2.method);
})(InitializeRequest || (exports2.InitializeRequest = InitializeRequest = {}));
var InitializeErrorCodes;
(function(InitializeErrorCodes2) {
InitializeErrorCodes2.unknownProtocolVersion = 1;
})(InitializeErrorCodes || (exports2.InitializeErrorCodes = InitializeErrorCodes = {}));
var InitializedNotification;
(function(InitializedNotification2) {
InitializedNotification2.method = "initialized";
InitializedNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
InitializedNotification2.type = new messages_1.ProtocolNotificationType(InitializedNotification2.method);
})(InitializedNotification || (exports2.InitializedNotification = InitializedNotification = {}));
var ShutdownRequest;
(function(ShutdownRequest2) {
ShutdownRequest2.method = "shutdown";
ShutdownRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
ShutdownRequest2.type = new messages_1.ProtocolRequestType0(ShutdownRequest2.method);
})(ShutdownRequest || (exports2.ShutdownRequest = ShutdownRequest = {}));
var ExitNotification;
(function(ExitNotification2) {
ExitNotification2.method = "exit";
ExitNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
ExitNotification2.type = new messages_1.ProtocolNotificationType0(ExitNotification2.method);
})(ExitNotification || (exports2.ExitNotification = ExitNotification = {}));
var DidChangeConfigurationNotification;
(function(DidChangeConfigurationNotification2) {
DidChangeConfigurationNotification2.method = "workspace/didChangeConfiguration";
DidChangeConfigurationNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidChangeConfigurationNotification2.type = new messages_1.ProtocolNotificationType(DidChangeConfigurationNotification2.method);
})(DidChangeConfigurationNotification || (exports2.DidChangeConfigurationNotification = DidChangeConfigurationNotification = {}));
var MessageType;
(function(MessageType2) {
MessageType2.Error = 1;
MessageType2.Warning = 2;
MessageType2.Info = 3;
MessageType2.Log = 4;
MessageType2.Debug = 5;
})(MessageType || (exports2.MessageType = MessageType = {}));
var ShowMessageNotification;
(function(ShowMessageNotification2) {
ShowMessageNotification2.method = "window/showMessage";
ShowMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
ShowMessageNotification2.type = new messages_1.ProtocolNotificationType(ShowMessageNotification2.method);
})(ShowMessageNotification || (exports2.ShowMessageNotification = ShowMessageNotification = {}));
var ShowMessageRequest;
(function(ShowMessageRequest2) {
ShowMessageRequest2.method = "window/showMessageRequest";
ShowMessageRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
ShowMessageRequest2.type = new messages_1.ProtocolRequestType(ShowMessageRequest2.method);
})(ShowMessageRequest || (exports2.ShowMessageRequest = ShowMessageRequest = {}));
var LogMessageNotification;
(function(LogMessageNotification2) {
LogMessageNotification2.method = "window/logMessage";
LogMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
LogMessageNotification2.type = new messages_1.ProtocolNotificationType(LogMessageNotification2.method);
})(LogMessageNotification || (exports2.LogMessageNotification = LogMessageNotification = {}));
var TelemetryEventNotification;
(function(TelemetryEventNotification2) {
TelemetryEventNotification2.method = "telemetry/event";
TelemetryEventNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType(TelemetryEventNotification2.method);
})(TelemetryEventNotification || (exports2.TelemetryEventNotification = TelemetryEventNotification = {}));
var TextDocumentSyncKind;
(function(TextDocumentSyncKind2) {
TextDocumentSyncKind2.None = 0;
TextDocumentSyncKind2.Full = 1;
TextDocumentSyncKind2.Incremental = 2;
})(TextDocumentSyncKind || (exports2.TextDocumentSyncKind = TextDocumentSyncKind = {}));
var DidOpenTextDocumentNotification;
(function(DidOpenTextDocumentNotification2) {
DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
DidOpenTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
})(DidOpenTextDocumentNotification || (exports2.DidOpenTextDocumentNotification = DidOpenTextDocumentNotification = {}));
var TextDocumentContentChangeEvent;
(function(TextDocumentContentChangeEvent2) {
function isIncremental(event) {
let candidate = event;
return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
}
TextDocumentContentChangeEvent2.isIncremental = isIncremental;
function isFull(event) {
let candidate = event;
return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
}
TextDocumentContentChangeEvent2.isFull = isFull;
})(TextDocumentContentChangeEvent || (exports2.TextDocumentContentChangeEvent = TextDocumentContentChangeEvent = {}));
var DidChangeTextDocumentNotification;
(function(DidChangeTextDocumentNotification2) {
DidChangeTextDocumentNotification2.method = "textDocument/didChange";
DidChangeTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification2.method);
})(DidChangeTextDocumentNotification || (exports2.DidChangeTextDocumentNotification = DidChangeTextDocumentNotification = {}));
var DidCloseTextDocumentNotification;
(function(DidCloseTextDocumentNotification2) {
DidCloseTextDocumentNotification2.method = "textDocument/didClose";
DidCloseTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification2.method);
})(DidCloseTextDocumentNotification || (exports2.DidCloseTextDocumentNotification = DidCloseTextDocumentNotification = {}));
var DidSaveTextDocumentNotification;
(function(DidSaveTextDocumentNotification2) {
DidSaveTextDocumentNotification2.method = "textDocument/didSave";
DidSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification2.method);
})(DidSaveTextDocumentNotification || (exports2.DidSaveTextDocumentNotification = DidSaveTextDocumentNotification = {}));
var TextDocumentSaveReason;
(function(TextDocumentSaveReason2) {
TextDocumentSaveReason2.Manual = 1;
TextDocumentSaveReason2.AfterDelay = 2;
TextDocumentSaveReason2.FocusOut = 3;
})(TextDocumentSaveReason || (exports2.TextDocumentSaveReason = TextDocumentSaveReason = {}));
var WillSaveTextDocumentNotification;
(function(WillSaveTextDocumentNotification2) {
WillSaveTextDocumentNotification2.method = "textDocument/willSave";
WillSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification2.method);
})(WillSaveTextDocumentNotification || (exports2.WillSaveTextDocumentNotification = WillSaveTextDocumentNotification = {}));
var WillSaveTextDocumentWaitUntilRequest;
(function(WillSaveTextDocumentWaitUntilRequest2) {
WillSaveTextDocumentWaitUntilRequest2.method = "textDocument/willSaveWaitUntil";
WillSaveTextDocumentWaitUntilRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest2.method);
})(WillSaveTextDocumentWaitUntilRequest || (exports2.WillSaveTextDocumentWaitUntilRequest = WillSaveTextDocumentWaitUntilRequest = {}));
var DidChangeWatchedFilesNotification;
(function(DidChangeWatchedFilesNotification2) {
DidChangeWatchedFilesNotification2.method = "workspace/didChangeWatchedFiles";
DidChangeWatchedFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWatchedFilesNotification2.method);
})(DidChangeWatchedFilesNotification || (exports2.DidChangeWatchedFilesNotification = DidChangeWatchedFilesNotification = {}));
var FileChangeType;
(function(FileChangeType2) {
FileChangeType2.Created = 1;
FileChangeType2.Changed = 2;
FileChangeType2.Deleted = 3;
})(FileChangeType || (exports2.FileChangeType = FileChangeType = {}));
var RelativePattern;
(function(RelativePattern2) {
function is(value) {
const candidate = value;
return Is.objectLiteral(candidate) && (vscode_languageserver_types_1.URI.is(candidate.baseUri) || vscode_languageserver_types_1.WorkspaceFolder.is(candidate.baseUri)) && Is.string(candidate.pattern);
}
RelativePattern2.is = is;
})(RelativePattern || (exports2.RelativePattern = RelativePattern = {}));
var WatchKind;
(function(WatchKind2) {
WatchKind2.Create = 1;
WatchKind2.Change = 2;
WatchKind2.Delete = 4;
})(WatchKind || (exports2.WatchKind = WatchKind = {}));
var PublishDiagnosticsNotification;
(function(PublishDiagnosticsNotification2) {
PublishDiagnosticsNotification2.method = "textDocument/publishDiagnostics";
PublishDiagnosticsNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType(PublishDiagnosticsNotification2.method);
})(PublishDiagnosticsNotification || (exports2.PublishDiagnosticsNotification = PublishDiagnosticsNotification = {}));
var CompletionTriggerKind;
(function(CompletionTriggerKind2) {
CompletionTriggerKind2.Invoked = 1;
CompletionTriggerKind2.TriggerCharacter = 2;
CompletionTriggerKind2.TriggerForIncompleteCompletions = 3;
})(CompletionTriggerKind || (exports2.CompletionTriggerKind = CompletionTriggerKind = {}));
var CompletionRequest;
(function(CompletionRequest2) {
CompletionRequest2.method = "textDocument/completion";
CompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
})(CompletionRequest || (exports2.CompletionRequest = CompletionRequest = {}));
var CompletionResolveRequest;
(function(CompletionResolveRequest2) {
CompletionResolveRequest2.method = "completionItem/resolve";
CompletionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CompletionResolveRequest2.type = new messages_1.ProtocolRequestType(CompletionResolveRequest2.method);
})(CompletionResolveRequest || (exports2.CompletionResolveRequest = CompletionResolveRequest = {}));
var HoverRequest;
(function(HoverRequest2) {
HoverRequest2.method = "textDocument/hover";
HoverRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
HoverRequest2.type = new messages_1.ProtocolRequestType(HoverRequest2.method);
})(HoverRequest || (exports2.HoverRequest = HoverRequest = {}));
var SignatureHelpTriggerKind;
(function(SignatureHelpTriggerKind2) {
SignatureHelpTriggerKind2.Invoked = 1;
SignatureHelpTriggerKind2.TriggerCharacter = 2;
SignatureHelpTriggerKind2.ContentChange = 3;
})(SignatureHelpTriggerKind || (exports2.SignatureHelpTriggerKind = SignatureHelpTriggerKind = {}));
var SignatureHelpRequest;
(function(SignatureHelpRequest2) {
SignatureHelpRequest2.method = "textDocument/signatureHelp";
SignatureHelpRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
SignatureHelpRequest2.type = new messages_1.ProtocolRequestType(SignatureHelpRequest2.method);
})(SignatureHelpRequest || (exports2.SignatureHelpRequest = SignatureHelpRequest = {}));
var DefinitionRequest;
(function(DefinitionRequest2) {
DefinitionRequest2.method = "textDocument/definition";
DefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
})(DefinitionRequest || (exports2.DefinitionRequest = DefinitionRequest = {}));
var ReferencesRequest;
(function(ReferencesRequest2) {
ReferencesRequest2.method = "textDocument/references";
ReferencesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
})(ReferencesRequest || (exports2.ReferencesRequest = ReferencesRequest = {}));
var DocumentHighlightRequest;
(function(DocumentHighlightRequest2) {
DocumentHighlightRequest2.method = "textDocument/documentHighlight";
DocumentHighlightRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
})(DocumentHighlightRequest || (exports2.DocumentHighlightRequest = DocumentHighlightRequest = {}));
var DocumentSymbolRequest;
(function(DocumentSymbolRequest2) {
DocumentSymbolRequest2.method = "textDocument/documentSymbol";
DocumentSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
})(DocumentSymbolRequest || (exports2.DocumentSymbolRequest = DocumentSymbolRequest = {}));
var CodeActionRequest;
(function(CodeActionRequest2) {
CodeActionRequest2.method = "textDocument/codeAction";
CodeActionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
})(CodeActionRequest || (exports2.CodeActionRequest = CodeActionRequest = {}));
var CodeActionResolveRequest;
(function(CodeActionResolveRequest2) {
CodeActionResolveRequest2.method = "codeAction/resolve";
CodeActionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
})(CodeActionResolveRequest || (exports2.CodeActionResolveRequest = CodeActionResolveRequest = {}));
var WorkspaceSymbolRequest;
(function(WorkspaceSymbolRequest2) {
WorkspaceSymbolRequest2.method = "workspace/symbol";
WorkspaceSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
})(WorkspaceSymbolRequest || (exports2.WorkspaceSymbolRequest = WorkspaceSymbolRequest = {}));
var WorkspaceSymbolResolveRequest;
(function(WorkspaceSymbolResolveRequest2) {
WorkspaceSymbolResolveRequest2.method = "workspaceSymbol/resolve";
WorkspaceSymbolResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
WorkspaceSymbolResolveRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolResolveRequest2.method);
})(WorkspaceSymbolResolveRequest || (exports2.WorkspaceSymbolResolveRequest = WorkspaceSymbolResolveRequest = {}));
var CodeLensRequest;
(function(CodeLensRequest2) {
CodeLensRequest2.method = "textDocument/codeLens";
CodeLensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
})(CodeLensRequest || (exports2.CodeLensRequest = CodeLensRequest = {}));
var CodeLensResolveRequest;
(function(CodeLensResolveRequest2) {
CodeLensResolveRequest2.method = "codeLens/resolve";
CodeLensResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
})(CodeLensResolveRequest || (exports2.CodeLensResolveRequest = CodeLensResolveRequest = {}));
var CodeLensRefreshRequest;
(function(CodeLensRefreshRequest2) {
CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
CodeLensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
})(CodeLensRefreshRequest || (exports2.CodeLensRefreshRequest = CodeLensRefreshRequest = {}));
var DocumentLinkRequest;
(function(DocumentLinkRequest2) {
DocumentLinkRequest2.method = "textDocument/documentLink";
DocumentLinkRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
})(DocumentLinkRequest || (exports2.DocumentLinkRequest = DocumentLinkRequest = {}));
var DocumentLinkResolveRequest;
(function(DocumentLinkResolveRequest2) {
DocumentLinkResolveRequest2.method = "documentLink/resolve";
DocumentLinkResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
})(DocumentLinkResolveRequest || (exports2.DocumentLinkResolveRequest = DocumentLinkResolveRequest = {}));
var DocumentFormattingRequest;
(function(DocumentFormattingRequest2) {
DocumentFormattingRequest2.method = "textDocument/formatting";
DocumentFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest2.method);
})(DocumentFormattingRequest || (exports2.DocumentFormattingRequest = DocumentFormattingRequest = {}));
var DocumentRangeFormattingRequest;
(function(DocumentRangeFormattingRequest2) {
DocumentRangeFormattingRequest2.method = "textDocument/rangeFormatting";
DocumentRangeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest2.method);
})(DocumentRangeFormattingRequest || (exports2.DocumentRangeFormattingRequest = DocumentRangeFormattingRequest = {}));
var DocumentRangesFormattingRequest;
(function(DocumentRangesFormattingRequest2) {
DocumentRangesFormattingRequest2.method = "textDocument/rangesFormatting";
DocumentRangesFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentRangesFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangesFormattingRequest2.method);
})(DocumentRangesFormattingRequest || (exports2.DocumentRangesFormattingRequest = DocumentRangesFormattingRequest = {}));
var DocumentOnTypeFormattingRequest;
(function(DocumentOnTypeFormattingRequest2) {
DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
DocumentOnTypeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
})(DocumentOnTypeFormattingRequest || (exports2.DocumentOnTypeFormattingRequest = DocumentOnTypeFormattingRequest = {}));
var PrepareSupportDefaultBehavior;
(function(PrepareSupportDefaultBehavior2) {
PrepareSupportDefaultBehavior2.Identifier = 1;
})(PrepareSupportDefaultBehavior || (exports2.PrepareSupportDefaultBehavior = PrepareSupportDefaultBehavior = {}));
var RenameRequest;
(function(RenameRequest2) {
RenameRequest2.method = "textDocument/rename";
RenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
RenameRequest2.type = new messages_1.ProtocolRequestType(RenameRequest2.method);
})(RenameRequest || (exports2.RenameRequest = RenameRequest = {}));
var PrepareRenameRequest;
(function(PrepareRenameRequest2) {
PrepareRenameRequest2.method = "textDocument/prepareRename";
PrepareRenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
PrepareRenameRequest2.type = new messages_1.ProtocolRequestType(PrepareRenameRequest2.method);
})(PrepareRenameRequest || (exports2.PrepareRenameRequest = PrepareRenameRequest = {}));
var ExecuteCommandRequest;
(function(ExecuteCommandRequest2) {
ExecuteCommandRequest2.method = "workspace/executeCommand";
ExecuteCommandRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType(ExecuteCommandRequest2.method);
})(ExecuteCommandRequest || (exports2.ExecuteCommandRequest = ExecuteCommandRequest = {}));
var ApplyWorkspaceEditRequest;
(function(ApplyWorkspaceEditRequest2) {
ApplyWorkspaceEditRequest2.method = "workspace/applyEdit";
ApplyWorkspaceEditRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType("workspace/applyEdit");
})(ApplyWorkspaceEditRequest || (exports2.ApplyWorkspaceEditRequest = ApplyWorkspaceEditRequest = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/common/connection.js
var require_connection2 = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/connection.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createProtocolConnection = void 0;
var vscode_jsonrpc_1 = require_main();
function createProtocolConnection(input, output, logger2, options) {
if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
options = { connectionStrategy: options };
}
return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger2, options);
}
exports2.createProtocolConnection = createProtocolConnection;
}
});
// node_modules/vscode-languageserver-protocol/lib/common/api.js
var require_api2 = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/common/api.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.LSPErrorCodes = exports2.createProtocolConnection = void 0;
__exportStar(require_main(), exports2);
__exportStar(require_main2(), exports2);
__exportStar(require_messages2(), exports2);
__exportStar(require_protocol(), exports2);
var connection_1 = require_connection2();
Object.defineProperty(exports2, "createProtocolConnection", { enumerable: true, get: function() {
return connection_1.createProtocolConnection;
} });
var LSPErrorCodes;
(function(LSPErrorCodes2) {
LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
LSPErrorCodes2.RequestFailed = -32803;
LSPErrorCodes2.ServerCancelled = -32802;
LSPErrorCodes2.ContentModified = -32801;
LSPErrorCodes2.RequestCancelled = -32800;
LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
})(LSPErrorCodes || (exports2.LSPErrorCodes = LSPErrorCodes = {}));
}
});
// node_modules/vscode-languageserver-protocol/lib/node/main.js
var require_main3 = __commonJS({
"node_modules/vscode-languageserver-protocol/lib/node/main.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createProtocolConnection = void 0;
var node_1 = require_node();
__exportStar(require_node(), exports2);
__exportStar(require_api2(), exports2);
function createProtocolConnection(input, output, logger2, options) {
return (0, node_1.createMessageConnection)(input, output, logger2, options);
}
exports2.createProtocolConnection = createProtocolConnection;
}
});
// node_modules/vscode-languageclient/lib/common/utils/async.js
var require_async = __commonJS({
"node_modules/vscode-languageclient/lib/common/utils/async.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.forEach = exports2.mapAsync = exports2.map = exports2.clearTestMode = exports2.setTestMode = exports2.Semaphore = exports2.Delayer = void 0;
var vscode_languageserver_protocol_1 = require_main3();
var Delayer = class {
constructor(defaultDelay) {
this.defaultDelay = defaultDelay;
this.timeout = void 0;
this.completionPromise = void 0;
this.onSuccess = void 0;
this.task = void 0;
}
trigger(task, delay = this.defaultDelay) {
this.task = task;
if (delay >= 0) {
this.cancelTimeout();
}
if (!this.completionPromise) {
this.completionPromise = new Promise((resolve3) => {
this.onSuccess = resolve3;
}).then(() => {
this.completionPromise = void 0;
this.onSuccess = void 0;
var result = this.task();
this.task = void 0;
return result;
});
}
if (delay >= 0 || this.timeout === void 0) {
this.timeout = (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => {
this.timeout = void 0;
this.onSuccess(void 0);
}, delay >= 0 ? delay : this.defaultDelay);
}
return this.completionPromise;
}
forceDelivery() {
if (!this.completionPromise) {
return void 0;
}
this.cancelTimeout();
let result = this.task();
this.completionPromise = void 0;
this.onSuccess = void 0;
this.task = void 0;
return result;
}
isTriggered() {
return this.timeout !== void 0;
}
cancel() {
this.cancelTimeout();
this.completionPromise = void 0;
}
cancelTimeout() {
if (this.timeout !== void 0) {
this.timeout.dispose();
this.timeout = void 0;
}
}
};
exports2.Delayer = Delayer;
var Semaphore = class {
constructor(capacity = 1) {
if (capacity <= 0) {
throw new Error("Capacity must be greater than 0");
}
this._capacity = capacity;
this._active = 0;
this._waiting = [];
}
lock(thunk) {
return new Promise((resolve3, reject) => {
this._waiting.push({ thunk, resolve: resolve3, reject });
this.runNext();
});
}
get active() {
return this._active;
}
runNext() {
if (this._waiting.length === 0 || this._active === this._capacity) {
return;
}
(0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => this.doRunNext());
}
doRunNext() {
if (this._waiting.length === 0 || this._active === this._capacity) {
return;
}
const next = this._waiting.shift();
this._active++;
if (this._active > this._capacity) {
throw new Error(`To many thunks active`);
}
try {
const result = next.thunk();
if (result instanceof Promise) {
result.then((value) => {
this._active--;
next.resolve(value);
this.runNext();
}, (err) => {
this._active--;
next.reject(err);
this.runNext();
});
} else {
this._active--;
next.resolve(result);
this.runNext();
}
} catch (err) {
this._active--;
next.reject(err);
this.runNext();
}
}
};
exports2.Semaphore = Semaphore;
var $test = false;
function setTestMode() {
$test = true;
}
exports2.setTestMode = setTestMode;
function clearTestMode() {
$test = false;
}
exports2.clearTestMode = clearTestMode;
var defaultYieldTimeout = 15;
var Timer = class {
constructor(yieldAfter = defaultYieldTimeout) {
this.yieldAfter = $test === true ? Math.max(yieldAfter, 2) : Math.max(yieldAfter, defaultYieldTimeout);
this.startTime = Date.now();
this.counter = 0;
this.total = 0;
this.counterInterval = 1;
}
start() {
this.counter = 0;
this.total = 0;
this.counterInterval = 1;
this.startTime = Date.now();
}
shouldYield() {
if (++this.counter >= this.counterInterval) {
const timeTaken = Date.now() - this.startTime;
const timeLeft = Math.max(0, this.yieldAfter - timeTaken);
this.total += this.counter;
this.counter = 0;
if (timeTaken >= this.yieldAfter || timeLeft <= 1) {
this.counterInterval = 1;
this.total = 0;
return true;
} else {
switch (timeTaken) {
case 0:
case 1:
this.counterInterval = this.total * 2;
break;
}
}
}
return false;
}
};
async function map(items, func, token, options) {
if (items.length === 0) {
return [];
}
const result = new Array(items.length);
const timer = new Timer(options?.yieldAfter);
function convertBatch(start) {
timer.start();
for (let i = start; i < items.length; i++) {
result[i] = func(items[i]);
if (timer.shouldYield()) {
options?.yieldCallback && options.yieldCallback();
return i + 1;
}
}
return -1;
}
let index = convertBatch(0);
while (index !== -1) {
if (token !== void 0 && token.isCancellationRequested) {
break;
}
index = await new Promise((resolve3) => {
(0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
resolve3(convertBatch(index));
});
});
}
return result;
}
exports2.map = map;
async function mapAsync(items, func, token, options) {
if (items.length === 0) {
return [];
}
const result = new Array(items.length);
const timer = new Timer(options?.yieldAfter);
async function convertBatch(start) {
timer.start();
for (let i = start; i < items.length; i++) {
result[i] = await func(items[i], token);
if (timer.shouldYield()) {
options?.yieldCallback && options.yieldCallback();
return i + 1;
}
}
return -1;
}
let index = await convertBatch(0);
while (index !== -1) {
if (token !== void 0 && token.isCancellationRequested) {
break;
}
index = await new Promise((resolve3) => {
(0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
resolve3(convertBatch(index));
});
});
}
return result;
}
exports2.mapAsync = mapAsync;
async function forEach(items, func, token, options) {
if (items.length === 0) {
return;
}
const timer = new Timer(options?.yieldAfter);
function runBatch(start) {
timer.start();
for (let i = start; i < items.length; i++) {
func(items[i]);
if (timer.shouldYield()) {
options?.yieldCallback && options.yieldCallback();
return i + 1;
}
}
return -1;
}
let index = runBatch(0);
while (index !== -1) {
if (token !== void 0 && token.isCancellationRequested) {
break;
}
index = await new Promise((resolve3) => {
(0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
resolve3(runBatch(index));
});
});
}
}
exports2.forEach = forEach;
}
});
// node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js
var require_protocolCompletionItem = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolCompletionItem = class extends code.CompletionItem {
constructor(label) {
super(label);
}
};
exports2.default = ProtocolCompletionItem;
}
});
// node_modules/vscode-languageclient/lib/common/protocolCodeLens.js
var require_protocolCodeLens = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolCodeLens.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolCodeLens = class extends code.CodeLens {
constructor(range) {
super(range);
}
};
exports2.default = ProtocolCodeLens;
}
});
// node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js
var require_protocolDocumentLink = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolDocumentLink = class extends code.DocumentLink {
constructor(range, target) {
super(range, target);
}
};
exports2.default = ProtocolDocumentLink;
}
});
// node_modules/vscode-languageclient/lib/common/protocolCodeAction.js
var require_protocolCodeAction = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolCodeAction.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var vscode22 = require("vscode");
var ProtocolCodeAction = class extends vscode22.CodeAction {
constructor(title, data) {
super(title);
this.data = data;
}
};
exports2.default = ProtocolCodeAction;
}
});
// node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js
var require_protocolDiagnostic = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProtocolDiagnostic = exports2.DiagnosticCode = void 0;
var vscode22 = require("vscode");
var Is = require_is();
var DiagnosticCode;
(function(DiagnosticCode2) {
function is(value) {
const candidate = value;
return candidate !== void 0 && candidate !== null && (Is.number(candidate.value) || Is.string(candidate.value)) && Is.string(candidate.target);
}
DiagnosticCode2.is = is;
})(DiagnosticCode || (exports2.DiagnosticCode = DiagnosticCode = {}));
var ProtocolDiagnostic = class extends vscode22.Diagnostic {
constructor(range, message, severity, data) {
super(range, message, severity);
this.data = data;
this.hasDiagnosticCode = false;
}
};
exports2.ProtocolDiagnostic = ProtocolDiagnostic;
}
});
// node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js
var require_protocolCallHierarchyItem = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolCallHierarchyItem = class extends code.CallHierarchyItem {
constructor(kind, name, detail, uri, range, selectionRange, data) {
super(kind, name, detail, uri, range, selectionRange);
if (data !== void 0) {
this.data = data;
}
}
};
exports2.default = ProtocolCallHierarchyItem;
}
});
// node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js
var require_protocolTypeHierarchyItem = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolTypeHierarchyItem = class extends code.TypeHierarchyItem {
constructor(kind, name, detail, uri, range, selectionRange, data) {
super(kind, name, detail, uri, range, selectionRange);
if (data !== void 0) {
this.data = data;
}
}
};
exports2.default = ProtocolTypeHierarchyItem;
}
});
// node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js
var require_protocolWorkspaceSymbol = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var WorkspaceSymbol = class extends code.SymbolInformation {
constructor(name, kind, containerName, locationOrUri, data) {
const hasRange = !(locationOrUri instanceof code.Uri);
super(name, kind, containerName, hasRange ? locationOrUri : new code.Location(locationOrUri, new code.Range(0, 0, 0, 0)));
this.hasRange = hasRange;
if (data !== void 0) {
this.data = data;
}
}
};
exports2.default = WorkspaceSymbol;
}
});
// node_modules/vscode-languageclient/lib/common/protocolInlayHint.js
var require_protocolInlayHint = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolInlayHint.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var code = require("vscode");
var ProtocolInlayHint = class extends code.InlayHint {
constructor(position, label, kind) {
super(position, label, kind);
}
};
exports2.default = ProtocolInlayHint;
}
});
// node_modules/vscode-languageclient/lib/common/codeConverter.js
var require_codeConverter = __commonJS({
"node_modules/vscode-languageclient/lib/common/codeConverter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createConverter = void 0;
var code = require("vscode");
var proto = require_main3();
var Is = require_is();
var async = require_async();
var protocolCompletionItem_1 = require_protocolCompletionItem();
var protocolCodeLens_1 = require_protocolCodeLens();
var protocolDocumentLink_1 = require_protocolDocumentLink();
var protocolCodeAction_1 = require_protocolCodeAction();
var protocolDiagnostic_1 = require_protocolDiagnostic();
var protocolCallHierarchyItem_1 = require_protocolCallHierarchyItem();
var protocolTypeHierarchyItem_1 = require_protocolTypeHierarchyItem();
var protocolWorkspaceSymbol_1 = require_protocolWorkspaceSymbol();
var protocolInlayHint_1 = require_protocolInlayHint();
var InsertReplaceRange;
(function(InsertReplaceRange2) {
function is(value) {
const candidate = value;
return candidate && !!candidate.inserting && !!candidate.replacing;
}
InsertReplaceRange2.is = is;
})(InsertReplaceRange || (InsertReplaceRange = {}));
function createConverter(uriConverter) {
const nullConverter = (value) => value.toString();
const _uriConverter = uriConverter || nullConverter;
function asUri(value) {
return _uriConverter(value);
}
function asTextDocumentIdentifier(textDocument) {
return {
uri: _uriConverter(textDocument.uri)
};
}
function asTextDocumentItem(textDocument) {
return {
uri: _uriConverter(textDocument.uri),
languageId: textDocument.languageId,
version: textDocument.version,
text: textDocument.getText()
};
}
function asVersionedTextDocumentIdentifier(textDocument) {
return {
uri: _uriConverter(textDocument.uri),
version: textDocument.version
};
}
function asOpenTextDocumentParams(textDocument) {
return {
textDocument: asTextDocumentItem(textDocument)
};
}
function isTextDocumentChangeEvent(value) {
const candidate = value;
return !!candidate.document && !!candidate.contentChanges;
}
function isTextDocument(value) {
const candidate = value;
return !!candidate.uri && !!candidate.version;
}
function asChangeTextDocumentParams(arg0, arg1, arg2) {
if (isTextDocument(arg0)) {
const result = {
textDocument: {
uri: _uriConverter(arg0.uri),
version: arg0.version
},
contentChanges: [{ text: arg0.getText() }]
};
return result;
} else if (isTextDocumentChangeEvent(arg0)) {
const uri = arg1;
const version = arg2;
const result = {
textDocument: {
uri: _uriConverter(uri),
version
},
contentChanges: arg0.contentChanges.map((change) => {
const range = change.range;
return {
range: {
start: { line: range.start.line, character: range.start.character },
end: { line: range.end.line, character: range.end.character }
},
rangeLength: change.rangeLength,
text: change.text
};
})
};
return result;
} else {
throw Error("Unsupported text document change parameter");
}
}
function asCloseTextDocumentParams(textDocument) {
return {
textDocument: asTextDocumentIdentifier(textDocument)
};
}
function asSaveTextDocumentParams(textDocument, includeContent = false) {
let result = {
textDocument: asTextDocumentIdentifier(textDocument)
};
if (includeContent) {
result.text = textDocument.getText();
}
return result;
}
function asTextDocumentSaveReason(reason) {
switch (reason) {
case code.TextDocumentSaveReason.Manual:
return proto.TextDocumentSaveReason.Manual;
case code.TextDocumentSaveReason.AfterDelay:
return proto.TextDocumentSaveReason.AfterDelay;
case code.TextDocumentSaveReason.FocusOut:
return proto.TextDocumentSaveReason.FocusOut;
}
return proto.TextDocumentSaveReason.Manual;
}
function asWillSaveTextDocumentParams(event) {
return {
textDocument: asTextDocumentIdentifier(event.document),
reason: asTextDocumentSaveReason(event.reason)
};
}
function asDidCreateFilesParams(event) {
return {
files: event.files.map((fileUri) => ({
uri: _uriConverter(fileUri)
}))
};
}
function asDidRenameFilesParams(event) {
return {
files: event.files.map((file) => ({
oldUri: _uriConverter(file.oldUri),
newUri: _uriConverter(file.newUri)
}))
};
}
function asDidDeleteFilesParams(event) {
return {
files: event.files.map((fileUri) => ({
uri: _uriConverter(fileUri)
}))
};
}
function asWillCreateFilesParams(event) {
return {
files: event.files.map((fileUri) => ({
uri: _uriConverter(fileUri)
}))
};
}
function asWillRenameFilesParams(event) {
return {
files: event.files.map((file) => ({
oldUri: _uriConverter(file.oldUri),
newUri: _uriConverter(file.newUri)
}))
};
}
function asWillDeleteFilesParams(event) {
return {
files: event.files.map((fileUri) => ({
uri: _uriConverter(fileUri)
}))
};
}
function asTextDocumentPositionParams(textDocument, position) {
return {
textDocument: asTextDocumentIdentifier(textDocument),
position: asWorkerPosition(position)
};
}
function asCompletionTriggerKind(triggerKind) {
switch (triggerKind) {
case code.CompletionTriggerKind.TriggerCharacter:
return proto.CompletionTriggerKind.TriggerCharacter;
case code.CompletionTriggerKind.TriggerForIncompleteCompletions:
return proto.CompletionTriggerKind.TriggerForIncompleteCompletions;
default:
return proto.CompletionTriggerKind.Invoked;
}
}
function asCompletionParams(textDocument, position, context) {
return {
textDocument: asTextDocumentIdentifier(textDocument),
position: asWorkerPosition(position),
context: {
triggerKind: asCompletionTriggerKind(context.triggerKind),
triggerCharacter: context.triggerCharacter
}
};
}
function asSignatureHelpTriggerKind(triggerKind) {
switch (triggerKind) {
case code.SignatureHelpTriggerKind.Invoke:
return proto.SignatureHelpTriggerKind.Invoked;
case code.SignatureHelpTriggerKind.TriggerCharacter:
return proto.SignatureHelpTriggerKind.TriggerCharacter;
case code.SignatureHelpTriggerKind.ContentChange:
return proto.SignatureHelpTriggerKind.ContentChange;
}
}
function asParameterInformation(value) {
return {
label: value.label
};
}
function asParameterInformations(values) {
return values.map(asParameterInformation);
}
function asSignatureInformation(value) {
return {
label: value.label,
parameters: asParameterInformations(value.parameters)
};
}
function asSignatureInformations(values) {
return values.map(asSignatureInformation);
}
function asSignatureHelp(value) {
if (value === void 0) {
return value;
}
return {
signatures: asSignatureInformations(value.signatures),
activeSignature: value.activeSignature,
activeParameter: value.activeParameter
};
}
function asSignatureHelpParams(textDocument, position, context) {
return {
textDocument: asTextDocumentIdentifier(textDocument),
position: asWorkerPosition(position),
context: {
isRetrigger: context.isRetrigger,
triggerCharacter: context.triggerCharacter,
triggerKind: asSignatureHelpTriggerKind(context.triggerKind),
activeSignatureHelp: asSignatureHelp(context.activeSignatureHelp)
}
};
}
function asWorkerPosition(position) {
return { line: position.line, character: position.character };
}
function asPosition2(value) {
if (value === void 0 || value === null) {
return value;
}
return { line: value.line > proto.uinteger.MAX_VALUE ? proto.uinteger.MAX_VALUE : value.line, character: value.character > proto.uinteger.MAX_VALUE ? proto.uinteger.MAX_VALUE : value.character };
}
function asPositions(values, token) {
return async.map(values, asPosition2, token);
}
function asPositionsSync(values) {
return values.map(asPosition2);
}
function asRange2(value) {
if (value === void 0 || value === null) {
return value;
}
return { start: asPosition2(value.start), end: asPosition2(value.end) };
}
function asRanges(values) {
return values.map(asRange2);
}
function asLocation(value) {
if (value === void 0 || value === null) {
return value;
}
return proto.Location.create(asUri(value.uri), asRange2(value.range));
}
function asDiagnosticSeverity(value) {
switch (value) {
case code.DiagnosticSeverity.Error:
return proto.DiagnosticSeverity.Error;
case code.DiagnosticSeverity.Warning:
return proto.DiagnosticSeverity.Warning;
case code.DiagnosticSeverity.Information:
return proto.DiagnosticSeverity.Information;
case code.DiagnosticSeverity.Hint:
return proto.DiagnosticSeverity.Hint;
}
}
function asDiagnosticTags(tags) {
if (!tags) {
return void 0;
}
let result = [];
for (let tag of tags) {
let converted = asDiagnosticTag(tag);
if (converted !== void 0) {
result.push(converted);
}
}
return result.length > 0 ? result : void 0;
}
function asDiagnosticTag(tag) {
switch (tag) {
case code.DiagnosticTag.Unnecessary:
return proto.DiagnosticTag.Unnecessary;
case code.DiagnosticTag.Deprecated:
return proto.DiagnosticTag.Deprecated;
default:
return void 0;
}
}
function asRelatedInformation(item) {
return {
message: item.message,
location: asLocation(item.location)
};
}
function asRelatedInformations(items) {
return items.map(asRelatedInformation);
}
function asDiagnosticCode(value) {
if (value === void 0 || value === null) {
return void 0;
}
if (Is.number(value) || Is.string(value)) {
return value;
}
return { value: value.value, target: asUri(value.target) };
}
function asDiagnostic(item) {
const result = proto.Diagnostic.create(asRange2(item.range), item.message);
const protocolDiagnostic = item instanceof protocolDiagnostic_1.ProtocolDiagnostic ? item : void 0;
if (protocolDiagnostic !== void 0 && protocolDiagnostic.data !== void 0) {
result.data = protocolDiagnostic.data;
}
const code2 = asDiagnosticCode(item.code);
if (protocolDiagnostic_1.DiagnosticCode.is(code2)) {
if (protocolDiagnostic !== void 0 && protocolDiagnostic.hasDiagnosticCode) {
result.code = code2;
} else {
result.code = code2.value;
result.codeDescription = { href: code2.target };
}
} else {
result.code = code2;
}
if (Is.number(item.severity)) {
result.severity = asDiagnosticSeverity(item.severity);
}
if (Array.isArray(item.tags)) {
result.tags = asDiagnosticTags(item.tags);
}
if (item.relatedInformation) {
result.relatedInformation = asRelatedInformations(item.relatedInformation);
}
if (item.source) {
result.source = item.source;
}
return result;
}
function asDiagnostics(items, token) {
if (items === void 0 || items === null) {
return items;
}
return async.map(items, asDiagnostic, token);
}
function asDiagnosticsSync(items) {
if (items === void 0 || items === null) {
return items;
}
return items.map(asDiagnostic);
}
function asDocumentation(format, documentation) {
switch (format) {
case "$string":
return documentation;
case proto.MarkupKind.PlainText:
return { kind: format, value: documentation };
case proto.MarkupKind.Markdown:
return { kind: format, value: documentation.value };
default:
return `Unsupported Markup content received. Kind is: ${format}`;
}
}
function asCompletionItemTag(tag) {
switch (tag) {
case code.CompletionItemTag.Deprecated:
return proto.CompletionItemTag.Deprecated;
}
return void 0;
}
function asCompletionItemTags(tags) {
if (tags === void 0) {
return tags;
}
const result = [];
for (let tag of tags) {
const converted = asCompletionItemTag(tag);
if (converted !== void 0) {
result.push(converted);
}
}
return result;
}
function asCompletionItemKind(value, original) {
if (original !== void 0) {
return original;
}
return value + 1;
}
function asCompletionItem(item, labelDetailsSupport = false) {
let label;
let labelDetails;
if (Is.string(item.label)) {
label = item.label;
} else {
label = item.label.label;
if (labelDetailsSupport && (item.label.detail !== void 0 || item.label.description !== void 0)) {
labelDetails = { detail: item.label.detail, description: item.label.description };
}
}
let result = { label };
if (labelDetails !== void 0) {
result.labelDetails = labelDetails;
}
let protocolItem = item instanceof protocolCompletionItem_1.default ? item : void 0;
if (item.detail) {
result.detail = item.detail;
}
if (item.documentation) {
if (!protocolItem || protocolItem.documentationFormat === "$string") {
result.documentation = item.documentation;
} else {
result.documentation = asDocumentation(protocolItem.documentationFormat, item.documentation);
}
}
if (item.filterText) {
result.filterText = item.filterText;
}
fillPrimaryInsertText(result, item);
if (Is.number(item.kind)) {
result.kind = asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind);
}
if (item.sortText) {
result.sortText = item.sortText;
}
if (item.additionalTextEdits) {
result.additionalTextEdits = asTextEdits(item.additionalTextEdits);
}
if (item.commitCharacters) {
result.commitCharacters = item.commitCharacters.slice();
}
if (item.command) {
result.command = asCommand(item.command);
}
if (item.preselect === true || item.preselect === false) {
result.preselect = item.preselect;
}
const tags = asCompletionItemTags(item.tags);
if (protocolItem) {
if (protocolItem.data !== void 0) {
result.data = protocolItem.data;
}
if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
if (protocolItem.deprecated === true && tags !== void 0 && tags.length > 0) {
const index = tags.indexOf(code.CompletionItemTag.Deprecated);
if (index !== -1) {
tags.splice(index, 1);
}
}
result.deprecated = protocolItem.deprecated;
}
if (protocolItem.insertTextMode !== void 0) {
result.insertTextMode = protocolItem.insertTextMode;
}
}
if (tags !== void 0 && tags.length > 0) {
result.tags = tags;
}
if (result.insertTextMode === void 0 && item.keepWhitespace === true) {
result.insertTextMode = proto.InsertTextMode.adjustIndentation;
}
return result;
}
function fillPrimaryInsertText(target, source) {
let format = proto.InsertTextFormat.PlainText;
let text = void 0;
let range = void 0;
if (source.textEdit) {
text = source.textEdit.newText;
range = source.textEdit.range;
} else if (source.insertText instanceof code.SnippetString) {
format = proto.InsertTextFormat.Snippet;
text = source.insertText.value;
} else {
text = source.insertText;
}
if (source.range) {
range = source.range;
}
target.insertTextFormat = format;
if (source.fromEdit && text !== void 0 && range !== void 0) {
target.textEdit = asCompletionTextEdit(text, range);
} else {
target.insertText = text;
}
}
function asCompletionTextEdit(newText, range) {
if (InsertReplaceRange.is(range)) {
return proto.InsertReplaceEdit.create(newText, asRange2(range.inserting), asRange2(range.replacing));
} else {
return { newText, range: asRange2(range) };
}
}
function asTextEdit(edit) {
return { range: asRange2(edit.range), newText: edit.newText };
}
function asTextEdits(edits) {
if (edits === void 0 || edits === null) {
return edits;
}
return edits.map(asTextEdit);
}
function asSymbolKind(item) {
if (item <= code.SymbolKind.TypeParameter) {
return item + 1;
}
return proto.SymbolKind.Property;
}
function asSymbolTag(item) {
return item;
}
function asSymbolTags(items) {
return items.map(asSymbolTag);
}
function asReferenceParams(textDocument, position, options) {
return {
textDocument: asTextDocumentIdentifier(textDocument),
position: asWorkerPosition(position),
context: { includeDeclaration: options.includeDeclaration }
};
}
async function asCodeAction(item, token) {
let result = proto.CodeAction.create(item.title);
if (item instanceof protocolCodeAction_1.default && item.data !== void 0) {
result.data = item.data;
}
if (item.kind !== void 0) {
result.kind = asCodeActionKind(item.kind);
}
if (item.diagnostics !== void 0) {
result.diagnostics = await asDiagnostics(item.diagnostics, token);
}
if (item.edit !== void 0) {
throw new Error(`VS Code code actions can only be converted to a protocol code action without an edit.`);
}
if (item.command !== void 0) {
result.command = asCommand(item.command);
}
if (item.isPreferred !== void 0) {
result.isPreferred = item.isPreferred;
}
if (item.disabled !== void 0) {
result.disabled = { reason: item.disabled.reason };
}
return result;
}
function asCodeActionSync(item) {
let result = proto.CodeAction.create(item.title);
if (item instanceof protocolCodeAction_1.default && item.data !== void 0) {
result.data = item.data;
}
if (item.kind !== void 0) {
result.kind = asCodeActionKind(item.kind);
}
if (item.diagnostics !== void 0) {
result.diagnostics = asDiagnosticsSync(item.diagnostics);
}
if (item.edit !== void 0) {
throw new Error(`VS Code code actions can only be converted to a protocol code action without an edit.`);
}
if (item.command !== void 0) {
result.command = asCommand(item.command);
}
if (item.isPreferred !== void 0) {
result.isPreferred = item.isPreferred;
}
if (item.disabled !== void 0) {
result.disabled = { reason: item.disabled.reason };
}
return result;
}
async function asCodeActionContext(context, token) {
if (context === void 0 || context === null) {
return context;
}
let only;
if (context.only && Is.string(context.only.value)) {
only = [context.only.value];
}
return proto.CodeActionContext.create(await asDiagnostics(context.diagnostics, token), only, asCodeActionTriggerKind(context.triggerKind));
}
function asCodeActionContextSync(context) {
if (context === void 0 || context === null) {
return context;
}
let only;
if (context.only && Is.string(context.only.value)) {
only = [context.only.value];
}
return proto.CodeActionContext.create(asDiagnosticsSync(context.diagnostics), only, asCodeActionTriggerKind(context.triggerKind));
}
function asCodeActionTriggerKind(kind) {
switch (kind) {
case code.CodeActionTriggerKind.Invoke:
return proto.CodeActionTriggerKind.Invoked;
case code.CodeActionTriggerKind.Automatic:
return proto.CodeActionTriggerKind.Automatic;
default:
return void 0;
}
}
function asCodeActionKind(item) {
if (item === void 0 || item === null) {
return void 0;
}
return item.value;
}
function asInlineValueContext(context) {
if (context === void 0 || context === null) {
return context;
}
return proto.InlineValueContext.create(context.frameId, asRange2(context.stoppedLocation));
}
function asInlineCompletionParams(document, position, context) {
return {
context: proto.InlineCompletionContext.create(context.triggerKind, context.selectedCompletionInfo),
textDocument: asTextDocumentIdentifier(document),
position: asPosition2(position)
};
}
function asCommand(item) {
let result = proto.Command.create(item.title, item.command);
if (item.arguments) {
result.arguments = item.arguments;
}
return result;
}
function asCodeLens(item) {
let result = proto.CodeLens.create(asRange2(item.range));
if (item.command) {
result.command = asCommand(item.command);
}
if (item instanceof protocolCodeLens_1.default) {
if (item.data) {
result.data = item.data;
}
}
return result;
}
function asFormattingOptions(options, fileOptions) {
const result = { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
if (fileOptions.trimTrailingWhitespace) {
result.trimTrailingWhitespace = true;
}
if (fileOptions.trimFinalNewlines) {
result.trimFinalNewlines = true;
}
if (fileOptions.insertFinalNewline) {
result.insertFinalNewline = true;
}
return result;
}
function asDocumentSymbolParams(textDocument) {
return {
textDocument: asTextDocumentIdentifier(textDocument)
};
}
function asCodeLensParams(textDocument) {
return {
textDocument: asTextDocumentIdentifier(textDocument)
};
}
function asDocumentLink(item) {
let result = proto.DocumentLink.create(asRange2(item.range));
if (item.target) {
result.target = asUri(item.target);
}
if (item.tooltip !== void 0) {
result.tooltip = item.tooltip;
}
let protocolItem = item instanceof protocolDocumentLink_1.default ? item : void 0;
if (protocolItem && protocolItem.data) {
result.data = protocolItem.data;
}
return result;
}
function asDocumentLinkParams(textDocument) {
return {
textDocument: asTextDocumentIdentifier(textDocument)
};
}
function asCallHierarchyItem(value) {
const result = {
name: value.name,
kind: asSymbolKind(value.kind),
uri: asUri(value.uri),
range: asRange2(value.range),
selectionRange: asRange2(value.selectionRange)
};
if (value.detail !== void 0 && value.detail.length > 0) {
result.detail = value.detail;
}
if (value.tags !== void 0) {
result.tags = asSymbolTags(value.tags);
}
if (value instanceof protocolCallHierarchyItem_1.default && value.data !== void 0) {
result.data = value.data;
}
return result;
}
function asTypeHierarchyItem(value) {
const result = {
name: value.name,
kind: asSymbolKind(value.kind),
uri: asUri(value.uri),
range: asRange2(value.range),
selectionRange: asRange2(value.selectionRange)
};
if (value.detail !== void 0 && value.detail.length > 0) {
result.detail = value.detail;
}
if (value.tags !== void 0) {
result.tags = asSymbolTags(value.tags);
}
if (value instanceof protocolTypeHierarchyItem_1.default && value.data !== void 0) {
result.data = value.data;
}
return result;
}
function asWorkspaceSymbol(item) {
const result = item instanceof protocolWorkspaceSymbol_1.default ? { name: item.name, kind: asSymbolKind(item.kind), location: item.hasRange ? asLocation(item.location) : { uri: _uriConverter(item.location.uri) }, data: item.data } : { name: item.name, kind: asSymbolKind(item.kind), location: asLocation(item.location) };
if (item.tags !== void 0) {
result.tags = asSymbolTags(item.tags);
}
if (item.containerName !== "") {
result.containerName = item.containerName;
}
return result;
}
function asInlayHint(item) {
const label = typeof item.label === "string" ? item.label : item.label.map(asInlayHintLabelPart);
const result = proto.InlayHint.create(asPosition2(item.position), label);
if (item.kind !== void 0) {
result.kind = item.kind;
}
if (item.textEdits !== void 0) {
result.textEdits = asTextEdits(item.textEdits);
}
if (item.tooltip !== void 0) {
result.tooltip = asTooltip(item.tooltip);
}
if (item.paddingLeft !== void 0) {
result.paddingLeft = item.paddingLeft;
}
if (item.paddingRight !== void 0) {
result.paddingRight = item.paddingRight;
}
if (item instanceof protocolInlayHint_1.default && item.data !== void 0) {
result.data = item.data;
}
return result;
}
function asInlayHintLabelPart(item) {
const result = proto.InlayHintLabelPart.create(item.value);
if (item.location !== void 0) {
result.location = asLocation(item.location);
}
if (item.command !== void 0) {
result.command = asCommand(item.command);
}
if (item.tooltip !== void 0) {
result.tooltip = asTooltip(item.tooltip);
}
return result;
}
function asTooltip(value) {
if (typeof value === "string") {
return value;
}
const result = {
kind: proto.MarkupKind.Markdown,
value: value.value
};
return result;
}
return {
asUri,
asTextDocumentIdentifier,
asTextDocumentItem,
asVersionedTextDocumentIdentifier,
asOpenTextDocumentParams,
asChangeTextDocumentParams,
asCloseTextDocumentParams,
asSaveTextDocumentParams,
asWillSaveTextDocumentParams,
asDidCreateFilesParams,
asDidRenameFilesParams,
asDidDeleteFilesParams,
asWillCreateFilesParams,
asWillRenameFilesParams,
asWillDeleteFilesParams,
asTextDocumentPositionParams,
asCompletionParams,
asSignatureHelpParams,
asWorkerPosition,
asRange: asRange2,
asRanges,
asPosition: asPosition2,
asPositions,
asPositionsSync,
asLocation,
asDiagnosticSeverity,
asDiagnosticTag,
asDiagnostic,
asDiagnostics,
asDiagnosticsSync,
asCompletionItem,
asTextEdit,
asSymbolKind,
asSymbolTag,
asSymbolTags,
asReferenceParams,
asCodeAction,
asCodeActionSync,
asCodeActionContext,
asCodeActionContextSync,
asInlineValueContext,
asCommand,
asCodeLens,
asFormattingOptions,
asDocumentSymbolParams,
asCodeLensParams,
asDocumentLink,
asDocumentLinkParams,
asCallHierarchyItem,
asTypeHierarchyItem,
asInlayHint,
asWorkspaceSymbol,
asInlineCompletionParams
};
}
exports2.createConverter = createConverter;
}
});
// node_modules/vscode-languageclient/lib/common/protocolConverter.js
var require_protocolConverter = __commonJS({
"node_modules/vscode-languageclient/lib/common/protocolConverter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.createConverter = void 0;
var code = require("vscode");
var ls = require_main3();
var Is = require_is();
var async = require_async();
var protocolCompletionItem_1 = require_protocolCompletionItem();
var protocolCodeLens_1 = require_protocolCodeLens();
var protocolDocumentLink_1 = require_protocolDocumentLink();
var protocolCodeAction_1 = require_protocolCodeAction();
var protocolDiagnostic_1 = require_protocolDiagnostic();
var protocolCallHierarchyItem_1 = require_protocolCallHierarchyItem();
var protocolTypeHierarchyItem_1 = require_protocolTypeHierarchyItem();
var protocolWorkspaceSymbol_1 = require_protocolWorkspaceSymbol();
var protocolInlayHint_1 = require_protocolInlayHint();
var vscode_languageserver_protocol_1 = require_main3();
var CodeBlock;
(function(CodeBlock2) {
function is(value) {
let candidate = value;
return candidate && Is.string(candidate.language) && Is.string(candidate.value);
}
CodeBlock2.is = is;
})(CodeBlock || (CodeBlock = {}));
function createConverter(uriConverter, trustMarkdown, supportHtml) {
const nullConverter = (value) => code.Uri.parse(value);
const _uriConverter = uriConverter || nullConverter;
function asUri(value) {
return _uriConverter(value);
}
function asDocumentSelector(selector) {
const result = [];
for (const filter of selector) {
if (typeof filter === "string") {
result.push(filter);
} else if (vscode_languageserver_protocol_1.NotebookCellTextDocumentFilter.is(filter)) {
if (typeof filter.notebook === "string") {
result.push({ notebookType: filter.notebook, language: filter.language });
} else {
const notebookType = filter.notebook.notebookType ?? "*";
result.push({ notebookType, scheme: filter.notebook.scheme, pattern: filter.notebook.pattern, language: filter.language });
}
} else if (vscode_languageserver_protocol_1.TextDocumentFilter.is(filter)) {
result.push({ language: filter.language, scheme: filter.scheme, pattern: filter.pattern });
}
}
return result;
}
async function asDiagnostics(diagnostics, token) {
return async.map(diagnostics, asDiagnostic, token);
}
function asDiagnosticsSync(diagnostics) {
const result = new Array(diagnostics.length);
for (let i = 0; i < diagnostics.length; i++) {
result[i] = asDiagnostic(diagnostics[i]);
}
return result;
}
function asDiagnostic(diagnostic) {
let result = new protocolDiagnostic_1.ProtocolDiagnostic(asRange2(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity), diagnostic.data);
if (diagnostic.code !== void 0) {
if (typeof diagnostic.code === "string" || typeof diagnostic.code === "number") {
if (ls.CodeDescription.is(diagnostic.codeDescription)) {
result.code = {
value: diagnostic.code,
target: asUri(diagnostic.codeDescription.href)
};
} else {
result.code = diagnostic.code;
}
} else if (protocolDiagnostic_1.DiagnosticCode.is(diagnostic.code)) {
result.hasDiagnosticCode = true;
const diagnosticCode = diagnostic.code;
result.code = {
value: diagnosticCode.value,
target: asUri(diagnosticCode.target)
};
}
}
if (diagnostic.source) {
result.source = diagnostic.source;
}
if (diagnostic.relatedInformation) {
result.relatedInformation = asRelatedInformation(diagnostic.relatedInformation);
}
if (Array.isArray(diagnostic.tags)) {
result.tags = asDiagnosticTags(diagnostic.tags);
}
return result;
}
function asRelatedInformation(relatedInformation) {
const result = new Array(relatedInformation.length);
for (let i = 0; i < relatedInformation.length; i++) {
const info = relatedInformation[i];
result[i] = new code.DiagnosticRelatedInformation(asLocation(info.location), info.message);
}
return result;
}
function asDiagnosticTags(tags) {
if (!tags) {
return void 0;
}
let result = [];
for (let tag of tags) {
let converted = asDiagnosticTag(tag);
if (converted !== void 0) {
result.push(converted);
}
}
return result.length > 0 ? result : void 0;
}
function asDiagnosticTag(tag) {
switch (tag) {
case ls.DiagnosticTag.Unnecessary:
return code.DiagnosticTag.Unnecessary;
case ls.DiagnosticTag.Deprecated:
return code.DiagnosticTag.Deprecated;
default:
return void 0;
}
}
function asPosition2(value) {
return value ? new code.Position(value.line, value.character) : void 0;
}
function asRange2(value) {
return value ? new code.Range(value.start.line, value.start.character, value.end.line, value.end.character) : void 0;
}
async function asRanges(items, token) {
return async.map(items, (range) => {
return new code.Range(range.start.line, range.start.character, range.end.line, range.end.character);
}, token);
}
function asDiagnosticSeverity(value) {
if (value === void 0 || value === null) {
return code.DiagnosticSeverity.Error;
}
switch (value) {
case ls.DiagnosticSeverity.Error:
return code.DiagnosticSeverity.Error;
case ls.DiagnosticSeverity.Warning:
return code.DiagnosticSeverity.Warning;
case ls.DiagnosticSeverity.Information:
return code.DiagnosticSeverity.Information;
case ls.DiagnosticSeverity.Hint:
return code.DiagnosticSeverity.Hint;
}
return code.DiagnosticSeverity.Error;
}
function asHoverContent(value) {
if (Is.string(value)) {
return asMarkdownString(value);
} else if (CodeBlock.is(value)) {
let result = asMarkdownString();
return result.appendCodeblock(value.value, value.language);
} else if (Array.isArray(value)) {
let result = [];
for (let element of value) {
let item = asMarkdownString();
if (CodeBlock.is(element)) {
item.appendCodeblock(element.value, element.language);
} else {
item.appendMarkdown(element);
}
result.push(item);
}
return result;
} else {
return asMarkdownString(value);
}
}
function asDocumentation(value) {
if (Is.string(value)) {
return value;
} else {
switch (value.kind) {
case ls.MarkupKind.Markdown:
return asMarkdownString(value.value);
case ls.MarkupKind.PlainText:
return value.value;
default:
return `Unsupported Markup content received. Kind is: ${value.kind}`;
}
}
}
function asMarkdownString(value) {
let result;
if (value === void 0 || typeof value === "string") {
result = new code.MarkdownString(value);
} else {
switch (value.kind) {
case ls.MarkupKind.Markdown:
result = new code.MarkdownString(value.value);
break;
case ls.MarkupKind.PlainText:
result = new code.MarkdownString();
result.appendText(value.value);
break;
default:
result = new code.MarkdownString();
result.appendText(`Unsupported Markup content received. Kind is: ${value.kind}`);
break;
}
}
result.isTrusted = trustMarkdown;
result.supportHtml = supportHtml;
return result;
}
function asHover(hover) {
if (!hover) {
return void 0;
}
return new code.Hover(asHoverContent(hover.contents), asRange2(hover.range));
}
async function asCompletionResult(value, allCommitCharacters, token) {
if (!value) {
return void 0;
}
if (Array.isArray(value)) {
return async.map(value, (item) => asCompletionItem(item, allCommitCharacters), token);
}
const list = value;
const { defaultRange, commitCharacters } = getCompletionItemDefaults(list, allCommitCharacters);
const converted = await async.map(list.items, (item) => {
return asCompletionItem(item, commitCharacters, defaultRange, list.itemDefaults?.insertTextMode, list.itemDefaults?.insertTextFormat, list.itemDefaults?.data);
}, token);
return new code.CompletionList(converted, list.isIncomplete);
}
function getCompletionItemDefaults(list, allCommitCharacters) {
const rangeDefaults = list.itemDefaults?.editRange;
const commitCharacters = list.itemDefaults?.commitCharacters ?? allCommitCharacters;
return ls.Range.is(rangeDefaults) ? { defaultRange: asRange2(rangeDefaults), commitCharacters } : rangeDefaults !== void 0 ? { defaultRange: { inserting: asRange2(rangeDefaults.insert), replacing: asRange2(rangeDefaults.replace) }, commitCharacters } : { defaultRange: void 0, commitCharacters };
}
function asCompletionItemKind(value) {
if (ls.CompletionItemKind.Text <= value && value <= ls.CompletionItemKind.TypeParameter) {
return [value - 1, void 0];
}
return [code.CompletionItemKind.Text, value];
}
function asCompletionItemTag(tag) {
switch (tag) {
case ls.CompletionItemTag.Deprecated:
return code.CompletionItemTag.Deprecated;
}
return void 0;
}
function asCompletionItemTags(tags) {
if (tags === void 0 || tags === null) {
return [];
}
const result = [];
for (const tag of tags) {
const converted = asCompletionItemTag(tag);
if (converted !== void 0) {
result.push(converted);
}
}
return result;
}
function asCompletionItem(item, defaultCommitCharacters, defaultRange, defaultInsertTextMode, defaultInsertTextFormat, defaultData) {
const tags = asCompletionItemTags(item.tags);
const label = asCompletionItemLabel(item);
const result = new protocolCompletionItem_1.default(label);
if (item.detail) {
result.detail = item.detail;
}
if (item.documentation) {
result.documentation = asDocumentation(item.documentation);
result.documentationFormat = Is.string(item.documentation) ? "$string" : item.documentation.kind;
}
if (item.filterText) {
result.filterText = item.filterText;
}
const insertText = asCompletionInsertText(item, defaultRange, defaultInsertTextFormat);
if (insertText) {
result.insertText = insertText.text;
result.range = insertText.range;
result.fromEdit = insertText.fromEdit;
}
if (Is.number(item.kind)) {
let [itemKind, original] = asCompletionItemKind(item.kind);
result.kind = itemKind;
if (original) {
result.originalItemKind = original;
}
}
if (item.sortText) {
result.sortText = item.sortText;
}
if (item.additionalTextEdits) {
result.additionalTextEdits = asTextEditsSync(item.additionalTextEdits);
}
const commitCharacters = item.commitCharacters !== void 0 ? Is.stringArray(item.commitCharacters) ? item.commitCharacters : void 0 : defaultCommitCharacters;
if (commitCharacters) {
result.commitCharacters = commitCharacters.slice();
}
if (item.command) {
result.command = asCommand(item.command);
}
if (item.deprecated === true || item.deprecated === false) {
result.deprecated = item.deprecated;
if (item.deprecated === true) {
tags.push(code.CompletionItemTag.Deprecated);
}
}
if (item.preselect === true || item.preselect === false) {
result.preselect = item.preselect;
}
const data = item.data ?? defaultData;
if (data !== void 0) {
result.data = data;
}
if (tags.length > 0) {
result.tags = tags;
}
const insertTextMode = item.insertTextMode ?? defaultInsertTextMode;
if (insertTextMode !== void 0) {
result.insertTextMode = insertTextMode;
if (insertTextMode === ls.InsertTextMode.asIs) {
result.keepWhitespace = true;
}
}
return result;
}
function asCompletionItemLabel(item) {
if (ls.CompletionItemLabelDetails.is(item.labelDetails)) {
return {
label: item.label,
detail: item.labelDetails.detail,
description: item.labelDetails.description
};
} else {
return item.label;
}
}
function asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
const insertTextFormat = item.insertTextFormat ?? defaultInsertTextFormat;
if (item.textEdit !== void 0 || defaultRange !== void 0) {
const [range, newText] = item.textEdit !== void 0 ? getCompletionRangeAndText(item.textEdit) : [defaultRange, item.textEditText ?? item.label];
if (insertTextFormat === ls.InsertTextFormat.Snippet) {
return { text: new code.SnippetString(newText), range, fromEdit: true };
} else {
return { text: newText, range, fromEdit: true };
}
} else if (item.insertText) {
if (insertTextFormat === ls.InsertTextFormat.Snippet) {
return { text: new code.SnippetString(item.insertText), fromEdit: false };
} else {
return { text: item.insertText, fromEdit: false };
}
} else {
return void 0;
}
}
function getCompletionRangeAndText(value) {
if (ls.InsertReplaceEdit.is(value)) {
return [{ inserting: asRange2(value.insert), replacing: asRange2(value.replace) }, value.newText];
} else {
return [asRange2(value.range), value.newText];
}
}
function asTextEdit(edit) {
if (!edit) {
return void 0;
}
return new code.TextEdit(asRange2(edit.range), edit.newText);
}
async function asTextEdits(items, token) {
if (!items) {
return void 0;
}
return async.map(items, asTextEdit, token);
}
function asTextEditsSync(items) {
if (!items) {
return void 0;
}
const result = new Array(items.length);
for (let i = 0; i < items.length; i++) {
result[i] = asTextEdit(items[i]);
}
return result;
}
async function asSignatureHelp(item, token) {
if (!item) {
return void 0;
}
let result = new code.SignatureHelp();
if (Is.number(item.activeSignature)) {
result.activeSignature = item.activeSignature;
} else {
result.activeSignature = 0;
}
if (Is.number(item.activeParameter)) {
result.activeParameter = item.activeParameter;
} else {
result.activeParameter = 0;
}
if (item.signatures) {
result.signatures = await asSignatureInformations(item.signatures, token);
}
return result;
}
async function asSignatureInformations(items, token) {
return async.mapAsync(items, asSignatureInformation, token);
}
async function asSignatureInformation(item, token) {
let result = new code.SignatureInformation(item.label);
if (item.documentation !== void 0) {
result.documentation = asDocumentation(item.documentation);
}
if (item.parameters !== void 0) {
result.parameters = await asParameterInformations(item.parameters, token);
}
if (item.activeParameter !== void 0) {
result.activeParameter = item.activeParameter;
}
{
return result;
}
}
function asParameterInformations(items, token) {
return async.map(items, asParameterInformation, token);
}
function asParameterInformation(item) {
let result = new code.ParameterInformation(item.label);
if (item.documentation) {
result.documentation = asDocumentation(item.documentation);
}
return result;
}
function asLocation(item) {
return item ? new code.Location(_uriConverter(item.uri), asRange2(item.range)) : void 0;
}
async function asDeclarationResult(item, token) {
if (!item) {
return void 0;
}
return asLocationResult(item, token);
}
async function asDefinitionResult(item, token) {
if (!item) {
return void 0;
}
return asLocationResult(item, token);
}
function asLocationLink(item) {
if (!item) {
return void 0;
}
let result = {
targetUri: _uriConverter(item.targetUri),
targetRange: asRange2(item.targetRange),
originSelectionRange: asRange2(item.originSelectionRange),
targetSelectionRange: asRange2(item.targetSelectionRange)
};
if (!result.targetSelectionRange) {
throw new Error(`targetSelectionRange must not be undefined or null`);
}
return result;
}
async function asLocationResult(item, token) {
if (!item) {
return void 0;
}
if (Is.array(item)) {
if (item.length === 0) {
return [];
} else if (ls.LocationLink.is(item[0])) {
const links = item;
return async.map(links, asLocationLink, token);
} else {
const locations = item;
return async.map(locations, asLocation, token);
}
} else if (ls.LocationLink.is(item)) {
return [asLocationLink(item)];
} else {
return asLocation(item);
}
}
async function asReferences(values, token) {
if (!values) {
return void 0;
}
return async.map(values, asLocation, token);
}
async function asDocumentHighlights(values, token) {
if (!values) {
return void 0;
}
return async.map(values, asDocumentHighlight, token);
}
function asDocumentHighlight(item) {
let result = new code.DocumentHighlight(asRange2(item.range));
if (Is.number(item.kind)) {
result.kind = asDocumentHighlightKind(item.kind);
}
return result;
}
function asDocumentHighlightKind(item) {
switch (item) {
case ls.DocumentHighlightKind.Text:
return code.DocumentHighlightKind.Text;
case ls.DocumentHighlightKind.Read:
return code.DocumentHighlightKind.Read;
case ls.DocumentHighlightKind.Write:
return code.DocumentHighlightKind.Write;
}
return code.DocumentHighlightKind.Text;
}
async function asSymbolInformations(values, token) {
if (!values) {
return void 0;
}
return async.map(values, asSymbolInformation, token);
}
function asSymbolKind(item) {
if (item <= ls.SymbolKind.TypeParameter) {
return item - 1;
}
return code.SymbolKind.Property;
}
function asSymbolTag(value) {
switch (value) {
case ls.SymbolTag.Deprecated:
return code.SymbolTag.Deprecated;
default:
return void 0;
}
}
function asSymbolTags(items) {
if (items === void 0 || items === null) {
return void 0;
}
const result = [];
for (const item of items) {
const converted = asSymbolTag(item);
if (converted !== void 0) {
result.push(converted);
}
}
return result.length === 0 ? void 0 : result;
}
function asSymbolInformation(item) {
const data = item.data;
const location2 = item.location;
const result = location2.range === void 0 || data !== void 0 ? new protocolWorkspaceSymbol_1.default(item.name, asSymbolKind(item.kind), item.containerName ?? "", location2.range === void 0 ? _uriConverter(location2.uri) : new code.Location(_uriConverter(item.location.uri), asRange2(location2.range)), data) : new code.SymbolInformation(item.name, asSymbolKind(item.kind), item.containerName ?? "", new code.Location(_uriConverter(item.location.uri), asRange2(location2.range)));
fillTags(result, item);
return result;
}
async function asDocumentSymbols(values, token) {
if (values === void 0 || values === null) {
return void 0;
}
return async.map(values, asDocumentSymbol, token);
}
function asDocumentSymbol(value) {
let result = new code.DocumentSymbol(value.name, value.detail || "", asSymbolKind(value.kind), asRange2(value.range), asRange2(value.selectionRange));
fillTags(result, value);
if (value.children !== void 0 && value.children.length > 0) {
let children = [];
for (let child of value.children) {
children.push(asDocumentSymbol(child));
}
result.children = children;
}
return result;
}
function fillTags(result, value) {
result.tags = asSymbolTags(value.tags);
if (value.deprecated) {
if (!result.tags) {
result.tags = [code.SymbolTag.Deprecated];
} else {
if (!result.tags.includes(code.SymbolTag.Deprecated)) {
result.tags = result.tags.concat(code.SymbolTag.Deprecated);
}
}
}
}
function asCommand(item) {
let result = { title: item.title, command: item.command };
if (item.arguments) {
result.arguments = item.arguments;
}
return result;
}
async function asCommands(items, token) {
if (!items) {
return void 0;
}
return async.map(items, asCommand, token);
}
const kindMapping = /* @__PURE__ */ new Map();
kindMapping.set(ls.CodeActionKind.Empty, code.CodeActionKind.Empty);
kindMapping.set(ls.CodeActionKind.QuickFix, code.CodeActionKind.QuickFix);
kindMapping.set(ls.CodeActionKind.Refactor, code.CodeActionKind.Refactor);
kindMapping.set(ls.CodeActionKind.RefactorExtract, code.CodeActionKind.RefactorExtract);
kindMapping.set(ls.CodeActionKind.RefactorInline, code.CodeActionKind.RefactorInline);
kindMapping.set(ls.CodeActionKind.RefactorRewrite, code.CodeActionKind.RefactorRewrite);
kindMapping.set(ls.CodeActionKind.Source, code.CodeActionKind.Source);
kindMapping.set(ls.CodeActionKind.SourceOrganizeImports, code.CodeActionKind.SourceOrganizeImports);
function asCodeActionKind(item) {
if (item === void 0 || item === null) {
return void 0;
}
let result = kindMapping.get(item);
if (result) {
return result;
}
let parts = item.split(".");
result = code.CodeActionKind.Empty;
for (let part of parts) {
result = result.append(part);
}
return result;
}
function asCodeActionKinds(items) {
if (items === void 0 || items === null) {
return void 0;
}
return items.map((kind) => asCodeActionKind(kind));
}
async function asCodeAction(item, token) {
if (item === void 0 || item === null) {
return void 0;
}
let result = new protocolCodeAction_1.default(item.title, item.data);
if (item.kind !== void 0) {
result.kind = asCodeActionKind(item.kind);
}
if (item.diagnostics !== void 0) {
result.diagnostics = asDiagnosticsSync(item.diagnostics);
}
if (item.edit !== void 0) {
result.edit = await asWorkspaceEdit(item.edit, token);
}
if (item.command !== void 0) {
result.command = asCommand(item.command);
}
if (item.isPreferred !== void 0) {
result.isPreferred = item.isPreferred;
}
if (item.disabled !== void 0) {
result.disabled = { reason: item.disabled.reason };
}
return result;
}
function asCodeActionResult(items, token) {
return async.mapAsync(items, async (item) => {
if (ls.Command.is(item)) {
return asCommand(item);
} else {
return asCodeAction(item, token);
}
}, token);
}
function asCodeLens(item) {
if (!item) {
return void 0;
}
let result = new protocolCodeLens_1.default(asRange2(item.range));
if (item.command) {
result.command = asCommand(item.command);
}
if (item.data !== void 0 && item.data !== null) {
result.data = item.data;
}
return result;
}
async function asCodeLenses(items, token) {
if (!items) {
return void 0;
}
return async.map(items, asCodeLens, token);
}
async function asWorkspaceEdit(item, token) {
if (!item) {
return void 0;
}
const sharedMetadata = /* @__PURE__ */ new Map();
if (item.changeAnnotations !== void 0) {
const changeAnnotations = item.changeAnnotations;
await async.forEach(Object.keys(changeAnnotations), (key) => {
const metaData = asWorkspaceEditEntryMetadata(changeAnnotations[key]);
sharedMetadata.set(key, metaData);
}, token);
}
const asMetadata = (annotation) => {
if (annotation === void 0) {
return void 0;
} else {
return sharedMetadata.get(annotation);
}
};
const result = new code.WorkspaceEdit();
if (item.documentChanges) {
const documentChanges = item.documentChanges;
await async.forEach(documentChanges, (change) => {
if (ls.CreateFile.is(change)) {
result.createFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
} else if (ls.RenameFile.is(change)) {
result.renameFile(_uriConverter(change.oldUri), _uriConverter(change.newUri), change.options, asMetadata(change.annotationId));
} else if (ls.DeleteFile.is(change)) {
result.deleteFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
} else if (ls.TextDocumentEdit.is(change)) {
const uri = _uriConverter(change.textDocument.uri);
for (const edit of change.edits) {
if (ls.AnnotatedTextEdit.is(edit)) {
result.replace(uri, asRange2(edit.range), edit.newText, asMetadata(edit.annotationId));
} else {
result.replace(uri, asRange2(edit.range), edit.newText);
}
}
} else {
throw new Error(`Unknown workspace edit change received:
${JSON.stringify(change, void 0, 4)}`);
}
}, token);
} else if (item.changes) {
const changes = item.changes;
await async.forEach(Object.keys(changes), (key) => {
result.set(_uriConverter(key), asTextEditsSync(changes[key]));
}, token);
}
return result;
}
function asWorkspaceEditEntryMetadata(annotation) {
if (annotation === void 0) {
return void 0;
}
return { label: annotation.label, needsConfirmation: !!annotation.needsConfirmation, description: annotation.description };
}
function asDocumentLink(item) {
let range = asRange2(item.range);
let target = item.target ? asUri(item.target) : void 0;
let link = new protocolDocumentLink_1.default(range, target);
if (item.tooltip !== void 0) {
link.tooltip = item.tooltip;
}
if (item.data !== void 0 && item.data !== null) {
link.data = item.data;
}
return link;
}
async function asDocumentLinks(items, token) {
if (!items) {
return void 0;
}
return async.map(items, asDocumentLink, token);
}
function asColor(color) {
return new code.Color(color.red, color.green, color.blue, color.alpha);
}
function asColorInformation(ci) {
return new code.ColorInformation(asRange2(ci.range), asColor(ci.color));
}
async function asColorInformations(colorInformation, token) {
if (!colorInformation) {
return void 0;
}
return async.map(colorInformation, asColorInformation, token);
}
function asColorPresentation(cp2) {
let presentation = new code.ColorPresentation(cp2.label);
presentation.additionalTextEdits = asTextEditsSync(cp2.additionalTextEdits);
if (cp2.textEdit) {
presentation.textEdit = asTextEdit(cp2.textEdit);
}
return presentation;
}
async function asColorPresentations(colorPresentations, token) {
if (!colorPresentations) {
return void 0;
}
return async.map(colorPresentations, asColorPresentation, token);
}
function asFoldingRangeKind(kind) {
if (kind) {
switch (kind) {
case ls.FoldingRangeKind.Comment:
return code.FoldingRangeKind.Comment;
case ls.FoldingRangeKind.Imports:
return code.FoldingRangeKind.Imports;
case ls.FoldingRangeKind.Region:
return code.FoldingRangeKind.Region;
}
}
return void 0;
}
function asFoldingRange(r) {
return new code.FoldingRange(r.startLine, r.endLine, asFoldingRangeKind(r.kind));
}
async function asFoldingRanges(foldingRanges, token) {
if (!foldingRanges) {
return void 0;
}
return async.map(foldingRanges, asFoldingRange, token);
}
function asSelectionRange(selectionRange) {
return new code.SelectionRange(asRange2(selectionRange.range), selectionRange.parent ? asSelectionRange(selectionRange.parent) : void 0);
}
async function asSelectionRanges(selectionRanges, token) {
if (!Array.isArray(selectionRanges)) {
return [];
}
return async.map(selectionRanges, asSelectionRange, token);
}
function asInlineValue(inlineValue) {
if (ls.InlineValueText.is(inlineValue)) {
return new code.InlineValueText(asRange2(inlineValue.range), inlineValue.text);
} else if (ls.InlineValueVariableLookup.is(inlineValue)) {
return new code.InlineValueVariableLookup(asRange2(inlineValue.range), inlineValue.variableName, inlineValue.caseSensitiveLookup);
} else {
return new code.InlineValueEvaluatableExpression(asRange2(inlineValue.range), inlineValue.expression);
}
}
async function asInlineValues(inlineValues, token) {
if (!Array.isArray(inlineValues)) {
return [];
}
return async.map(inlineValues, asInlineValue, token);
}
async function asInlayHint(value, token) {
const label = typeof value.label === "string" ? value.label : await async.map(value.label, asInlayHintLabelPart, token);
const result = new protocolInlayHint_1.default(asPosition2(value.position), label);
if (value.kind !== void 0) {
result.kind = value.kind;
}
if (value.textEdits !== void 0) {
result.textEdits = await asTextEdits(value.textEdits, token);
}
if (value.tooltip !== void 0) {
result.tooltip = asTooltip(value.tooltip);
}
if (value.paddingLeft !== void 0) {
result.paddingLeft = value.paddingLeft;
}
if (value.paddingRight !== void 0) {
result.paddingRight = value.paddingRight;
}
if (value.data !== void 0) {
result.data = value.data;
}
return result;
}
function asInlayHintLabelPart(part) {
const result = new code.InlayHintLabelPart(part.value);
if (part.location !== void 0) {
result.location = asLocation(part.location);
}
if (part.tooltip !== void 0) {
result.tooltip = asTooltip(part.tooltip);
}
if (part.command !== void 0) {
result.command = asCommand(part.command);
}
return result;
}
function asTooltip(value) {
if (typeof value === "string") {
return value;
}
return asMarkdownString(value);
}
async function asInlayHints(values, token) {
if (!Array.isArray(values)) {
return void 0;
}
return async.mapAsync(values, asInlayHint, token);
}
function asCallHierarchyItem(item) {
if (item === null) {
return void 0;
}
const result = new protocolCallHierarchyItem_1.default(asSymbolKind(item.kind), item.name, item.detail || "", asUri(item.uri), asRange2(item.range), asRange2(item.selectionRange), item.data);
if (item.tags !== void 0) {
result.tags = asSymbolTags(item.tags);
}
return result;
}
async function asCallHierarchyItems(items, token) {
if (items === null) {
return void 0;
}
return async.map(items, asCallHierarchyItem, token);
}
async function asCallHierarchyIncomingCall(item, token) {
return new code.CallHierarchyIncomingCall(asCallHierarchyItem(item.from), await asRanges(item.fromRanges, token));
}
async function asCallHierarchyIncomingCalls(items, token) {
if (items === null) {
return void 0;
}
return async.mapAsync(items, asCallHierarchyIncomingCall, token);
}
async function asCallHierarchyOutgoingCall(item, token) {
return new code.CallHierarchyOutgoingCall(asCallHierarchyItem(item.to), await asRanges(item.fromRanges, token));
}
async function asCallHierarchyOutgoingCalls(items, token) {
if (items === null) {
return void 0;
}
return async.mapAsync(items, asCallHierarchyOutgoingCall, token);
}
async function asSemanticTokens(value, _token) {
if (value === void 0 || value === null) {
return void 0;
}
return new code.SemanticTokens(new Uint32Array(value.data), value.resultId);
}
function asSemanticTokensEdit(value) {
return new code.SemanticTokensEdit(value.start, value.deleteCount, value.data !== void 0 ? new Uint32Array(value.data) : void 0);
}
async function asSemanticTokensEdits(value, _token) {
if (value === void 0 || value === null) {
return void 0;
}
return new code.SemanticTokensEdits(value.edits.map(asSemanticTokensEdit), value.resultId);
}
function asSemanticTokensLegend(value) {
return value;
}
async function asLinkedEditingRanges(value, token) {
if (value === null || value === void 0) {
return void 0;
}
return new code.LinkedEditingRanges(await asRanges(value.ranges, token), asRegularExpression(value.wordPattern));
}
function asRegularExpression(value) {
if (value === null || value === void 0) {
return void 0;
}
return new RegExp(value);
}
function asTypeHierarchyItem(item) {
if (item === null) {
return void 0;
}
let result = new protocolTypeHierarchyItem_1.default(asSymbolKind(item.kind), item.name, item.detail || "", asUri(item.uri), asRange2(item.range), asRange2(item.selectionRange), item.data);
if (item.tags !== void 0) {
result.tags = asSymbolTags(item.tags);
}
return result;
}
async function asTypeHierarchyItems(items, token) {
if (items === null) {
return void 0;
}
return async.map(items, asTypeHierarchyItem, token);
}
function asGlobPattern(pattern) {
if (Is.string(pattern)) {
return pattern;
}
if (ls.RelativePattern.is(pattern)) {
if (ls.URI.is(pattern.baseUri)) {
return new code.RelativePattern(asUri(pattern.baseUri), pattern.pattern);
} else if (ls.WorkspaceFolder.is(pattern.baseUri)) {
const workspaceFolder = code.workspace.getWorkspaceFolder(asUri(pattern.baseUri.uri));
return workspaceFolder !== void 0 ? new code.RelativePattern(workspaceFolder, pattern.pattern) : void 0;
}
}
return void 0;
}
async function asInlineCompletionResult(value, token) {
if (!value) {
return void 0;
}
if (Array.isArray(value)) {
return async.map(value, (item) => asInlineCompletionItem(item), token);
}
const list = value;
const converted = await async.map(list.items, (item) => {
return asInlineCompletionItem(item);
}, token);
return new code.InlineCompletionList(converted);
}
function asInlineCompletionItem(item) {
let insertText;
if (typeof item.insertText === "string") {
insertText = item.insertText;
} else {
insertText = new code.SnippetString(item.insertText.value);
}
let command = void 0;
if (item.command) {
command = asCommand(item.command);
}
const inlineCompletionItem = new code.InlineCompletionItem(insertText, asRange2(item.range), command);
if (item.filterText) {
inlineCompletionItem.filterText = item.filterText;
}
return inlineCompletionItem;
}
return {
asUri,
asDocumentSelector,
asDiagnostics,
asDiagnostic,
asRange: asRange2,
asRanges,
asPosition: asPosition2,
asDiagnosticSeverity,
asDiagnosticTag,
asHover,
asCompletionResult,
asCompletionItem,
asTextEdit,
asTextEdits,
asSignatureHelp,
asSignatureInformations,
asSignatureInformation,
asParameterInformations,
asParameterInformation,
asDeclarationResult,
asDefinitionResult,
asLocation,
asReferences,
asDocumentHighlights,
asDocumentHighlight,
asDocumentHighlightKind,
asSymbolKind,
asSymbolTag,
asSymbolTags,
asSymbolInformations,
asSymbolInformation,
asDocumentSymbols,
asDocumentSymbol,
asCommand,
asCommands,
asCodeAction,
asCodeActionKind,
asCodeActionKinds,
asCodeActionResult,
asCodeLens,
asCodeLenses,
asWorkspaceEdit,
asDocumentLink,
asDocumentLinks,
asFoldingRangeKind,
asFoldingRange,
asFoldingRanges,
asColor,
asColorInformation,
asColorInformations,
asColorPresentation,
asColorPresentations,
asSelectionRange,
asSelectionRanges,
asInlineValue,
asInlineValues,
asInlayHint,
asInlayHints,
asSemanticTokensLegend,
asSemanticTokens,
asSemanticTokensEdit,
asSemanticTokensEdits,
asCallHierarchyItem,
asCallHierarchyItems,
asCallHierarchyIncomingCall,
asCallHierarchyIncomingCalls,
asCallHierarchyOutgoingCall,
asCallHierarchyOutgoingCalls,
asLinkedEditingRanges,
asTypeHierarchyItem,
asTypeHierarchyItems,
asGlobPattern,
asInlineCompletionResult,
asInlineCompletionItem
};
}
exports2.createConverter = createConverter;
}
});
// node_modules/vscode-languageclient/lib/common/utils/uuid.js
var require_uuid = __commonJS({
"node_modules/vscode-languageclient/lib/common/utils/uuid.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.generateUuid = exports2.parse = exports2.isUUID = exports2.v4 = exports2.empty = void 0;
var ValueUUID = class {
constructor(_value) {
this._value = _value;
}
asHex() {
return this._value;
}
equals(other) {
return this.asHex() === other.asHex();
}
};
var V4UUID = class _V4UUID extends ValueUUID {
static _oneOf(array) {
return array[Math.floor(array.length * Math.random())];
}
static _randomHex() {
return _V4UUID._oneOf(_V4UUID._chars);
}
constructor() {
super([
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
"-",
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
"-",
"4",
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
"-",
_V4UUID._oneOf(_V4UUID._timeHighBits),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
"-",
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex(),
_V4UUID._randomHex()
].join(""));
}
};
V4UUID._chars = ["0", "1", "2", "3", "4", "5", "6", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
V4UUID._timeHighBits = ["8", "9", "a", "b"];
exports2.empty = new ValueUUID("00000000-0000-0000-0000-000000000000");
function v42() {
return new V4UUID();
}
exports2.v4 = v42;
var _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
function isUUID(value) {
return _UUIDPattern.test(value);
}
exports2.isUUID = isUUID;
function parse(value) {
if (!isUUID(value)) {
throw new Error("invalid uuid");
}
return new ValueUUID(value);
}
exports2.parse = parse;
function generateUuid() {
return v42().asHex();
}
exports2.generateUuid = generateUuid;
}
});
// node_modules/vscode-languageclient/lib/common/progressPart.js
var require_progressPart = __commonJS({
"node_modules/vscode-languageclient/lib/common/progressPart.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProgressPart = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var Is = require_is();
var ProgressPart = class {
constructor(_client, _token, done) {
this._client = _client;
this._token = _token;
this._reported = 0;
this._infinite = false;
this._lspProgressDisposable = this._client.onProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, (value) => {
switch (value.kind) {
case "begin":
this.begin(value);
break;
case "report":
this.report(value);
break;
case "end":
this.done();
done && done(this);
break;
}
});
}
begin(params) {
this._infinite = params.percentage === void 0;
if (this._lspProgressDisposable === void 0) {
return;
}
void vscode_1.window.withProgress({ location: vscode_1.ProgressLocation.Window, cancellable: params.cancellable, title: params.title }, async (progress, cancellationToken) => {
if (this._lspProgressDisposable === void 0) {
return;
}
this._progress = progress;
this._cancellationToken = cancellationToken;
this._tokenDisposable = this._cancellationToken.onCancellationRequested(() => {
this._client.sendNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, { token: this._token });
});
this.report(params);
return new Promise((resolve3, reject) => {
this._resolve = resolve3;
this._reject = reject;
});
});
}
report(params) {
if (this._infinite && Is.string(params.message)) {
this._progress !== void 0 && this._progress.report({ message: params.message });
} else if (Is.number(params.percentage)) {
const percentage = Math.max(0, Math.min(params.percentage, 100));
const delta = Math.max(0, percentage - this._reported);
this._reported += delta;
this._progress !== void 0 && this._progress.report({ message: params.message, increment: delta });
}
}
cancel() {
this.cleanup();
if (this._reject !== void 0) {
this._reject();
this._resolve = void 0;
this._reject = void 0;
}
}
done() {
this.cleanup();
if (this._resolve !== void 0) {
this._resolve();
this._resolve = void 0;
this._reject = void 0;
}
}
cleanup() {
if (this._lspProgressDisposable !== void 0) {
this._lspProgressDisposable.dispose();
this._lspProgressDisposable = void 0;
}
if (this._tokenDisposable !== void 0) {
this._tokenDisposable.dispose();
this._tokenDisposable = void 0;
}
this._progress = void 0;
this._cancellationToken = void 0;
}
};
exports2.ProgressPart = ProgressPart;
}
});
// node_modules/vscode-languageclient/lib/common/features.js
var require_features = __commonJS({
"node_modules/vscode-languageclient/lib/common/features.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WorkspaceFeature = exports2.TextDocumentLanguageFeature = exports2.TextDocumentEventFeature = exports2.DynamicDocumentFeature = exports2.DynamicFeature = exports2.StaticFeature = exports2.ensure = exports2.LSPCancellationError = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var Is = require_is();
var UUID = require_uuid();
var LSPCancellationError = class extends vscode_1.CancellationError {
constructor(data) {
super();
this.data = data;
}
};
exports2.LSPCancellationError = LSPCancellationError;
function ensure(target, key) {
if (target[key] === void 0) {
target[key] = {};
}
return target[key];
}
exports2.ensure = ensure;
var StaticFeature;
(function(StaticFeature2) {
function is(value) {
const candidate = value;
return candidate !== void 0 && candidate !== null && Is.func(candidate.fillClientCapabilities) && Is.func(candidate.initialize) && Is.func(candidate.getState) && Is.func(candidate.clear) && (candidate.fillInitializeParams === void 0 || Is.func(candidate.fillInitializeParams));
}
StaticFeature2.is = is;
})(StaticFeature || (exports2.StaticFeature = StaticFeature = {}));
var DynamicFeature;
(function(DynamicFeature2) {
function is(value) {
const candidate = value;
return candidate !== void 0 && candidate !== null && Is.func(candidate.fillClientCapabilities) && Is.func(candidate.initialize) && Is.func(candidate.getState) && Is.func(candidate.clear) && (candidate.fillInitializeParams === void 0 || Is.func(candidate.fillInitializeParams)) && Is.func(candidate.register) && Is.func(candidate.unregister) && candidate.registrationType !== void 0;
}
DynamicFeature2.is = is;
})(DynamicFeature || (exports2.DynamicFeature = DynamicFeature = {}));
var DynamicDocumentFeature = class {
constructor(client) {
this._client = client;
}
/**
* Returns the state the feature is in.
*/
getState() {
const selectors = this.getDocumentSelectors();
let count = 0;
for (const selector of selectors) {
count++;
for (const document of vscode_1.workspace.textDocuments) {
if (vscode_1.languages.match(selector, document) > 0) {
return { kind: "document", id: this.registrationType.method, registrations: true, matches: true };
}
}
}
const registrations = count > 0;
return { kind: "document", id: this.registrationType.method, registrations, matches: false };
}
};
exports2.DynamicDocumentFeature = DynamicDocumentFeature;
var TextDocumentEventFeature = class extends DynamicDocumentFeature {
static textDocumentFilter(selectors, textDocument) {
for (const selector of selectors) {
if (vscode_1.languages.match(selector, textDocument) > 0) {
return true;
}
}
return false;
}
constructor(client, event, type, middleware, createParams, textDocument, selectorFilter) {
super(client);
this._event = event;
this._type = type;
this._middleware = middleware;
this._createParams = createParams;
this._textDocument = textDocument;
this._selectorFilter = selectorFilter;
this._selectors = /* @__PURE__ */ new Map();
this._onNotificationSent = new vscode_1.EventEmitter();
}
getStateInfo() {
return [this._selectors.values(), false];
}
getDocumentSelectors() {
return this._selectors.values();
}
register(data) {
if (!data.registerOptions.documentSelector) {
return;
}
if (!this._listener) {
this._listener = this._event((data2) => {
this.callback(data2).catch((error) => {
this._client.error(`Sending document notification ${this._type.method} failed.`, error);
});
});
}
this._selectors.set(data.id, this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector));
}
async callback(data) {
const doSend = async (data2) => {
const params = this._createParams(data2);
await this._client.sendNotification(this._type, params);
this.notificationSent(this.getTextDocument(data2), this._type, params);
};
if (this.matches(data)) {
const middleware = this._middleware();
return middleware ? middleware(data, (data2) => doSend(data2)) : doSend(data);
}
}
matches(data) {
if (this._client.hasDedicatedTextSynchronizationFeature(this._textDocument(data))) {
return false;
}
return !this._selectorFilter || this._selectorFilter(this._selectors.values(), data);
}
get onNotificationSent() {
return this._onNotificationSent.event;
}
notificationSent(textDocument, type, params) {
this._onNotificationSent.fire({ textDocument, type, params });
}
unregister(id) {
this._selectors.delete(id);
if (this._selectors.size === 0 && this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
clear() {
this._selectors.clear();
this._onNotificationSent.dispose();
if (this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
getProvider(document) {
for (const selector of this._selectors.values()) {
if (vscode_1.languages.match(selector, document) > 0) {
return {
send: (data) => {
return this.callback(data);
}
};
}
}
return void 0;
}
};
exports2.TextDocumentEventFeature = TextDocumentEventFeature;
var TextDocumentLanguageFeature = class extends DynamicDocumentFeature {
constructor(client, registrationType) {
super(client);
this._registrationType = registrationType;
this._registrations = /* @__PURE__ */ new Map();
}
*getDocumentSelectors() {
for (const registration of this._registrations.values()) {
const selector = registration.data.registerOptions.documentSelector;
if (selector === null) {
continue;
}
yield this._client.protocol2CodeConverter.asDocumentSelector(selector);
}
}
get registrationType() {
return this._registrationType;
}
register(data) {
if (!data.registerOptions.documentSelector) {
return;
}
let registration = this.registerLanguageProvider(data.registerOptions, data.id);
this._registrations.set(data.id, { disposable: registration[0], data, provider: registration[1] });
}
unregister(id) {
let registration = this._registrations.get(id);
if (registration !== void 0) {
registration.disposable.dispose();
}
}
clear() {
this._registrations.forEach((value) => {
value.disposable.dispose();
});
this._registrations.clear();
}
getRegistration(documentSelector2, capability) {
if (!capability) {
return [void 0, void 0];
} else if (vscode_languageserver_protocol_1.TextDocumentRegistrationOptions.is(capability)) {
const id = vscode_languageserver_protocol_1.StaticRegistrationOptions.hasId(capability) ? capability.id : UUID.generateUuid();
const selector = capability.documentSelector ?? documentSelector2;
if (selector) {
return [id, Object.assign({}, capability, { documentSelector: selector })];
}
} else if (Is.boolean(capability) && capability === true || vscode_languageserver_protocol_1.WorkDoneProgressOptions.is(capability)) {
if (!documentSelector2) {
return [void 0, void 0];
}
const options = Is.boolean(capability) && capability === true ? { documentSelector: documentSelector2 } : Object.assign({}, capability, { documentSelector: documentSelector2 });
return [UUID.generateUuid(), options];
}
return [void 0, void 0];
}
getRegistrationOptions(documentSelector2, capability) {
if (!documentSelector2 || !capability) {
return void 0;
}
return Is.boolean(capability) && capability === true ? { documentSelector: documentSelector2 } : Object.assign({}, capability, { documentSelector: documentSelector2 });
}
getProvider(textDocument) {
for (const registration of this._registrations.values()) {
let selector = registration.data.registerOptions.documentSelector;
if (selector !== null && vscode_1.languages.match(this._client.protocol2CodeConverter.asDocumentSelector(selector), textDocument) > 0) {
return registration.provider;
}
}
return void 0;
}
getAllProviders() {
const result = [];
for (const item of this._registrations.values()) {
result.push(item.provider);
}
return result;
}
};
exports2.TextDocumentLanguageFeature = TextDocumentLanguageFeature;
var WorkspaceFeature = class {
constructor(client, registrationType) {
this._client = client;
this._registrationType = registrationType;
this._registrations = /* @__PURE__ */ new Map();
}
getState() {
const registrations = this._registrations.size > 0;
return { kind: "workspace", id: this._registrationType.method, registrations };
}
get registrationType() {
return this._registrationType;
}
register(data) {
const registration = this.registerLanguageProvider(data.registerOptions);
this._registrations.set(data.id, { disposable: registration[0], provider: registration[1] });
}
unregister(id) {
let registration = this._registrations.get(id);
if (registration !== void 0) {
registration.disposable.dispose();
}
}
clear() {
this._registrations.forEach((registration) => {
registration.disposable.dispose();
});
this._registrations.clear();
}
getProviders() {
const result = [];
for (const registration of this._registrations.values()) {
result.push(registration.provider);
}
return result;
}
};
exports2.WorkspaceFeature = WorkspaceFeature;
}
});
// node_modules/vscode-languageclient/node_modules/minimatch/lib/path.js
var require_path = __commonJS({
"node_modules/vscode-languageclient/node_modules/minimatch/lib/path.js"(exports2, module2) {
var isWindows2 = typeof process === "object" && process && process.platform === "win32";
module2.exports = isWindows2 ? { sep: "\\" } : { sep: "/" };
}
});
// node_modules/balanced-match/index.js
var require_balanced_match = __commonJS({
"node_modules/balanced-match/index.js"(exports2, module2) {
"use strict";
module2.exports = balanced;
function balanced(a, b, str) {
if (a instanceof RegExp) a = maybeMatch(a, str);
if (b instanceof RegExp) b = maybeMatch(b, str);
var r = range(a, b, str);
return r && {
start: r[0],
end: r[1],
pre: str.slice(0, r[0]),
body: str.slice(r[0] + a.length, r[1]),
post: str.slice(r[1] + b.length)
};
}
function maybeMatch(reg, str) {
var m = str.match(reg);
return m ? m[0] : null;
}
balanced.range = range;
function range(a, b, str) {
var begs, beg, left, right, result;
var ai = str.indexOf(a);
var bi = str.indexOf(b, ai + 1);
var i = ai;
if (ai >= 0 && bi > 0) {
if (a === b) {
return [ai, bi];
}
begs = [];
left = str.length;
while (i >= 0 && !result) {
if (i == ai) {
begs.push(i);
ai = str.indexOf(a, i + 1);
} else if (begs.length == 1) {
result = [begs.pop(), bi];
} else {
beg = begs.pop();
if (beg < left) {
left = beg;
right = bi;
}
bi = str.indexOf(b, i + 1);
}
i = ai < bi && ai >= 0 ? ai : bi;
}
if (begs.length) {
result = [left, right];
}
}
return result;
}
}
});
// node_modules/brace-expansion/index.js
var require_brace_expansion = __commonJS({
"node_modules/brace-expansion/index.js"(exports2, module2) {
var balanced = require_balanced_match();
module2.exports = expandTop;
var escSlash = "\0SLASH" + Math.random() + "\0";
var escOpen = "\0OPEN" + Math.random() + "\0";
var escClose = "\0CLOSE" + Math.random() + "\0";
var escComma = "\0COMMA" + Math.random() + "\0";
var escPeriod = "\0PERIOD" + Math.random() + "\0";
function numeric(str) {
return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
}
function escapeBraces(str) {
return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
}
function unescapeBraces(str) {
return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
}
function parseCommaParts(str) {
if (!str)
return [""];
var parts = [];
var m = balanced("{", "}", str);
if (!m)
return str.split(",");
var pre = m.pre;
var body = m.body;
var post = m.post;
var p = pre.split(",");
p[p.length - 1] += "{" + body + "}";
var postParts = parseCommaParts(post);
if (post.length) {
p[p.length - 1] += postParts.shift();
p.push.apply(p, postParts);
}
parts.push.apply(parts, p);
return parts;
}
function expandTop(str) {
if (!str)
return [];
if (str.substr(0, 2) === "{}") {
str = "\\{\\}" + str.substr(2);
}
return expand(escapeBraces(str), true).map(unescapeBraces);
}
function embrace(str) {
return "{" + str + "}";
}
function isPadded(el) {
return /^-?0\d/.test(el);
}
function lte(i, y) {
return i <= y;
}
function gte(i, y) {
return i >= y;
}
function expand(str, isTop) {
var expansions = [];
var m = balanced("{", "}", str);
if (!m) return [str];
var pre = m.pre;
var post = m.post.length ? expand(m.post, false) : [""];
if (/\$$/.test(m.pre)) {
for (var k = 0; k < post.length; k++) {
var expansion = pre + "{" + m.body + "}" + post[k];
expansions.push(expansion);
}
} else {
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
var isSequence = isNumericSequence || isAlphaSequence;
var isOptions = m.body.indexOf(",") >= 0;
if (!isSequence && !isOptions) {
if (m.post.match(/,(?!,).*\}/)) {
str = m.pre + "{" + m.body + escClose + m.post;
return expand(str);
}
return [str];
}
var n;
if (isSequence) {
n = m.body.split(/\.\./);
} else {
n = parseCommaParts(m.body);
if (n.length === 1) {
n = expand(n[0], false).map(embrace);
if (n.length === 1) {
return post.map(function(p) {
return m.pre + n[0] + p;
});
}
}
}
var N;
if (isSequence) {
var x = numeric(n[0]);
var y = numeric(n[1]);
var width = Math.max(n[0].length, n[1].length);
var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
var test = lte;
var reverse = y < x;
if (reverse) {
incr *= -1;
test = gte;
}
var pad = n.some(isPadded);
N = [];
for (var i = x; test(i, y); i += incr) {
var c;
if (isAlphaSequence) {
c = String.fromCharCode(i);
if (c === "\\")
c = "";
} else {
c = String(i);
if (pad) {
var need = width - c.length;
if (need > 0) {
var z = new Array(need + 1).join("0");
if (i < 0)
c = "-" + z + c.slice(1);
else
c = z + c;
}
}
}
N.push(c);
}
} else {
N = [];
for (var j = 0; j < n.length; j++) {
N.push.apply(N, expand(n[j], false));
}
}
for (var j = 0; j < N.length; j++) {
for (var k = 0; k < post.length; k++) {
var expansion = pre + N[j] + post[k];
if (!isTop || isSequence || expansion)
expansions.push(expansion);
}
}
}
return expansions;
}
}
});
// node_modules/vscode-languageclient/node_modules/minimatch/minimatch.js
var require_minimatch = __commonJS({
"node_modules/vscode-languageclient/node_modules/minimatch/minimatch.js"(exports2, module2) {
var minimatch = module2.exports = (p, pattern, options = {}) => {
assertValidPattern(pattern);
if (!options.nocomment && pattern.charAt(0) === "#") {
return false;
}
return new Minimatch(pattern, options).match(p);
};
module2.exports = minimatch;
var path11 = require_path();
minimatch.sep = path11.sep;
var GLOBSTAR = Symbol("globstar **");
minimatch.GLOBSTAR = GLOBSTAR;
var expand = require_brace_expansion();
var plTypes = {
"!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
"?": { open: "(?:", close: ")?" },
"+": { open: "(?:", close: ")+" },
"*": { open: "(?:", close: ")*" },
"@": { open: "(?:", close: ")" }
};
var qmark = "[^/]";
var star = qmark + "*?";
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
var charSet = (s) => s.split("").reduce((set, c) => {
set[c] = true;
return set;
}, {});
var reSpecials = charSet("().*{}+?[]^$\\!");
var addPatternStartSet = charSet("[.(");
var slashSplit = /\/+/;
minimatch.filter = (pattern, options = {}) => (p, i, list) => minimatch(p, pattern, options);
var ext = (a, b = {}) => {
const t = {};
Object.keys(a).forEach((k) => t[k] = a[k]);
Object.keys(b).forEach((k) => t[k] = b[k]);
return t;
};
minimatch.defaults = (def) => {
if (!def || typeof def !== "object" || !Object.keys(def).length) {
return minimatch;
}
const orig = minimatch;
const m = (p, pattern, options) => orig(p, pattern, ext(def, options));
m.Minimatch = class Minimatch extends orig.Minimatch {
constructor(pattern, options) {
super(pattern, ext(def, options));
}
};
m.Minimatch.defaults = (options) => orig.defaults(ext(def, options)).Minimatch;
m.filter = (pattern, options) => orig.filter(pattern, ext(def, options));
m.defaults = (options) => orig.defaults(ext(def, options));
m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options));
m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options));
m.match = (list, pattern, options) => orig.match(list, pattern, ext(def, options));
return m;
};
minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
var braceExpand = (pattern, options = {}) => {
assertValidPattern(pattern);
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
return [pattern];
}
return expand(pattern);
};
var MAX_PATTERN_LENGTH = 1024 * 64;
var assertValidPattern = (pattern) => {
if (typeof pattern !== "string") {
throw new TypeError("invalid pattern");
}
if (pattern.length > MAX_PATTERN_LENGTH) {
throw new TypeError("pattern is too long");
}
};
var SUBPARSE = Symbol("subparse");
minimatch.makeRe = (pattern, options) => new Minimatch(pattern, options || {}).makeRe();
minimatch.match = (list, pattern, options = {}) => {
const mm = new Minimatch(pattern, options);
list = list.filter((f) => mm.match(f));
if (mm.options.nonull && !list.length) {
list.push(pattern);
}
return list;
};
var globUnescape = (s) => s.replace(/\\(.)/g, "$1");
var charUnescape = (s) => s.replace(/\\([^-\]])/g, "$1");
var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
var braExpEscape = (s) => s.replace(/[[\]\\]/g, "\\$&");
var Minimatch = class {
constructor(pattern, options) {
assertValidPattern(pattern);
if (!options) options = {};
this.options = options;
this.set = [];
this.pattern = pattern;
this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
if (this.windowsPathsNoEscape) {
this.pattern = this.pattern.replace(/\\/g, "/");
}
this.regexp = null;
this.negate = false;
this.comment = false;
this.empty = false;
this.partial = !!options.partial;
this.make();
}
debug() {
}
make() {
const pattern = this.pattern;
const options = this.options;
if (!options.nocomment && pattern.charAt(0) === "#") {
this.comment = true;
return;
}
if (!pattern) {
this.empty = true;
return;
}
this.parseNegate();
let set = this.globSet = this.braceExpand();
if (options.debug) this.debug = (...args) => console.error(...args);
this.debug(this.pattern, set);
set = this.globParts = set.map((s) => s.split(slashSplit));
this.debug(this.pattern, set);
set = set.map((s, si, set2) => s.map(this.parse, this));
this.debug(this.pattern, set);
set = set.filter((s) => s.indexOf(false) === -1);
this.debug(this.pattern, set);
this.set = set;
}
parseNegate() {
if (this.options.nonegate) return;
const pattern = this.pattern;
let negate = false;
let negateOffset = 0;
for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
negate = !negate;
negateOffset++;
}
if (negateOffset) this.pattern = pattern.slice(negateOffset);
this.negate = negate;
}
// set partial to true to test if, for example,
// "/a/b" matches the start of "/*/b/*/d"
// Partial means, if you run out of file before you run
// out of pattern, then that's fine, as long as all
// the parts match.
matchOne(file, pattern, partial) {
var options = this.options;
this.debug(
"matchOne",
{ "this": this, file, pattern }
);
this.debug("matchOne", file.length, pattern.length);
for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
this.debug("matchOne loop");
var p = pattern[pi];
var f = file[fi];
this.debug(pattern, p, f);
if (p === false) return false;
if (p === GLOBSTAR) {
this.debug("GLOBSTAR", [pattern, p, f]);
var fr = fi;
var pr = pi + 1;
if (pr === pl) {
this.debug("** at the end");
for (; fi < fl; fi++) {
if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".") return false;
}
return true;
}
while (fr < fl) {
var swallowee = file[fr];
this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
this.debug("globstar found match!", fr, fl, swallowee);
return true;
} else {
if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
this.debug("dot detected!", file, fr, pattern, pr);
break;
}
this.debug("globstar swallow a segment, and continue");
fr++;
}
}
if (partial) {
this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
if (fr === fl) return true;
}
return false;
}
var hit;
if (typeof p === "string") {
hit = f === p;
this.debug("string match", p, f, hit);
} else {
hit = f.match(p);
this.debug("pattern match", p, f, hit);
}
if (!hit) return false;
}
if (fi === fl && pi === pl) {
return true;
} else if (fi === fl) {
return partial;
} else if (pi === pl) {
return fi === fl - 1 && file[fi] === "";
}
throw new Error("wtf?");
}
braceExpand() {
return braceExpand(this.pattern, this.options);
}
parse(pattern, isSub) {
assertValidPattern(pattern);
const options = this.options;
if (pattern === "**") {
if (!options.noglobstar)
return GLOBSTAR;
else
pattern = "*";
}
if (pattern === "") return "";
let re = "";
let hasMagic = false;
let escaping = false;
const patternListStack = [];
const negativeLists = [];
let stateChar;
let inClass = false;
let reClassStart = -1;
let classStart = -1;
let cs;
let pl;
let sp;
let dotTravAllowed = pattern.charAt(0) === ".";
let dotFileAllowed = options.dot || dotTravAllowed;
const patternStart = () => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
const subPatternStart = (p) => p.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
const clearStateChar = () => {
if (stateChar) {
switch (stateChar) {
case "*":
re += star;
hasMagic = true;
break;
case "?":
re += qmark;
hasMagic = true;
break;
default:
re += "\\" + stateChar;
break;
}
this.debug("clearStateChar %j %j", stateChar, re);
stateChar = false;
}
};
for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
this.debug("%s %s %s %j", pattern, i, re, c);
if (escaping) {
if (c === "/") {
return false;
}
if (reSpecials[c]) {
re += "\\";
}
re += c;
escaping = false;
continue;
}
switch (c) {
/* istanbul ignore next */
case "/": {
return false;
}
case "\\":
if (inClass && pattern.charAt(i + 1) === "-") {
re += c;
continue;
}
clearStateChar();
escaping = true;
continue;
// the various stateChar values
// for the "extglob" stuff.
case "?":
case "*":
case "+":
case "@":
case "!":
this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
if (inClass) {
this.debug(" in class");
if (c === "!" && i === classStart + 1) c = "^";
re += c;
continue;
}
this.debug("call clearStateChar %j", stateChar);
clearStateChar();
stateChar = c;
if (options.noext) clearStateChar();
continue;
case "(": {
if (inClass) {
re += "(";
continue;
}
if (!stateChar) {
re += "\\(";
continue;
}
const plEntry = {
type: stateChar,
start: i - 1,
reStart: re.length,
open: plTypes[stateChar].open,
close: plTypes[stateChar].close
};
this.debug(this.pattern, " ", plEntry);
patternListStack.push(plEntry);
re += plEntry.open;
if (plEntry.start === 0 && plEntry.type !== "!") {
dotTravAllowed = true;
re += subPatternStart(pattern.slice(i + 1));
}
this.debug("plType %j %j", stateChar, re);
stateChar = false;
continue;
}
case ")": {
const plEntry = patternListStack[patternListStack.length - 1];
if (inClass || !plEntry) {
re += "\\)";
continue;
}
patternListStack.pop();
clearStateChar();
hasMagic = true;
pl = plEntry;
re += pl.close;
if (pl.type === "!") {
negativeLists.push(Object.assign(pl, { reEnd: re.length }));
}
continue;
}
case "|": {
const plEntry = patternListStack[patternListStack.length - 1];
if (inClass || !plEntry) {
re += "\\|";
continue;
}
clearStateChar();
re += "|";
if (plEntry.start === 0 && plEntry.type !== "!") {
dotTravAllowed = true;
re += subPatternStart(pattern.slice(i + 1));
}
continue;
}
// these are mostly the same in regexp and glob
case "[":
clearStateChar();
if (inClass) {
re += "\\" + c;
continue;
}
inClass = true;
classStart = i;
reClassStart = re.length;
re += c;
continue;
case "]":
if (i === classStart + 1 || !inClass) {
re += "\\" + c;
continue;
}
cs = pattern.substring(classStart + 1, i);
try {
RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
re += c;
} catch (er) {
re = re.substring(0, reClassStart) + "(?:$.)";
}
hasMagic = true;
inClass = false;
continue;
default:
clearStateChar();
if (reSpecials[c] && !(c === "^" && inClass)) {
re += "\\";
}
re += c;
break;
}
}
if (inClass) {
cs = pattern.slice(classStart + 1);
sp = this.parse(cs, SUBPARSE);
re = re.substring(0, reClassStart) + "\\[" + sp[0];
hasMagic = hasMagic || sp[1];
}
for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
let tail;
tail = re.slice(pl.reStart + pl.open.length);
this.debug("setting tail", re, pl);
tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
if (!$2) {
$2 = "\\";
}
return $1 + $1 + $2 + "|";
});
this.debug("tail=%j\n %s", tail, tail, pl, re);
const t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
hasMagic = true;
re = re.slice(0, pl.reStart) + t + "\\(" + tail;
}
clearStateChar();
if (escaping) {
re += "\\\\";
}
const addPatternStart = addPatternStartSet[re.charAt(0)];
for (let n = negativeLists.length - 1; n > -1; n--) {
const nl = negativeLists[n];
const nlBefore = re.slice(0, nl.reStart);
const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
let nlAfter = re.slice(nl.reEnd);
const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
const closeParensBefore = nlBefore.split(")").length;
const openParensBefore = nlBefore.split("(").length - closeParensBefore;
let cleanAfter = nlAfter;
for (let i = 0; i < openParensBefore; i++) {
cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
}
nlAfter = cleanAfter;
const dollar = nlAfter === "" && isSub !== SUBPARSE ? "(?:$|\\/)" : "";
re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
}
if (re !== "" && hasMagic) {
re = "(?=.)" + re;
}
if (addPatternStart) {
re = patternStart() + re;
}
if (isSub === SUBPARSE) {
return [re, hasMagic];
}
if (options.nocase && !hasMagic) {
hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
}
if (!hasMagic) {
return globUnescape(pattern);
}
const flags = options.nocase ? "i" : "";
try {
return Object.assign(new RegExp("^" + re + "$", flags), {
_glob: pattern,
_src: re
});
} catch (er) {
return new RegExp("$.");
}
}
makeRe() {
if (this.regexp || this.regexp === false) return this.regexp;
const set = this.set;
if (!set.length) {
this.regexp = false;
return this.regexp;
}
const options = this.options;
const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
const flags = options.nocase ? "i" : "";
let re = set.map((pattern) => {
pattern = pattern.map(
(p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
).reduce((set2, p) => {
if (!(set2[set2.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
set2.push(p);
}
return set2;
}, []);
pattern.forEach((p, i) => {
if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
return;
}
if (i === 0) {
if (pattern.length > 1) {
pattern[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i + 1];
} else {
pattern[i] = twoStar;
}
} else if (i === pattern.length - 1) {
pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
} else {
pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
pattern[i + 1] = GLOBSTAR;
}
});
return pattern.filter((p) => p !== GLOBSTAR).join("/");
}).join("|");
re = "^(?:" + re + ")$";
if (this.negate) re = "^(?!" + re + ").*$";
try {
this.regexp = new RegExp(re, flags);
} catch (ex) {
this.regexp = false;
}
return this.regexp;
}
match(f, partial = this.partial) {
this.debug("match", f, this.pattern);
if (this.comment) return false;
if (this.empty) return f === "";
if (f === "/" && partial) return true;
const options = this.options;
if (path11.sep !== "/") {
f = f.split(path11.sep).join("/");
}
f = f.split(slashSplit);
this.debug(this.pattern, "split", f);
const set = this.set;
this.debug(this.pattern, "set", set);
let filename;
for (let i = f.length - 1; i >= 0; i--) {
filename = f[i];
if (filename) break;
}
for (let i = 0; i < set.length; i++) {
const pattern = set[i];
let file = f;
if (options.matchBase && pattern.length === 1) {
file = [filename];
}
const hit = this.matchOne(file, pattern, partial);
if (hit) {
if (options.flipNegate) return true;
return !this.negate;
}
}
if (options.flipNegate) return false;
return this.negate;
}
static defaults(def) {
return minimatch.defaults(def).Minimatch;
}
};
minimatch.Minimatch = Minimatch;
}
});
// node_modules/vscode-languageclient/lib/common/diagnostic.js
var require_diagnostic = __commonJS({
"node_modules/vscode-languageclient/lib/common/diagnostic.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagnosticFeature = exports2.DiagnosticPullMode = exports2.vsdiag = void 0;
var minimatch = require_minimatch();
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var uuid_1 = require_uuid();
var features_1 = require_features();
function ensure(target, key) {
if (target[key] === void 0) {
target[key] = {};
}
return target[key];
}
var vsdiag;
(function(vsdiag2) {
let DocumentDiagnosticReportKind;
(function(DocumentDiagnosticReportKind2) {
DocumentDiagnosticReportKind2["full"] = "full";
DocumentDiagnosticReportKind2["unChanged"] = "unChanged";
})(DocumentDiagnosticReportKind = vsdiag2.DocumentDiagnosticReportKind || (vsdiag2.DocumentDiagnosticReportKind = {}));
})(vsdiag || (exports2.vsdiag = vsdiag = {}));
var DiagnosticPullMode;
(function(DiagnosticPullMode2) {
DiagnosticPullMode2["onType"] = "onType";
DiagnosticPullMode2["onSave"] = "onSave";
})(DiagnosticPullMode || (exports2.DiagnosticPullMode = DiagnosticPullMode = {}));
var RequestStateKind;
(function(RequestStateKind2) {
RequestStateKind2["active"] = "open";
RequestStateKind2["reschedule"] = "reschedule";
RequestStateKind2["outDated"] = "drop";
})(RequestStateKind || (RequestStateKind = {}));
var Tabs = class _Tabs {
constructor() {
this.open = /* @__PURE__ */ new Set();
this._onOpen = new vscode_1.EventEmitter();
this._onClose = new vscode_1.EventEmitter();
_Tabs.fillTabResources(this.open);
const openTabsHandler = (event) => {
if (event.closed.length === 0 && event.opened.length === 0) {
return;
}
const oldTabs = this.open;
const currentTabs = /* @__PURE__ */ new Set();
_Tabs.fillTabResources(currentTabs);
const closed = /* @__PURE__ */ new Set();
const opened = new Set(currentTabs);
for (const tab of oldTabs.values()) {
if (currentTabs.has(tab)) {
opened.delete(tab);
} else {
closed.add(tab);
}
}
this.open = currentTabs;
if (closed.size > 0) {
const toFire = /* @__PURE__ */ new Set();
for (const item of closed) {
toFire.add(vscode_1.Uri.parse(item));
}
this._onClose.fire(toFire);
}
if (opened.size > 0) {
const toFire = /* @__PURE__ */ new Set();
for (const item of opened) {
toFire.add(vscode_1.Uri.parse(item));
}
this._onOpen.fire(toFire);
}
};
if (vscode_1.window.tabGroups.onDidChangeTabs !== void 0) {
this.disposable = vscode_1.window.tabGroups.onDidChangeTabs(openTabsHandler);
} else {
this.disposable = { dispose: () => {
} };
}
}
get onClose() {
return this._onClose.event;
}
get onOpen() {
return this._onOpen.event;
}
dispose() {
this.disposable.dispose();
}
isActive(document) {
return document instanceof vscode_1.Uri ? vscode_1.window.activeTextEditor?.document.uri === document : vscode_1.window.activeTextEditor?.document === document;
}
isVisible(document) {
const uri = document instanceof vscode_1.Uri ? document : document.uri;
return this.open.has(uri.toString());
}
getTabResources() {
const result = /* @__PURE__ */ new Set();
_Tabs.fillTabResources(/* @__PURE__ */ new Set(), result);
return result;
}
static fillTabResources(strings, uris) {
const seen = strings ?? /* @__PURE__ */ new Set();
for (const group of vscode_1.window.tabGroups.all) {
for (const tab of group.tabs) {
const input = tab.input;
let uri;
if (input instanceof vscode_1.TabInputText) {
uri = input.uri;
} else if (input instanceof vscode_1.TabInputTextDiff) {
uri = input.modified;
} else if (input instanceof vscode_1.TabInputCustom) {
uri = input.uri;
}
if (uri !== void 0 && !seen.has(uri.toString())) {
seen.add(uri.toString());
uris !== void 0 && uris.add(uri);
}
}
}
}
};
var PullState;
(function(PullState2) {
PullState2[PullState2["document"] = 1] = "document";
PullState2[PullState2["workspace"] = 2] = "workspace";
})(PullState || (PullState = {}));
var DocumentOrUri;
(function(DocumentOrUri2) {
function asKey(document) {
return document instanceof vscode_1.Uri ? document.toString() : document.uri.toString();
}
DocumentOrUri2.asKey = asKey;
})(DocumentOrUri || (DocumentOrUri = {}));
var DocumentPullStateTracker = class {
constructor() {
this.documentPullStates = /* @__PURE__ */ new Map();
this.workspacePullStates = /* @__PURE__ */ new Map();
}
track(kind, document, arg1) {
const states = kind === PullState.document ? this.documentPullStates : this.workspacePullStates;
const [key, uri, version] = document instanceof vscode_1.Uri ? [document.toString(), document, arg1] : [document.uri.toString(), document.uri, document.version];
let state = states.get(key);
if (state === void 0) {
state = { document: uri, pulledVersion: version, resultId: void 0 };
states.set(key, state);
}
return state;
}
update(kind, document, arg1, arg2) {
const states = kind === PullState.document ? this.documentPullStates : this.workspacePullStates;
const [key, uri, version, resultId] = document instanceof vscode_1.Uri ? [document.toString(), document, arg1, arg2] : [document.uri.toString(), document.uri, document.version, arg1];
let state = states.get(key);
if (state === void 0) {
state = { document: uri, pulledVersion: version, resultId };
states.set(key, state);
} else {
state.pulledVersion = version;
state.resultId = resultId;
}
}
unTrack(kind, document) {
const key = DocumentOrUri.asKey(document);
const states = kind === PullState.document ? this.documentPullStates : this.workspacePullStates;
states.delete(key);
}
tracks(kind, document) {
const key = DocumentOrUri.asKey(document);
const states = kind === PullState.document ? this.documentPullStates : this.workspacePullStates;
return states.has(key);
}
getResultId(kind, document) {
const key = DocumentOrUri.asKey(document);
const states = kind === PullState.document ? this.documentPullStates : this.workspacePullStates;
return states.get(key)?.resultId;
}
getAllResultIds() {
const result = [];
for (let [uri, value] of this.workspacePullStates) {
if (this.documentPullStates.has(uri)) {
value = this.documentPullStates.get(uri);
}
if (value.resultId !== void 0) {
result.push({ uri, value: value.resultId });
}
}
return result;
}
};
var DiagnosticRequestor = class {
constructor(client, tabs, options) {
this.client = client;
this.tabs = tabs;
this.options = options;
this.isDisposed = false;
this.onDidChangeDiagnosticsEmitter = new vscode_1.EventEmitter();
this.provider = this.createProvider();
this.diagnostics = vscode_1.languages.createDiagnosticCollection(options.identifier);
this.openRequests = /* @__PURE__ */ new Map();
this.documentStates = new DocumentPullStateTracker();
this.workspaceErrorCounter = 0;
}
knows(kind, document) {
const uri = document instanceof vscode_1.Uri ? document : document.uri;
return this.documentStates.tracks(kind, document) || this.openRequests.has(uri.toString());
}
forget(kind, document) {
this.documentStates.unTrack(kind, document);
}
pull(document, cb) {
if (this.isDisposed) {
return;
}
const uri = document instanceof vscode_1.Uri ? document : document.uri;
this.pullAsync(document).then(() => {
if (cb) {
cb();
}
}, (error) => {
this.client.error(`Document pull failed for text document ${uri.toString()}`, error, false);
});
}
async pullAsync(document, version) {
if (this.isDisposed) {
return;
}
const isUri = document instanceof vscode_1.Uri;
const uri = isUri ? document : document.uri;
const key = uri.toString();
version = isUri ? version : document.version;
const currentRequestState = this.openRequests.get(key);
const documentState = isUri ? this.documentStates.track(PullState.document, document, version) : this.documentStates.track(PullState.document, document);
if (currentRequestState === void 0) {
const tokenSource = new vscode_1.CancellationTokenSource();
this.openRequests.set(key, { state: RequestStateKind.active, document, version, tokenSource });
let report;
let afterState;
try {
report = await this.provider.provideDiagnostics(document, documentState.resultId, tokenSource.token) ?? { kind: vsdiag.DocumentDiagnosticReportKind.full, items: [] };
} catch (error) {
if (error instanceof features_1.LSPCancellationError && vscode_languageserver_protocol_1.DiagnosticServerCancellationData.is(error.data) && error.data.retriggerRequest === false) {
afterState = { state: RequestStateKind.outDated, document };
}
if (afterState === void 0 && error instanceof vscode_1.CancellationError) {
afterState = { state: RequestStateKind.reschedule, document };
} else {
throw error;
}
}
afterState = afterState ?? this.openRequests.get(key);
if (afterState === void 0) {
this.client.error(`Lost request state in diagnostic pull model. Clearing diagnostics for ${key}`);
this.diagnostics.delete(uri);
return;
}
this.openRequests.delete(key);
if (!this.tabs.isVisible(document)) {
this.documentStates.unTrack(PullState.document, document);
return;
}
if (afterState.state === RequestStateKind.outDated) {
return;
}
if (report !== void 0) {
if (report.kind === vsdiag.DocumentDiagnosticReportKind.full) {
this.diagnostics.set(uri, report.items);
}
documentState.pulledVersion = version;
documentState.resultId = report.resultId;
}
if (afterState.state === RequestStateKind.reschedule) {
this.pull(document);
}
} else {
if (currentRequestState.state === RequestStateKind.active) {
currentRequestState.tokenSource.cancel();
this.openRequests.set(key, { state: RequestStateKind.reschedule, document: currentRequestState.document });
} else if (currentRequestState.state === RequestStateKind.outDated) {
this.openRequests.set(key, { state: RequestStateKind.reschedule, document: currentRequestState.document });
}
}
}
forgetDocument(document) {
const uri = document instanceof vscode_1.Uri ? document : document.uri;
const key = uri.toString();
const request = this.openRequests.get(key);
if (this.options.workspaceDiagnostics) {
if (request !== void 0) {
this.openRequests.set(key, { state: RequestStateKind.reschedule, document });
} else {
this.pull(document, () => {
this.forget(PullState.document, document);
});
}
} else {
if (request !== void 0) {
if (request.state === RequestStateKind.active) {
request.tokenSource.cancel();
}
this.openRequests.set(key, { state: RequestStateKind.outDated, document });
}
this.diagnostics.delete(uri);
this.forget(PullState.document, document);
}
}
pullWorkspace() {
if (this.isDisposed) {
return;
}
this.pullWorkspaceAsync().then(() => {
this.workspaceTimeout = (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => {
this.pullWorkspace();
}, 2e3);
}, (error) => {
if (!(error instanceof features_1.LSPCancellationError) && !vscode_languageserver_protocol_1.DiagnosticServerCancellationData.is(error.data)) {
this.client.error(`Workspace diagnostic pull failed.`, error, false);
this.workspaceErrorCounter++;
}
if (this.workspaceErrorCounter <= 5) {
this.workspaceTimeout = (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => {
this.pullWorkspace();
}, 2e3);
}
});
}
async pullWorkspaceAsync() {
if (!this.provider.provideWorkspaceDiagnostics || this.isDisposed) {
return;
}
if (this.workspaceCancellation !== void 0) {
this.workspaceCancellation.cancel();
this.workspaceCancellation = void 0;
}
this.workspaceCancellation = new vscode_1.CancellationTokenSource();
const previousResultIds = this.documentStates.getAllResultIds().map((item) => {
return {
uri: this.client.protocol2CodeConverter.asUri(item.uri),
value: item.value
};
});
await this.provider.provideWorkspaceDiagnostics(previousResultIds, this.workspaceCancellation.token, (chunk) => {
if (!chunk || this.isDisposed) {
return;
}
for (const item of chunk.items) {
if (item.kind === vsdiag.DocumentDiagnosticReportKind.full) {
if (!this.documentStates.tracks(PullState.document, item.uri)) {
this.diagnostics.set(item.uri, item.items);
}
}
this.documentStates.update(PullState.workspace, item.uri, item.version ?? void 0, item.resultId);
}
});
}
createProvider() {
const result = {
onDidChangeDiagnostics: this.onDidChangeDiagnosticsEmitter.event,
provideDiagnostics: (document, previousResultId, token) => {
const provideDiagnostics = (document2, previousResultId2, token2) => {
const params = {
identifier: this.options.identifier,
textDocument: { uri: this.client.code2ProtocolConverter.asUri(document2 instanceof vscode_1.Uri ? document2 : document2.uri) },
previousResultId: previousResultId2
};
if (this.isDisposed === true || !this.client.isRunning()) {
return { kind: vsdiag.DocumentDiagnosticReportKind.full, items: [] };
}
return this.client.sendRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, params, token2).then(async (result2) => {
if (result2 === void 0 || result2 === null || this.isDisposed || token2.isCancellationRequested) {
return { kind: vsdiag.DocumentDiagnosticReportKind.full, items: [] };
}
if (result2.kind === vscode_languageserver_protocol_1.DocumentDiagnosticReportKind.Full) {
return { kind: vsdiag.DocumentDiagnosticReportKind.full, resultId: result2.resultId, items: await this.client.protocol2CodeConverter.asDiagnostics(result2.items, token2) };
} else {
return { kind: vsdiag.DocumentDiagnosticReportKind.unChanged, resultId: result2.resultId };
}
}, (error) => {
return this.client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, token2, error, { kind: vsdiag.DocumentDiagnosticReportKind.full, items: [] });
});
};
const middleware = this.client.middleware;
return middleware.provideDiagnostics ? middleware.provideDiagnostics(document, previousResultId, token, provideDiagnostics) : provideDiagnostics(document, previousResultId, token);
}
};
if (this.options.workspaceDiagnostics) {
result.provideWorkspaceDiagnostics = (resultIds, token, resultReporter) => {
const convertReport = async (report) => {
if (report.kind === vscode_languageserver_protocol_1.DocumentDiagnosticReportKind.Full) {
return {
kind: vsdiag.DocumentDiagnosticReportKind.full,
uri: this.client.protocol2CodeConverter.asUri(report.uri),
resultId: report.resultId,
version: report.version,
items: await this.client.protocol2CodeConverter.asDiagnostics(report.items, token)
};
} else {
return {
kind: vsdiag.DocumentDiagnosticReportKind.unChanged,
uri: this.client.protocol2CodeConverter.asUri(report.uri),
resultId: report.resultId,
version: report.version
};
}
};
const convertPreviousResultIds = (resultIds2) => {
const converted = [];
for (const item of resultIds2) {
converted.push({ uri: this.client.code2ProtocolConverter.asUri(item.uri), value: item.value });
}
return converted;
};
const provideDiagnostics = (resultIds2, token2) => {
const partialResultToken = (0, uuid_1.generateUuid)();
const disposable = this.client.onProgress(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.partialResult, partialResultToken, async (partialResult) => {
if (partialResult === void 0 || partialResult === null) {
resultReporter(null);
return;
}
const converted = {
items: []
};
for (const item of partialResult.items) {
try {
converted.items.push(await convertReport(item));
} catch (error) {
this.client.error(`Converting workspace diagnostics failed.`, error);
}
}
resultReporter(converted);
});
const params = {
identifier: this.options.identifier,
previousResultIds: convertPreviousResultIds(resultIds2),
partialResultToken
};
if (this.isDisposed === true || !this.client.isRunning()) {
return { items: [] };
}
return this.client.sendRequest(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.type, params, token2).then(async (result2) => {
if (token2.isCancellationRequested) {
return { items: [] };
}
const converted = {
items: []
};
for (const item of result2.items) {
converted.items.push(await convertReport(item));
}
disposable.dispose();
resultReporter(converted);
return { items: [] };
}, (error) => {
disposable.dispose();
return this.client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, token2, error, { items: [] });
});
};
const middleware = this.client.middleware;
return middleware.provideWorkspaceDiagnostics ? middleware.provideWorkspaceDiagnostics(resultIds, token, resultReporter, provideDiagnostics) : provideDiagnostics(resultIds, token, resultReporter);
};
}
return result;
}
dispose() {
this.isDisposed = true;
this.workspaceCancellation?.cancel();
this.workspaceTimeout?.dispose();
for (const [key, request] of this.openRequests) {
if (request.state === RequestStateKind.active) {
request.tokenSource.cancel();
}
this.openRequests.set(key, { state: RequestStateKind.outDated, document: request.document });
}
this.diagnostics.dispose();
}
};
var BackgroundScheduler = class {
constructor(diagnosticRequestor) {
this.diagnosticRequestor = diagnosticRequestor;
this.documents = new vscode_languageserver_protocol_1.LinkedMap();
this.isDisposed = false;
}
add(document) {
if (this.isDisposed === true) {
return;
}
const key = DocumentOrUri.asKey(document);
if (this.documents.has(key)) {
return;
}
this.documents.set(key, document, vscode_languageserver_protocol_1.Touch.Last);
this.trigger();
}
remove(document) {
const key = DocumentOrUri.asKey(document);
this.documents.delete(key);
if (this.documents.size === 0) {
this.stop();
} else if (key === this.endDocumentKey()) {
this.endDocument = this.documents.last;
}
}
trigger() {
if (this.isDisposed === true) {
return;
}
if (this.intervalHandle !== void 0) {
this.endDocument = this.documents.last;
return;
}
this.endDocument = this.documents.last;
this.intervalHandle = (0, vscode_languageserver_protocol_1.RAL)().timer.setInterval(() => {
const document = this.documents.first;
if (document !== void 0) {
const key = DocumentOrUri.asKey(document);
this.diagnosticRequestor.pull(document);
this.documents.set(key, document, vscode_languageserver_protocol_1.Touch.Last);
if (key === this.endDocumentKey()) {
this.stop();
}
}
}, 200);
}
dispose() {
this.isDisposed = true;
this.stop();
this.documents.clear();
}
stop() {
this.intervalHandle?.dispose();
this.intervalHandle = void 0;
this.endDocument = void 0;
}
endDocumentKey() {
return this.endDocument !== void 0 ? DocumentOrUri.asKey(this.endDocument) : void 0;
}
};
var DiagnosticFeatureProviderImpl = class {
constructor(client, tabs, options) {
const diagnosticPullOptions = client.clientOptions.diagnosticPullOptions ?? { onChange: true, onSave: false };
const documentSelector2 = client.protocol2CodeConverter.asDocumentSelector(options.documentSelector);
const disposables = [];
const matchResource = (resource) => {
const selector = options.documentSelector;
if (diagnosticPullOptions.match !== void 0) {
return diagnosticPullOptions.match(selector, resource);
}
for (const filter of selector) {
if (!vscode_languageserver_protocol_1.TextDocumentFilter.is(filter)) {
continue;
}
if (typeof filter === "string") {
return false;
}
if (filter.language !== void 0 && filter.language !== "*") {
return false;
}
if (filter.scheme !== void 0 && filter.scheme !== "*" && filter.scheme !== resource.scheme) {
return false;
}
if (filter.pattern !== void 0) {
const matcher = new minimatch.Minimatch(filter.pattern, { noext: true });
if (!matcher.makeRe()) {
return false;
}
if (!matcher.match(resource.fsPath)) {
return false;
}
}
}
return true;
};
const matches = (document) => {
return document instanceof vscode_1.Uri ? matchResource(document) : vscode_1.languages.match(documentSelector2, document) > 0 && tabs.isVisible(document);
};
const isActiveDocument = (document) => {
return document instanceof vscode_1.Uri ? this.activeTextDocument?.uri.toString() === document.toString() : this.activeTextDocument === document;
};
this.diagnosticRequestor = new DiagnosticRequestor(client, tabs, options);
this.backgroundScheduler = new BackgroundScheduler(this.diagnosticRequestor);
const addToBackgroundIfNeeded = (document) => {
if (!matches(document) || !options.interFileDependencies || isActiveDocument(document)) {
return;
}
this.backgroundScheduler.add(document);
};
this.activeTextDocument = vscode_1.window.activeTextEditor?.document;
vscode_1.window.onDidChangeActiveTextEditor((editor) => {
const oldActive = this.activeTextDocument;
this.activeTextDocument = editor?.document;
if (oldActive !== void 0) {
addToBackgroundIfNeeded(oldActive);
}
if (this.activeTextDocument !== void 0) {
this.backgroundScheduler.remove(this.activeTextDocument);
}
});
const openFeature = client.getFeature(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.method);
disposables.push(openFeature.onNotificationSent((event) => {
const textDocument = event.textDocument;
if (this.diagnosticRequestor.knows(PullState.document, textDocument)) {
return;
}
if (matches(textDocument)) {
this.diagnosticRequestor.pull(textDocument, () => {
addToBackgroundIfNeeded(textDocument);
});
}
}));
disposables.push(tabs.onOpen((opened) => {
for (const resource of opened) {
if (this.diagnosticRequestor.knows(PullState.document, resource)) {
continue;
}
const uriStr = resource.toString();
let textDocument;
for (const item of vscode_1.workspace.textDocuments) {
if (uriStr === item.uri.toString()) {
textDocument = item;
break;
}
}
if (textDocument !== void 0 && matches(textDocument)) {
this.diagnosticRequestor.pull(textDocument, () => {
addToBackgroundIfNeeded(textDocument);
});
}
}
}));
const pulledTextDocuments = /* @__PURE__ */ new Set();
for (const textDocument of vscode_1.workspace.textDocuments) {
if (matches(textDocument)) {
this.diagnosticRequestor.pull(textDocument, () => {
addToBackgroundIfNeeded(textDocument);
});
pulledTextDocuments.add(textDocument.uri.toString());
}
}
if (diagnosticPullOptions.onTabs === true) {
for (const resource of tabs.getTabResources()) {
if (!pulledTextDocuments.has(resource.toString()) && matches(resource)) {
this.diagnosticRequestor.pull(resource, () => {
addToBackgroundIfNeeded(resource);
});
}
}
}
if (diagnosticPullOptions.onChange === true) {
const changeFeature = client.getFeature(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.method);
disposables.push(changeFeature.onNotificationSent(async (event) => {
const textDocument = event.textDocument;
if ((diagnosticPullOptions.filter === void 0 || !diagnosticPullOptions.filter(textDocument, DiagnosticPullMode.onType)) && this.diagnosticRequestor.knows(PullState.document, textDocument)) {
this.diagnosticRequestor.pull(textDocument, () => {
this.backgroundScheduler.trigger();
});
}
}));
}
if (diagnosticPullOptions.onSave === true) {
const saveFeature = client.getFeature(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.method);
disposables.push(saveFeature.onNotificationSent((event) => {
const textDocument = event.textDocument;
if ((diagnosticPullOptions.filter === void 0 || !diagnosticPullOptions.filter(textDocument, DiagnosticPullMode.onSave)) && this.diagnosticRequestor.knows(PullState.document, textDocument)) {
this.diagnosticRequestor.pull(event.textDocument, () => {
this.backgroundScheduler.trigger();
});
}
}));
}
const closeFeature = client.getFeature(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.method);
disposables.push(closeFeature.onNotificationSent((event) => {
this.cleanUpDocument(event.textDocument);
}));
tabs.onClose((closed) => {
for (const document of closed) {
this.cleanUpDocument(document);
}
});
this.diagnosticRequestor.onDidChangeDiagnosticsEmitter.event(() => {
for (const textDocument of vscode_1.workspace.textDocuments) {
if (matches(textDocument)) {
this.diagnosticRequestor.pull(textDocument);
}
}
});
if (options.workspaceDiagnostics === true && options.identifier !== "da348dc5-c30a-4515-9d98-31ff3be38d14") {
this.diagnosticRequestor.pullWorkspace();
}
this.disposable = vscode_1.Disposable.from(...disposables, this.backgroundScheduler, this.diagnosticRequestor);
}
get onDidChangeDiagnosticsEmitter() {
return this.diagnosticRequestor.onDidChangeDiagnosticsEmitter;
}
get diagnostics() {
return this.diagnosticRequestor.provider;
}
cleanUpDocument(document) {
if (this.diagnosticRequestor.knows(PullState.document, document)) {
this.diagnosticRequestor.forgetDocument(document);
this.backgroundScheduler.remove(document);
}
}
};
var DiagnosticFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type);
}
fillClientCapabilities(capabilities) {
let capability = ensure(ensure(capabilities, "textDocument"), "diagnostic");
capability.dynamicRegistration = true;
capability.relatedDocumentSupport = false;
ensure(ensure(capabilities, "workspace"), "diagnostics").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
const client = this._client;
client.onRequest(vscode_languageserver_protocol_1.DiagnosticRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeDiagnosticsEmitter.fire();
}
});
let [id, options] = this.getRegistration(documentSelector2, capabilities.diagnosticProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
clear() {
if (this.tabs !== void 0) {
this.tabs.dispose();
this.tabs = void 0;
}
super.clear();
}
registerLanguageProvider(options) {
if (this.tabs === void 0) {
this.tabs = new Tabs();
}
const provider = new DiagnosticFeatureProviderImpl(this._client, this.tabs, options);
return [provider.disposable, provider];
}
};
exports2.DiagnosticFeature = DiagnosticFeature;
}
});
// node_modules/vscode-languageclient/lib/common/notebook.js
var require_notebook = __commonJS({
"node_modules/vscode-languageclient/lib/common/notebook.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.NotebookDocumentSyncFeature = void 0;
var vscode22 = require("vscode");
var minimatch = require_minimatch();
var proto = require_main3();
var UUID = require_uuid();
var Is = require_is();
function ensure(target, key) {
if (target[key] === void 0) {
target[key] = {};
}
return target[key];
}
var Converter;
(function(Converter2) {
let c2p;
(function(c2p2) {
function asVersionedNotebookDocumentIdentifier(notebookDocument, base) {
return {
version: notebookDocument.version,
uri: base.asUri(notebookDocument.uri)
};
}
c2p2.asVersionedNotebookDocumentIdentifier = asVersionedNotebookDocumentIdentifier;
function asNotebookDocument(notebookDocument, cells, base) {
const result = proto.NotebookDocument.create(base.asUri(notebookDocument.uri), notebookDocument.notebookType, notebookDocument.version, asNotebookCells(cells, base));
if (Object.keys(notebookDocument.metadata).length > 0) {
result.metadata = asMetadata(notebookDocument.metadata);
}
return result;
}
c2p2.asNotebookDocument = asNotebookDocument;
function asNotebookCells(cells, base) {
return cells.map((cell) => asNotebookCell(cell, base));
}
c2p2.asNotebookCells = asNotebookCells;
function asMetadata(metadata) {
const seen = /* @__PURE__ */ new Set();
return deepCopy(seen, metadata);
}
c2p2.asMetadata = asMetadata;
function asNotebookCell(cell, base) {
const result = proto.NotebookCell.create(asNotebookCellKind(cell.kind), base.asUri(cell.document.uri));
if (Object.keys(cell.metadata).length > 0) {
result.metadata = asMetadata(cell.metadata);
}
if (cell.executionSummary !== void 0 && (Is.number(cell.executionSummary.executionOrder) && Is.boolean(cell.executionSummary.success))) {
result.executionSummary = {
executionOrder: cell.executionSummary.executionOrder,
success: cell.executionSummary.success
};
}
return result;
}
c2p2.asNotebookCell = asNotebookCell;
function asNotebookCellKind(kind) {
switch (kind) {
case vscode22.NotebookCellKind.Markup:
return proto.NotebookCellKind.Markup;
case vscode22.NotebookCellKind.Code:
return proto.NotebookCellKind.Code;
}
}
function deepCopy(seen, value) {
if (seen.has(value)) {
throw new Error(`Can't deep copy cyclic structures.`);
}
if (Array.isArray(value)) {
const result = [];
for (const elem of value) {
if (elem !== null && typeof elem === "object" || Array.isArray(elem)) {
result.push(deepCopy(seen, elem));
} else {
if (elem instanceof RegExp) {
throw new Error(`Can't transfer regular expressions to the server`);
}
result.push(elem);
}
}
return result;
} else {
const props = Object.keys(value);
const result = /* @__PURE__ */ Object.create(null);
for (const prop of props) {
const elem = value[prop];
if (elem !== null && typeof elem === "object" || Array.isArray(elem)) {
result[prop] = deepCopy(seen, elem);
} else {
if (elem instanceof RegExp) {
throw new Error(`Can't transfer regular expressions to the server`);
}
result[prop] = elem;
}
}
return result;
}
}
function asTextContentChange(event, base) {
const params = base.asChangeTextDocumentParams(event, event.document.uri, event.document.version);
return { document: params.textDocument, changes: params.contentChanges };
}
c2p2.asTextContentChange = asTextContentChange;
function asNotebookDocumentChangeEvent(event, base) {
const result = /* @__PURE__ */ Object.create(null);
if (event.metadata) {
result.metadata = Converter2.c2p.asMetadata(event.metadata);
}
if (event.cells !== void 0) {
const cells = /* @__PURE__ */ Object.create(null);
const changedCells = event.cells;
if (changedCells.structure) {
cells.structure = {
array: {
start: changedCells.structure.array.start,
deleteCount: changedCells.structure.array.deleteCount,
cells: changedCells.structure.array.cells !== void 0 ? changedCells.structure.array.cells.map((cell) => Converter2.c2p.asNotebookCell(cell, base)) : void 0
},
didOpen: changedCells.structure.didOpen !== void 0 ? changedCells.structure.didOpen.map((cell) => base.asOpenTextDocumentParams(cell.document).textDocument) : void 0,
didClose: changedCells.structure.didClose !== void 0 ? changedCells.structure.didClose.map((cell) => base.asCloseTextDocumentParams(cell.document).textDocument) : void 0
};
}
if (changedCells.data !== void 0) {
cells.data = changedCells.data.map((cell) => Converter2.c2p.asNotebookCell(cell, base));
}
if (changedCells.textContent !== void 0) {
cells.textContent = changedCells.textContent.map((event2) => Converter2.c2p.asTextContentChange(event2, base));
}
if (Object.keys(cells).length > 0) {
result.cells = cells;
}
}
return result;
}
c2p2.asNotebookDocumentChangeEvent = asNotebookDocumentChangeEvent;
})(c2p = Converter2.c2p || (Converter2.c2p = {}));
})(Converter || (Converter = {}));
var $NotebookCell;
(function($NotebookCell2) {
function computeDiff(originalCells, modifiedCells, compareMetadata) {
const originalLength = originalCells.length;
const modifiedLength = modifiedCells.length;
let startIndex = 0;
while (startIndex < modifiedLength && startIndex < originalLength && equals(originalCells[startIndex], modifiedCells[startIndex], compareMetadata)) {
startIndex++;
}
if (startIndex < modifiedLength && startIndex < originalLength) {
let originalEndIndex = originalLength - 1;
let modifiedEndIndex = modifiedLength - 1;
while (originalEndIndex >= 0 && modifiedEndIndex >= 0 && equals(originalCells[originalEndIndex], modifiedCells[modifiedEndIndex], compareMetadata)) {
originalEndIndex--;
modifiedEndIndex--;
}
const deleteCount = originalEndIndex + 1 - startIndex;
const newCells = startIndex === modifiedEndIndex + 1 ? void 0 : modifiedCells.slice(startIndex, modifiedEndIndex + 1);
return newCells !== void 0 ? { start: startIndex, deleteCount, cells: newCells } : { start: startIndex, deleteCount };
} else if (startIndex < modifiedLength) {
return { start: startIndex, deleteCount: 0, cells: modifiedCells.slice(startIndex) };
} else if (startIndex < originalLength) {
return { start: startIndex, deleteCount: originalLength - startIndex };
} else {
return void 0;
}
}
$NotebookCell2.computeDiff = computeDiff;
function equals(one, other, compareMetaData = true) {
if (one.kind !== other.kind || one.document.uri.toString() !== other.document.uri.toString() || one.document.languageId !== other.document.languageId || !equalsExecution(one.executionSummary, other.executionSummary)) {
return false;
}
return !compareMetaData || compareMetaData && equalsMetadata(one.metadata, other.metadata);
}
function equalsExecution(one, other) {
if (one === other) {
return true;
}
if (one === void 0 || other === void 0) {
return false;
}
return one.executionOrder === other.executionOrder && one.success === other.success && equalsTiming(one.timing, other.timing);
}
function equalsTiming(one, other) {
if (one === other) {
return true;
}
if (one === void 0 || other === void 0) {
return false;
}
return one.startTime === other.startTime && one.endTime === other.endTime;
}
function equalsMetadata(one, other) {
if (one === other) {
return true;
}
if (one === null || one === void 0 || other === null || other === void 0) {
return false;
}
if (typeof one !== typeof other) {
return false;
}
if (typeof one !== "object") {
return false;
}
const oneArray = Array.isArray(one);
const otherArray = Array.isArray(other);
if (oneArray !== otherArray) {
return false;
}
if (oneArray && otherArray) {
if (one.length !== other.length) {
return false;
}
for (let i = 0; i < one.length; i++) {
if (!equalsMetadata(one[i], other[i])) {
return false;
}
}
}
if (isObjectLiteral(one) && isObjectLiteral(other)) {
const oneKeys = Object.keys(one);
const otherKeys = Object.keys(other);
if (oneKeys.length !== otherKeys.length) {
return false;
}
oneKeys.sort();
otherKeys.sort();
if (!equalsMetadata(oneKeys, otherKeys)) {
return false;
}
for (let i = 0; i < oneKeys.length; i++) {
const prop = oneKeys[i];
if (!equalsMetadata(one[prop], other[prop])) {
return false;
}
}
return true;
}
return false;
}
function isObjectLiteral(value) {
return value !== null && typeof value === "object";
}
$NotebookCell2.isObjectLiteral = isObjectLiteral;
})($NotebookCell || ($NotebookCell = {}));
var $NotebookDocumentFilter;
(function($NotebookDocumentFilter2) {
function matchNotebook(filter, notebookDocument) {
if (typeof filter === "string") {
return filter === "*" || notebookDocument.notebookType === filter;
}
if (filter.notebookType !== void 0 && filter.notebookType !== "*" && notebookDocument.notebookType !== filter.notebookType) {
return false;
}
const uri = notebookDocument.uri;
if (filter.scheme !== void 0 && filter.scheme !== "*" && uri.scheme !== filter.scheme) {
return false;
}
if (filter.pattern !== void 0) {
const matcher = new minimatch.Minimatch(filter.pattern, { noext: true });
if (!matcher.makeRe()) {
return false;
}
if (!matcher.match(uri.fsPath)) {
return false;
}
}
return true;
}
$NotebookDocumentFilter2.matchNotebook = matchNotebook;
})($NotebookDocumentFilter || ($NotebookDocumentFilter = {}));
var $NotebookDocumentSyncOptions;
(function($NotebookDocumentSyncOptions2) {
function asDocumentSelector(options) {
const selector = options.notebookSelector;
const result = [];
for (const element of selector) {
const notebookType = (typeof element.notebook === "string" ? element.notebook : element.notebook?.notebookType) ?? "*";
const scheme = typeof element.notebook === "string" ? void 0 : element.notebook?.scheme;
const pattern = typeof element.notebook === "string" ? void 0 : element.notebook?.pattern;
if (element.cells !== void 0) {
for (const cell of element.cells) {
result.push(asDocumentFilter(notebookType, scheme, pattern, cell.language));
}
} else {
result.push(asDocumentFilter(notebookType, scheme, pattern, void 0));
}
}
return result;
}
$NotebookDocumentSyncOptions2.asDocumentSelector = asDocumentSelector;
function asDocumentFilter(notebookType, scheme, pattern, language) {
return scheme === void 0 && pattern === void 0 ? { notebook: notebookType, language } : { notebook: { notebookType, scheme, pattern }, language };
}
})($NotebookDocumentSyncOptions || ($NotebookDocumentSyncOptions = {}));
var SyncInfo;
(function(SyncInfo2) {
function create(cells) {
return {
cells,
uris: new Set(cells.map((cell) => cell.document.uri.toString()))
};
}
SyncInfo2.create = create;
})(SyncInfo || (SyncInfo = {}));
var NotebookDocumentSyncFeatureProvider = class {
constructor(client, options) {
this.client = client;
this.options = options;
this.notebookSyncInfo = /* @__PURE__ */ new Map();
this.notebookDidOpen = /* @__PURE__ */ new Set();
this.disposables = [];
this.selector = client.protocol2CodeConverter.asDocumentSelector($NotebookDocumentSyncOptions.asDocumentSelector(options));
vscode22.workspace.onDidOpenNotebookDocument((notebookDocument) => {
this.notebookDidOpen.add(notebookDocument.uri.toString());
this.didOpen(notebookDocument);
}, void 0, this.disposables);
for (const notebookDocument of vscode22.workspace.notebookDocuments) {
this.notebookDidOpen.add(notebookDocument.uri.toString());
this.didOpen(notebookDocument);
}
vscode22.workspace.onDidChangeNotebookDocument((event) => this.didChangeNotebookDocument(event), void 0, this.disposables);
if (this.options.save === true) {
vscode22.workspace.onDidSaveNotebookDocument((notebookDocument) => this.didSave(notebookDocument), void 0, this.disposables);
}
vscode22.workspace.onDidCloseNotebookDocument((notebookDocument) => {
this.didClose(notebookDocument);
this.notebookDidOpen.delete(notebookDocument.uri.toString());
}, void 0, this.disposables);
}
getState() {
for (const notebook of vscode22.workspace.notebookDocuments) {
const matchingCells = this.getMatchingCells(notebook);
if (matchingCells !== void 0) {
return { kind: "document", id: "$internal", registrations: true, matches: true };
}
}
return { kind: "document", id: "$internal", registrations: true, matches: false };
}
get mode() {
return "notebook";
}
handles(textDocument) {
return vscode22.languages.match(this.selector, textDocument) > 0;
}
didOpenNotebookCellTextDocument(notebookDocument, cell) {
if (vscode22.languages.match(this.selector, cell.document) === 0) {
return;
}
if (!this.notebookDidOpen.has(notebookDocument.uri.toString())) {
return;
}
const syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString());
const cellMatches = this.cellMatches(notebookDocument, cell);
if (syncInfo !== void 0) {
const cellIsSynced = syncInfo.uris.has(cell.document.uri.toString());
if (cellMatches && cellIsSynced || !cellMatches && !cellIsSynced) {
return;
}
if (cellMatches) {
const matchingCells = this.getMatchingCells(notebookDocument);
if (matchingCells !== void 0) {
const event = this.asNotebookDocumentChangeEvent(notebookDocument, void 0, syncInfo, matchingCells);
if (event !== void 0) {
this.doSendChange(event, matchingCells).catch(() => {
});
}
}
}
} else {
if (cellMatches) {
this.doSendOpen(notebookDocument, [cell]).catch(() => {
});
}
}
}
didChangeNotebookCellTextDocument(notebookDocument, event) {
if (vscode22.languages.match(this.selector, event.document) === 0) {
return;
}
this.doSendChange({
notebook: notebookDocument,
cells: { textContent: [event] }
}, void 0).catch(() => {
});
}
didCloseNotebookCellTextDocument(notebookDocument, cell) {
const syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString());
if (syncInfo === void 0) {
return;
}
const cellUri = cell.document.uri;
const index = syncInfo.cells.findIndex((item) => item.document.uri.toString() === cellUri.toString());
if (index === -1) {
return;
}
if (index === 0 && syncInfo.cells.length === 1) {
this.doSendClose(notebookDocument, syncInfo.cells).catch(() => {
});
} else {
const newCells = syncInfo.cells.slice();
const deleted = newCells.splice(index, 1);
this.doSendChange({
notebook: notebookDocument,
cells: {
structure: {
array: { start: index, deleteCount: 1 },
didClose: deleted
}
}
}, newCells).catch(() => {
});
}
}
dispose() {
for (const disposable of this.disposables) {
disposable.dispose();
}
}
didOpen(notebookDocument, matchingCells = this.getMatchingCells(notebookDocument), syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString())) {
if (syncInfo !== void 0) {
if (matchingCells !== void 0) {
const event = this.asNotebookDocumentChangeEvent(notebookDocument, void 0, syncInfo, matchingCells);
if (event !== void 0) {
this.doSendChange(event, matchingCells).catch(() => {
});
}
} else {
this.doSendClose(notebookDocument, []).catch(() => {
});
}
} else {
if (matchingCells === void 0) {
return;
}
this.doSendOpen(notebookDocument, matchingCells).catch(() => {
});
}
}
didChangeNotebookDocument(event) {
const notebookDocument = event.notebook;
const syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString());
if (syncInfo === void 0) {
if (event.contentChanges.length === 0) {
return;
}
const cells = this.getMatchingCells(notebookDocument);
if (cells === void 0) {
return;
}
this.didOpen(notebookDocument, cells, syncInfo);
} else {
const cells = this.getMatchingCells(notebookDocument);
if (cells === void 0) {
this.didClose(notebookDocument, syncInfo);
return;
}
const newEvent = this.asNotebookDocumentChangeEvent(event.notebook, event, syncInfo, cells);
if (newEvent !== void 0) {
this.doSendChange(newEvent, cells).catch(() => {
});
}
}
}
didSave(notebookDocument) {
const syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString());
if (syncInfo === void 0) {
return;
}
this.doSendSave(notebookDocument).catch(() => {
});
}
didClose(notebookDocument, syncInfo = this.notebookSyncInfo.get(notebookDocument.uri.toString())) {
if (syncInfo === void 0) {
return;
}
const syncedCells = notebookDocument.getCells().filter((cell) => syncInfo.uris.has(cell.document.uri.toString()));
this.doSendClose(notebookDocument, syncedCells).catch(() => {
});
}
async sendDidOpenNotebookDocument(notebookDocument) {
const cells = this.getMatchingCells(notebookDocument);
if (cells === void 0) {
return;
}
return this.doSendOpen(notebookDocument, cells);
}
async doSendOpen(notebookDocument, cells) {
const send = async (notebookDocument2, cells2) => {
const nb = Converter.c2p.asNotebookDocument(notebookDocument2, cells2, this.client.code2ProtocolConverter);
const cellDocuments = cells2.map((cell) => this.client.code2ProtocolConverter.asTextDocumentItem(cell.document));
try {
await this.client.sendNotification(proto.DidOpenNotebookDocumentNotification.type, {
notebookDocument: nb,
cellTextDocuments: cellDocuments
});
} catch (error) {
this.client.error("Sending DidOpenNotebookDocumentNotification failed", error);
throw error;
}
};
const middleware = this.client.middleware?.notebooks;
this.notebookSyncInfo.set(notebookDocument.uri.toString(), SyncInfo.create(cells));
return middleware?.didOpen !== void 0 ? middleware.didOpen(notebookDocument, cells, send) : send(notebookDocument, cells);
}
async sendDidChangeNotebookDocument(event) {
return this.doSendChange(event, void 0);
}
async doSendChange(event, cells = this.getMatchingCells(event.notebook)) {
const send = async (event2) => {
try {
await this.client.sendNotification(proto.DidChangeNotebookDocumentNotification.type, {
notebookDocument: Converter.c2p.asVersionedNotebookDocumentIdentifier(event2.notebook, this.client.code2ProtocolConverter),
change: Converter.c2p.asNotebookDocumentChangeEvent(event2, this.client.code2ProtocolConverter)
});
} catch (error) {
this.client.error("Sending DidChangeNotebookDocumentNotification failed", error);
throw error;
}
};
const middleware = this.client.middleware?.notebooks;
if (event.cells?.structure !== void 0) {
this.notebookSyncInfo.set(event.notebook.uri.toString(), SyncInfo.create(cells ?? []));
}
return middleware?.didChange !== void 0 ? middleware?.didChange(event, send) : send(event);
}
async sendDidSaveNotebookDocument(notebookDocument) {
return this.doSendSave(notebookDocument);
}
async doSendSave(notebookDocument) {
const send = async (notebookDocument2) => {
try {
await this.client.sendNotification(proto.DidSaveNotebookDocumentNotification.type, {
notebookDocument: { uri: this.client.code2ProtocolConverter.asUri(notebookDocument2.uri) }
});
} catch (error) {
this.client.error("Sending DidSaveNotebookDocumentNotification failed", error);
throw error;
}
};
const middleware = this.client.middleware?.notebooks;
return middleware?.didSave !== void 0 ? middleware.didSave(notebookDocument, send) : send(notebookDocument);
}
async sendDidCloseNotebookDocument(notebookDocument) {
return this.doSendClose(notebookDocument, this.getMatchingCells(notebookDocument) ?? []);
}
async doSendClose(notebookDocument, cells) {
const send = async (notebookDocument2, cells2) => {
try {
await this.client.sendNotification(proto.DidCloseNotebookDocumentNotification.type, {
notebookDocument: { uri: this.client.code2ProtocolConverter.asUri(notebookDocument2.uri) },
cellTextDocuments: cells2.map((cell) => this.client.code2ProtocolConverter.asTextDocumentIdentifier(cell.document))
});
} catch (error) {
this.client.error("Sending DidCloseNotebookDocumentNotification failed", error);
throw error;
}
};
const middleware = this.client.middleware?.notebooks;
this.notebookSyncInfo.delete(notebookDocument.uri.toString());
return middleware?.didClose !== void 0 ? middleware.didClose(notebookDocument, cells, send) : send(notebookDocument, cells);
}
asNotebookDocumentChangeEvent(notebook, event, syncInfo, matchingCells) {
if (event !== void 0 && event.notebook !== notebook) {
throw new Error("Notebook must be identical");
}
const result = {
notebook
};
if (event?.metadata !== void 0) {
result.metadata = Converter.c2p.asMetadata(event.metadata);
}
let matchingCellsSet;
if (event?.cellChanges !== void 0 && event.cellChanges.length > 0) {
const data = [];
matchingCellsSet = new Set(matchingCells.map((cell) => cell.document.uri.toString()));
for (const cellChange of event.cellChanges) {
if (matchingCellsSet.has(cellChange.cell.document.uri.toString()) && (cellChange.executionSummary !== void 0 || cellChange.metadata !== void 0)) {
data.push(cellChange.cell);
}
}
if (data.length > 0) {
result.cells = result.cells ?? {};
result.cells.data = data;
}
}
if ((event?.contentChanges !== void 0 && event.contentChanges.length > 0 || event === void 0) && syncInfo !== void 0 && matchingCells !== void 0) {
const oldCells = syncInfo.cells;
const newCells = matchingCells;
const diff = $NotebookCell.computeDiff(oldCells, newCells, false);
let addedCells;
let removedCells;
if (diff !== void 0) {
addedCells = diff.cells === void 0 ? /* @__PURE__ */ new Map() : new Map(diff.cells.map((cell) => [cell.document.uri.toString(), cell]));
removedCells = diff.deleteCount === 0 ? /* @__PURE__ */ new Map() : new Map(oldCells.slice(diff.start, diff.start + diff.deleteCount).map((cell) => [cell.document.uri.toString(), cell]));
for (const key of Array.from(removedCells.keys())) {
if (addedCells.has(key)) {
removedCells.delete(key);
addedCells.delete(key);
}
}
result.cells = result.cells ?? {};
const didOpen = [];
const didClose = [];
if (addedCells.size > 0 || removedCells.size > 0) {
for (const cell of addedCells.values()) {
didOpen.push(cell);
}
for (const cell of removedCells.values()) {
didClose.push(cell);
}
}
result.cells.structure = {
array: diff,
didOpen,
didClose
};
}
}
return Object.keys(result).length > 1 ? result : void 0;
}
getMatchingCells(notebookDocument, cells = notebookDocument.getCells()) {
if (this.options.notebookSelector === void 0) {
return void 0;
}
for (const item of this.options.notebookSelector) {
if (item.notebook === void 0 || $NotebookDocumentFilter.matchNotebook(item.notebook, notebookDocument)) {
const filtered = this.filterCells(notebookDocument, cells, item.cells);
return filtered.length === 0 ? void 0 : filtered;
}
}
return void 0;
}
cellMatches(notebookDocument, cell) {
const cells = this.getMatchingCells(notebookDocument, [cell]);
return cells !== void 0 && cells[0] === cell;
}
filterCells(notebookDocument, cells, cellSelector) {
const filtered = cellSelector !== void 0 ? cells.filter((cell) => {
const cellLanguage = cell.document.languageId;
return cellSelector.some(((filter) => filter.language === "*" || cellLanguage === filter.language));
}) : cells;
return typeof this.client.clientOptions.notebookDocumentOptions?.filterCells === "function" ? this.client.clientOptions.notebookDocumentOptions.filterCells(notebookDocument, filtered) : filtered;
}
};
var NotebookDocumentSyncFeature = class _NotebookDocumentSyncFeature {
constructor(client) {
this.client = client;
this.registrations = /* @__PURE__ */ new Map();
this.registrationType = proto.NotebookDocumentSyncRegistrationType.type;
vscode22.workspace.onDidOpenTextDocument((textDocument) => {
if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
return;
}
const [notebookDocument, notebookCell] = this.findNotebookDocumentAndCell(textDocument);
if (notebookDocument === void 0 || notebookCell === void 0) {
return;
}
for (const provider of this.registrations.values()) {
if (provider instanceof NotebookDocumentSyncFeatureProvider) {
provider.didOpenNotebookCellTextDocument(notebookDocument, notebookCell);
}
}
});
vscode22.workspace.onDidChangeTextDocument((event) => {
if (event.contentChanges.length === 0) {
return;
}
const textDocument = event.document;
if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
return;
}
const [notebookDocument] = this.findNotebookDocumentAndCell(textDocument);
if (notebookDocument === void 0) {
return;
}
for (const provider of this.registrations.values()) {
if (provider instanceof NotebookDocumentSyncFeatureProvider) {
provider.didChangeNotebookCellTextDocument(notebookDocument, event);
}
}
});
vscode22.workspace.onDidCloseTextDocument((textDocument) => {
if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
return;
}
const [notebookDocument, notebookCell] = this.findNotebookDocumentAndCell(textDocument);
if (notebookDocument === void 0 || notebookCell === void 0) {
return;
}
for (const provider of this.registrations.values()) {
if (provider instanceof NotebookDocumentSyncFeatureProvider) {
provider.didCloseNotebookCellTextDocument(notebookDocument, notebookCell);
}
}
});
}
getState() {
if (this.registrations.size === 0) {
return { kind: "document", id: this.registrationType.method, registrations: false, matches: false };
}
for (const provider of this.registrations.values()) {
const state = provider.getState();
if (state.kind === "document" && state.registrations === true && state.matches === true) {
return { kind: "document", id: this.registrationType.method, registrations: true, matches: true };
}
}
return { kind: "document", id: this.registrationType.method, registrations: true, matches: false };
}
fillClientCapabilities(capabilities) {
const synchronization = ensure(ensure(capabilities, "notebookDocument"), "synchronization");
synchronization.dynamicRegistration = true;
synchronization.executionSummarySupport = true;
}
preInitialize(capabilities) {
const options = capabilities.notebookDocumentSync;
if (options === void 0) {
return;
}
this.dedicatedChannel = this.client.protocol2CodeConverter.asDocumentSelector($NotebookDocumentSyncOptions.asDocumentSelector(options));
}
initialize(capabilities) {
const options = capabilities.notebookDocumentSync;
if (options === void 0) {
return;
}
const id = options.id ?? UUID.generateUuid();
this.register({ id, registerOptions: options });
}
register(data) {
const provider = new NotebookDocumentSyncFeatureProvider(this.client, data.registerOptions);
this.registrations.set(data.id, provider);
}
unregister(id) {
const provider = this.registrations.get(id);
provider && provider.dispose();
}
clear() {
for (const provider of this.registrations.values()) {
provider.dispose();
}
this.registrations.clear();
}
handles(textDocument) {
if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
return false;
}
if (this.dedicatedChannel !== void 0 && vscode22.languages.match(this.dedicatedChannel, textDocument) > 0) {
return true;
}
for (const provider of this.registrations.values()) {
if (provider.handles(textDocument)) {
return true;
}
}
return false;
}
getProvider(notebookCell) {
for (const provider of this.registrations.values()) {
if (provider.handles(notebookCell.document)) {
return provider;
}
}
return void 0;
}
findNotebookDocumentAndCell(textDocument) {
const uri = textDocument.uri.toString();
for (const notebookDocument of vscode22.workspace.notebookDocuments) {
for (const cell of notebookDocument.getCells()) {
if (cell.document.uri.toString() === uri) {
return [notebookDocument, cell];
}
}
}
return [void 0, void 0];
}
};
exports2.NotebookDocumentSyncFeature = NotebookDocumentSyncFeature;
NotebookDocumentSyncFeature.CellScheme = "vscode-notebook-cell";
}
});
// node_modules/vscode-languageclient/lib/common/configuration.js
var require_configuration = __commonJS({
"node_modules/vscode-languageclient/lib/common/configuration.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SyncConfigurationFeature = exports2.toJSONObject = exports2.ConfigurationFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var Is = require_is();
var UUID = require_uuid();
var features_1 = require_features();
var ConfigurationFeature = class {
constructor(client) {
this._client = client;
}
getState() {
return { kind: "static" };
}
fillClientCapabilities(capabilities) {
capabilities.workspace = capabilities.workspace || {};
capabilities.workspace.configuration = true;
}
initialize() {
let client = this._client;
client.onRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, (params, token) => {
let configuration = (params2) => {
let result = [];
for (let item of params2.items) {
let resource = item.scopeUri !== void 0 && item.scopeUri !== null ? this._client.protocol2CodeConverter.asUri(item.scopeUri) : void 0;
result.push(this.getConfiguration(resource, item.section !== null ? item.section : void 0));
}
return result;
};
let middleware = client.middleware.workspace;
return middleware && middleware.configuration ? middleware.configuration(params, token, configuration) : configuration(params, token);
});
}
getConfiguration(resource, section) {
let result = null;
if (section) {
let index = section.lastIndexOf(".");
if (index === -1) {
result = toJSONObject(vscode_1.workspace.getConfiguration(void 0, resource).get(section));
} else {
let config = vscode_1.workspace.getConfiguration(section.substr(0, index), resource);
if (config) {
result = toJSONObject(config.get(section.substr(index + 1)));
}
}
} else {
let config = vscode_1.workspace.getConfiguration(void 0, resource);
result = {};
for (let key of Object.keys(config)) {
if (config.has(key)) {
result[key] = toJSONObject(config.get(key));
}
}
}
if (result === void 0) {
result = null;
}
return result;
}
clear() {
}
};
exports2.ConfigurationFeature = ConfigurationFeature;
function toJSONObject(obj) {
if (obj) {
if (Array.isArray(obj)) {
return obj.map(toJSONObject);
} else if (typeof obj === "object") {
const res = /* @__PURE__ */ Object.create(null);
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
res[key] = toJSONObject(obj[key]);
}
}
return res;
}
}
return obj;
}
exports2.toJSONObject = toJSONObject;
var SyncConfigurationFeature = class {
constructor(_client) {
this._client = _client;
this.isCleared = false;
this._listeners = /* @__PURE__ */ new Map();
}
getState() {
return { kind: "workspace", id: this.registrationType.method, registrations: this._listeners.size > 0 };
}
get registrationType() {
return vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "didChangeConfiguration").dynamicRegistration = true;
}
initialize() {
this.isCleared = false;
let section = this._client.clientOptions.synchronize?.configurationSection;
if (section !== void 0) {
this.register({
id: UUID.generateUuid(),
registerOptions: {
section
}
});
}
}
register(data) {
let disposable = vscode_1.workspace.onDidChangeConfiguration((event) => {
this.onDidChangeConfiguration(data.registerOptions.section, event);
});
this._listeners.set(data.id, disposable);
if (data.registerOptions.section !== void 0) {
this.onDidChangeConfiguration(data.registerOptions.section, void 0);
}
}
unregister(id) {
let disposable = this._listeners.get(id);
if (disposable) {
this._listeners.delete(id);
disposable.dispose();
}
}
clear() {
for (const disposable of this._listeners.values()) {
disposable.dispose();
}
this._listeners.clear();
this.isCleared = true;
}
onDidChangeConfiguration(configurationSection, event) {
if (this.isCleared) {
return;
}
let sections;
if (Is.string(configurationSection)) {
sections = [configurationSection];
} else {
sections = configurationSection;
}
if (sections !== void 0 && event !== void 0) {
let affected = sections.some((section) => event.affectsConfiguration(section));
if (!affected) {
return;
}
}
const didChangeConfiguration = async (sections2) => {
if (sections2 === void 0) {
return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: null });
} else {
return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: this.extractSettingsInformation(sections2) });
}
};
let middleware = this._client.middleware.workspace?.didChangeConfiguration;
(middleware ? middleware(sections, didChangeConfiguration) : didChangeConfiguration(sections)).catch((error) => {
this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type.method} failed`, error);
});
}
extractSettingsInformation(keys) {
function ensurePath(config, path11) {
let current = config;
for (let i = 0; i < path11.length - 1; i++) {
let obj = current[path11[i]];
if (!obj) {
obj = /* @__PURE__ */ Object.create(null);
current[path11[i]] = obj;
}
current = obj;
}
return current;
}
let resource = this._client.clientOptions.workspaceFolder ? this._client.clientOptions.workspaceFolder.uri : void 0;
let result = /* @__PURE__ */ Object.create(null);
for (let i = 0; i < keys.length; i++) {
let key = keys[i];
let index = key.indexOf(".");
let config = null;
if (index >= 0) {
config = vscode_1.workspace.getConfiguration(key.substr(0, index), resource).get(key.substr(index + 1));
} else {
config = vscode_1.workspace.getConfiguration(void 0, resource).get(key);
}
if (config) {
let path11 = keys[i].split(".");
ensurePath(result, path11)[path11[path11.length - 1]] = toJSONObject(config);
}
}
return result;
}
};
exports2.SyncConfigurationFeature = SyncConfigurationFeature;
}
});
// node_modules/vscode-languageclient/lib/common/textSynchronization.js
var require_textSynchronization = __commonJS({
"node_modules/vscode-languageclient/lib/common/textSynchronization.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DidSaveTextDocumentFeature = exports2.WillSaveWaitUntilFeature = exports2.WillSaveFeature = exports2.DidChangeTextDocumentFeature = exports2.DidCloseTextDocumentFeature = exports2.DidOpenTextDocumentFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var DidOpenTextDocumentFeature = class extends features_1.TextDocumentEventFeature {
constructor(client, syncedDocuments) {
super(client, vscode_1.workspace.onDidOpenTextDocument, vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, () => client.middleware.didOpen, (textDocument) => client.code2ProtocolConverter.asOpenTextDocumentParams(textDocument), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
this._syncedDocuments = syncedDocuments;
}
get openDocuments() {
return this._syncedDocuments.values();
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.openClose) {
this.register({ id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector2 } });
}
}
get registrationType() {
return vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type;
}
register(data) {
super.register(data);
if (!data.registerOptions.documentSelector) {
return;
}
const documentSelector2 = this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector);
vscode_1.workspace.textDocuments.forEach((textDocument) => {
const uri = textDocument.uri.toString();
if (this._syncedDocuments.has(uri)) {
return;
}
if (vscode_1.languages.match(documentSelector2, textDocument) > 0 && !this._client.hasDedicatedTextSynchronizationFeature(textDocument)) {
const middleware = this._client.middleware;
const didOpen = (textDocument2) => {
return this._client.sendNotification(this._type, this._createParams(textDocument2));
};
(middleware.didOpen ? middleware.didOpen(textDocument, didOpen) : didOpen(textDocument)).catch((error) => {
this._client.error(`Sending document notification ${this._type.method} failed`, error);
});
this._syncedDocuments.set(uri, textDocument);
}
});
}
getTextDocument(data) {
return data;
}
notificationSent(textDocument, type, params) {
this._syncedDocuments.set(textDocument.uri.toString(), textDocument);
super.notificationSent(textDocument, type, params);
}
};
exports2.DidOpenTextDocumentFeature = DidOpenTextDocumentFeature;
var DidCloseTextDocumentFeature = class extends features_1.TextDocumentEventFeature {
constructor(client, syncedDocuments, pendingTextDocumentChanges) {
super(client, vscode_1.workspace.onDidCloseTextDocument, vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, () => client.middleware.didClose, (textDocument) => client.code2ProtocolConverter.asCloseTextDocumentParams(textDocument), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
this._syncedDocuments = syncedDocuments;
this._pendingTextDocumentChanges = pendingTextDocumentChanges;
}
get registrationType() {
return vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.openClose) {
this.register({ id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector2 } });
}
}
async callback(data) {
await super.callback(data);
this._pendingTextDocumentChanges.delete(data.uri.toString());
}
getTextDocument(data) {
return data;
}
notificationSent(textDocument, type, params) {
this._syncedDocuments.delete(textDocument.uri.toString());
super.notificationSent(textDocument, type, params);
}
unregister(id) {
const selector = this._selectors.get(id);
super.unregister(id);
const selectors = this._selectors.values();
this._syncedDocuments.forEach((textDocument) => {
if (vscode_1.languages.match(selector, textDocument) > 0 && !this._selectorFilter(selectors, textDocument) && !this._client.hasDedicatedTextSynchronizationFeature(textDocument)) {
let middleware = this._client.middleware;
let didClose = (textDocument2) => {
return this._client.sendNotification(this._type, this._createParams(textDocument2));
};
this._syncedDocuments.delete(textDocument.uri.toString());
(middleware.didClose ? middleware.didClose(textDocument, didClose) : didClose(textDocument)).catch((error) => {
this._client.error(`Sending document notification ${this._type.method} failed`, error);
});
}
});
}
};
exports2.DidCloseTextDocumentFeature = DidCloseTextDocumentFeature;
var DidChangeTextDocumentFeature = class extends features_1.DynamicDocumentFeature {
constructor(client, pendingTextDocumentChanges) {
super(client);
this._changeData = /* @__PURE__ */ new Map();
this._onNotificationSent = new vscode_1.EventEmitter();
this._onPendingChangeAdded = new vscode_1.EventEmitter();
this._pendingTextDocumentChanges = pendingTextDocumentChanges;
this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
}
get onNotificationSent() {
return this._onNotificationSent.event;
}
get onPendingChangeAdded() {
return this._onPendingChangeAdded.event;
}
get syncKind() {
return this._syncKind;
}
get registrationType() {
return vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.change !== void 0 && textDocumentSyncOptions.change !== vscode_languageserver_protocol_1.TextDocumentSyncKind.None) {
this.register({
id: UUID.generateUuid(),
registerOptions: Object.assign({}, { documentSelector: documentSelector2 }, { syncKind: textDocumentSyncOptions.change })
});
}
}
register(data) {
if (!data.registerOptions.documentSelector) {
return;
}
if (!this._listener) {
this._listener = vscode_1.workspace.onDidChangeTextDocument(this.callback, this);
}
this._changeData.set(data.id, {
syncKind: data.registerOptions.syncKind,
documentSelector: this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector)
});
this.updateSyncKind(data.registerOptions.syncKind);
}
*getDocumentSelectors() {
for (const data of this._changeData.values()) {
yield data.documentSelector;
}
}
async callback(event) {
if (event.contentChanges.length === 0) {
return;
}
const uri = event.document.uri;
const version = event.document.version;
const promises = [];
for (const changeData of this._changeData.values()) {
if (vscode_1.languages.match(changeData.documentSelector, event.document) > 0 && !this._client.hasDedicatedTextSynchronizationFeature(event.document)) {
const middleware = this._client.middleware;
if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental) {
const didChange = async (event2) => {
const params = this._client.code2ProtocolConverter.asChangeTextDocumentParams(event2, uri, version);
await this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
this.notificationSent(event2.document, vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
};
promises.push(middleware.didChange ? middleware.didChange(event, (event2) => didChange(event2)) : didChange(event));
} else if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
const didChange = async (event2) => {
const eventUri = event2.document.uri.toString();
this._pendingTextDocumentChanges.set(eventUri, event2.document);
this._onPendingChangeAdded.fire();
};
promises.push(middleware.didChange ? middleware.didChange(event, (event2) => didChange(event2)) : didChange(event));
}
}
}
return Promise.all(promises).then(void 0, (error) => {
this._client.error(`Sending document notification ${vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type.method} failed`, error);
throw error;
});
}
notificationSent(textDocument, type, params) {
this._onNotificationSent.fire({ textDocument, type, params });
}
unregister(id) {
this._changeData.delete(id);
if (this._changeData.size === 0) {
if (this._listener) {
this._listener.dispose();
this._listener = void 0;
}
this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
} else {
this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
for (const changeData of this._changeData.values()) {
this.updateSyncKind(changeData.syncKind);
if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
break;
}
}
}
}
clear() {
this._pendingTextDocumentChanges.clear();
this._changeData.clear();
this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
if (this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
getPendingDocumentChanges(excludes) {
if (this._pendingTextDocumentChanges.size === 0) {
return [];
}
let result;
if (excludes.size === 0) {
result = Array.from(this._pendingTextDocumentChanges.values());
this._pendingTextDocumentChanges.clear();
} else {
result = [];
for (const entry of this._pendingTextDocumentChanges) {
if (!excludes.has(entry[0])) {
result.push(entry[1]);
this._pendingTextDocumentChanges.delete(entry[0]);
}
}
}
return result;
}
getProvider(document) {
for (const changeData of this._changeData.values()) {
if (vscode_1.languages.match(changeData.documentSelector, document) > 0) {
return {
send: (event) => {
return this.callback(event);
}
};
}
}
return void 0;
}
updateSyncKind(syncKind) {
if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
return;
}
switch (syncKind) {
case vscode_languageserver_protocol_1.TextDocumentSyncKind.Full:
this._syncKind = syncKind;
break;
case vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental:
if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.None) {
this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
}
break;
}
}
};
exports2.DidChangeTextDocumentFeature = DidChangeTextDocumentFeature;
var WillSaveFeature = class extends features_1.TextDocumentEventFeature {
constructor(client) {
super(client, vscode_1.workspace.onWillSaveTextDocument, vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, () => client.middleware.willSave, (willSaveEvent) => client.code2ProtocolConverter.asWillSaveTextDocumentParams(willSaveEvent), (event) => event.document, (selectors, willSaveEvent) => features_1.TextDocumentEventFeature.textDocumentFilter(selectors, willSaveEvent.document));
}
get registrationType() {
return vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type;
}
fillClientCapabilities(capabilities) {
let value = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization");
value.willSave = true;
}
initialize(capabilities, documentSelector2) {
let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.willSave) {
this.register({
id: UUID.generateUuid(),
registerOptions: { documentSelector: documentSelector2 }
});
}
}
getTextDocument(data) {
return data.document;
}
};
exports2.WillSaveFeature = WillSaveFeature;
var WillSaveWaitUntilFeature = class extends features_1.DynamicDocumentFeature {
constructor(client) {
super(client);
this._selectors = /* @__PURE__ */ new Map();
}
getDocumentSelectors() {
return this._selectors.values();
}
get registrationType() {
return vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type;
}
fillClientCapabilities(capabilities) {
let value = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization");
value.willSaveWaitUntil = true;
}
initialize(capabilities, documentSelector2) {
let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.willSaveWaitUntil) {
this.register({
id: UUID.generateUuid(),
registerOptions: { documentSelector: documentSelector2 }
});
}
}
register(data) {
if (!data.registerOptions.documentSelector) {
return;
}
if (!this._listener) {
this._listener = vscode_1.workspace.onWillSaveTextDocument(this.callback, this);
}
this._selectors.set(data.id, this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector));
}
callback(event) {
if (features_1.TextDocumentEventFeature.textDocumentFilter(this._selectors.values(), event.document) && !this._client.hasDedicatedTextSynchronizationFeature(event.document)) {
let middleware = this._client.middleware;
let willSaveWaitUntil = (event2) => {
return this._client.sendRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, this._client.code2ProtocolConverter.asWillSaveTextDocumentParams(event2)).then(async (edits) => {
let vEdits = await this._client.protocol2CodeConverter.asTextEdits(edits);
return vEdits === void 0 ? [] : vEdits;
});
};
event.waitUntil(middleware.willSaveWaitUntil ? middleware.willSaveWaitUntil(event, willSaveWaitUntil) : willSaveWaitUntil(event));
}
}
unregister(id) {
this._selectors.delete(id);
if (this._selectors.size === 0 && this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
clear() {
this._selectors.clear();
if (this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
};
exports2.WillSaveWaitUntilFeature = WillSaveWaitUntilFeature;
var DidSaveTextDocumentFeature = class extends features_1.TextDocumentEventFeature {
constructor(client) {
super(client, vscode_1.workspace.onDidSaveTextDocument, vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, () => client.middleware.didSave, (textDocument) => client.code2ProtocolConverter.asSaveTextDocumentParams(textDocument, this._includeText), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
this._includeText = false;
}
get registrationType() {
return vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "synchronization").didSave = true;
}
initialize(capabilities, documentSelector2) {
const textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
if (documentSelector2 && textDocumentSyncOptions && textDocumentSyncOptions.save) {
const saveOptions = typeof textDocumentSyncOptions.save === "boolean" ? { includeText: false } : { includeText: !!textDocumentSyncOptions.save.includeText };
this.register({
id: UUID.generateUuid(),
registerOptions: Object.assign({}, { documentSelector: documentSelector2 }, saveOptions)
});
}
}
register(data) {
this._includeText = !!data.registerOptions.includeText;
super.register(data);
}
getTextDocument(data) {
return data;
}
};
exports2.DidSaveTextDocumentFeature = DidSaveTextDocumentFeature;
}
});
// node_modules/vscode-languageclient/lib/common/completion.js
var require_completion = __commonJS({
"node_modules/vscode-languageclient/lib/common/completion.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CompletionItemFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var SupportedCompletionItemKinds = [
vscode_languageserver_protocol_1.CompletionItemKind.Text,
vscode_languageserver_protocol_1.CompletionItemKind.Method,
vscode_languageserver_protocol_1.CompletionItemKind.Function,
vscode_languageserver_protocol_1.CompletionItemKind.Constructor,
vscode_languageserver_protocol_1.CompletionItemKind.Field,
vscode_languageserver_protocol_1.CompletionItemKind.Variable,
vscode_languageserver_protocol_1.CompletionItemKind.Class,
vscode_languageserver_protocol_1.CompletionItemKind.Interface,
vscode_languageserver_protocol_1.CompletionItemKind.Module,
vscode_languageserver_protocol_1.CompletionItemKind.Property,
vscode_languageserver_protocol_1.CompletionItemKind.Unit,
vscode_languageserver_protocol_1.CompletionItemKind.Value,
vscode_languageserver_protocol_1.CompletionItemKind.Enum,
vscode_languageserver_protocol_1.CompletionItemKind.Keyword,
vscode_languageserver_protocol_1.CompletionItemKind.Snippet,
vscode_languageserver_protocol_1.CompletionItemKind.Color,
vscode_languageserver_protocol_1.CompletionItemKind.File,
vscode_languageserver_protocol_1.CompletionItemKind.Reference,
vscode_languageserver_protocol_1.CompletionItemKind.Folder,
vscode_languageserver_protocol_1.CompletionItemKind.EnumMember,
vscode_languageserver_protocol_1.CompletionItemKind.Constant,
vscode_languageserver_protocol_1.CompletionItemKind.Struct,
vscode_languageserver_protocol_1.CompletionItemKind.Event,
vscode_languageserver_protocol_1.CompletionItemKind.Operator,
vscode_languageserver_protocol_1.CompletionItemKind.TypeParameter
];
var CompletionItemFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.CompletionRequest.type);
this.labelDetailsSupport = /* @__PURE__ */ new Map();
}
fillClientCapabilities(capabilities) {
let completion = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "completion");
completion.dynamicRegistration = true;
completion.contextSupport = true;
completion.completionItem = {
snippetSupport: true,
commitCharactersSupport: true,
documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText],
deprecatedSupport: true,
preselectSupport: true,
tagSupport: { valueSet: [vscode_languageserver_protocol_1.CompletionItemTag.Deprecated] },
insertReplaceSupport: true,
resolveSupport: {
properties: ["documentation", "detail", "additionalTextEdits"]
},
insertTextModeSupport: { valueSet: [vscode_languageserver_protocol_1.InsertTextMode.asIs, vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation] },
labelDetailsSupport: true
};
completion.insertTextMode = vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation;
completion.completionItemKind = { valueSet: SupportedCompletionItemKinds };
completion.completionList = {
itemDefaults: [
"commitCharacters",
"editRange",
"insertTextFormat",
"insertTextMode",
"data"
]
};
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.completionProvider);
if (!options) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: options
});
}
registerLanguageProvider(options, id) {
this.labelDetailsSupport.set(id, !!options.completionItem?.labelDetailsSupport);
const triggerCharacters = options.triggerCharacters ?? [];
const defaultCommitCharacters = options.allCommitCharacters;
const selector = options.documentSelector;
const provider = {
provideCompletionItems: (document, position, token, context) => {
const client = this._client;
const middleware = this._client.middleware;
const provideCompletionItems = (document2, position2, context2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.CompletionRequest.type, client.code2ProtocolConverter.asCompletionParams(document2, position2, context2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCompletionResult(result, defaultCommitCharacters, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CompletionRequest.type, token2, error, null);
});
};
return middleware.provideCompletionItem ? middleware.provideCompletionItem(document, position, context, token, provideCompletionItems) : provideCompletionItems(document, position, context, token);
},
resolveCompletionItem: options.resolveProvider ? (item, token) => {
const client = this._client;
const middleware = this._client.middleware;
const resolveCompletionItem = (item2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, client.code2ProtocolConverter.asCompletionItem(item2, !!this.labelDetailsSupport.get(id)), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCompletionItem(result);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, token2, error, item2);
});
};
return middleware.resolveCompletionItem ? middleware.resolveCompletionItem(item, token, resolveCompletionItem) : resolveCompletionItem(item, token);
} : void 0
};
return [vscode_1.languages.registerCompletionItemProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, ...triggerCharacters), provider];
}
};
exports2.CompletionItemFeature = CompletionItemFeature;
}
});
// node_modules/vscode-languageclient/lib/common/hover.js
var require_hover = __commonJS({
"node_modules/vscode-languageclient/lib/common/hover.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.HoverFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var HoverFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.HoverRequest.type);
}
fillClientCapabilities(capabilities) {
const hoverCapability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "hover");
hoverCapability.dynamicRegistration = true;
hoverCapability.contentFormat = [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText];
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.hoverProvider);
if (!options) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: options
});
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideHover: (document, position, token) => {
const client = this._client;
const provideHover = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.HoverRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asHover(result);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.HoverRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideHover ? middleware.provideHover(document, position, token, provideHover) : provideHover(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerHoverProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.HoverFeature = HoverFeature;
}
});
// node_modules/vscode-languageclient/lib/common/definition.js
var require_definition = __commonJS({
"node_modules/vscode-languageclient/lib/common/definition.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DefinitionFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var DefinitionFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DefinitionRequest.type);
}
fillClientCapabilities(capabilities) {
let definitionSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "definition");
definitionSupport.dynamicRegistration = true;
definitionSupport.linkSupport = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.definitionProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDefinition: (document, position, token) => {
const client = this._client;
const provideDefinition = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDefinitionResult(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDefinition ? middleware.provideDefinition(document, position, token, provideDefinition) : provideDefinition(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerDefinitionProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.DefinitionFeature = DefinitionFeature;
}
});
// node_modules/vscode-languageclient/lib/common/signatureHelp.js
var require_signatureHelp = __commonJS({
"node_modules/vscode-languageclient/lib/common/signatureHelp.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SignatureHelpFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var SignatureHelpFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.SignatureHelpRequest.type);
}
fillClientCapabilities(capabilities) {
let config = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "signatureHelp");
config.dynamicRegistration = true;
config.signatureInformation = { documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText] };
config.signatureInformation.parameterInformation = { labelOffsetSupport: true };
config.signatureInformation.activeParameterSupport = true;
config.contextSupport = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.signatureHelpProvider);
if (!options) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: options
});
}
registerLanguageProvider(options) {
const provider = {
provideSignatureHelp: (document, position, token, context) => {
const client = this._client;
const providerSignatureHelp = (document2, position2, context2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, client.code2ProtocolConverter.asSignatureHelpParams(document2, position2, context2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asSignatureHelp(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideSignatureHelp ? middleware.provideSignatureHelp(document, position, context, token, providerSignatureHelp) : providerSignatureHelp(document, position, context, token);
}
};
return [this.registerProvider(options, provider), provider];
}
registerProvider(options, provider) {
const selector = this._client.protocol2CodeConverter.asDocumentSelector(options.documentSelector);
if (options.retriggerCharacters === void 0) {
const triggerCharacters = options.triggerCharacters || [];
return vscode_1.languages.registerSignatureHelpProvider(selector, provider, ...triggerCharacters);
} else {
const metaData = {
triggerCharacters: options.triggerCharacters || [],
retriggerCharacters: options.retriggerCharacters || []
};
return vscode_1.languages.registerSignatureHelpProvider(selector, provider, metaData);
}
}
};
exports2.SignatureHelpFeature = SignatureHelpFeature;
}
});
// node_modules/vscode-languageclient/lib/common/documentHighlight.js
var require_documentHighlight = __commonJS({
"node_modules/vscode-languageclient/lib/common/documentHighlight.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DocumentHighlightFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var DocumentHighlightFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentHighlightRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "documentHighlight").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentHighlightProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDocumentHighlights: (document, position, token) => {
const client = this._client;
const _provideDocumentHighlights = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDocumentHighlights(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentHighlights ? middleware.provideDocumentHighlights(document, position, token, _provideDocumentHighlights) : _provideDocumentHighlights(document, position, token);
}
};
return [vscode_1.languages.registerDocumentHighlightProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.DocumentHighlightFeature = DocumentHighlightFeature;
}
});
// node_modules/vscode-languageclient/lib/common/documentSymbol.js
var require_documentSymbol = __commonJS({
"node_modules/vscode-languageclient/lib/common/documentSymbol.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DocumentSymbolFeature = exports2.SupportedSymbolTags = exports2.SupportedSymbolKinds = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
exports2.SupportedSymbolKinds = [
vscode_languageserver_protocol_1.SymbolKind.File,
vscode_languageserver_protocol_1.SymbolKind.Module,
vscode_languageserver_protocol_1.SymbolKind.Namespace,
vscode_languageserver_protocol_1.SymbolKind.Package,
vscode_languageserver_protocol_1.SymbolKind.Class,
vscode_languageserver_protocol_1.SymbolKind.Method,
vscode_languageserver_protocol_1.SymbolKind.Property,
vscode_languageserver_protocol_1.SymbolKind.Field,
vscode_languageserver_protocol_1.SymbolKind.Constructor,
vscode_languageserver_protocol_1.SymbolKind.Enum,
vscode_languageserver_protocol_1.SymbolKind.Interface,
vscode_languageserver_protocol_1.SymbolKind.Function,
vscode_languageserver_protocol_1.SymbolKind.Variable,
vscode_languageserver_protocol_1.SymbolKind.Constant,
vscode_languageserver_protocol_1.SymbolKind.String,
vscode_languageserver_protocol_1.SymbolKind.Number,
vscode_languageserver_protocol_1.SymbolKind.Boolean,
vscode_languageserver_protocol_1.SymbolKind.Array,
vscode_languageserver_protocol_1.SymbolKind.Object,
vscode_languageserver_protocol_1.SymbolKind.Key,
vscode_languageserver_protocol_1.SymbolKind.Null,
vscode_languageserver_protocol_1.SymbolKind.EnumMember,
vscode_languageserver_protocol_1.SymbolKind.Struct,
vscode_languageserver_protocol_1.SymbolKind.Event,
vscode_languageserver_protocol_1.SymbolKind.Operator,
vscode_languageserver_protocol_1.SymbolKind.TypeParameter
];
exports2.SupportedSymbolTags = [
vscode_languageserver_protocol_1.SymbolTag.Deprecated
];
var DocumentSymbolFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentSymbolRequest.type);
}
fillClientCapabilities(capabilities) {
let symbolCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "documentSymbol");
symbolCapabilities.dynamicRegistration = true;
symbolCapabilities.symbolKind = {
valueSet: exports2.SupportedSymbolKinds
};
symbolCapabilities.hierarchicalDocumentSymbolSupport = true;
symbolCapabilities.tagSupport = {
valueSet: exports2.SupportedSymbolTags
};
symbolCapabilities.labelSupport = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentSymbolProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDocumentSymbols: (document, token) => {
const client = this._client;
const _provideDocumentSymbols = async (document2, token2) => {
try {
const data = await client.sendRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, client.code2ProtocolConverter.asDocumentSymbolParams(document2), token2);
if (token2.isCancellationRequested || data === void 0 || data === null) {
return null;
}
if (data.length === 0) {
return [];
} else {
const first = data[0];
if (vscode_languageserver_protocol_1.DocumentSymbol.is(first)) {
return await client.protocol2CodeConverter.asDocumentSymbols(data, token2);
} else {
return await client.protocol2CodeConverter.asSymbolInformations(data, token2);
}
}
} catch (error) {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, token2, error, null);
}
};
const middleware = client.middleware;
return middleware.provideDocumentSymbols ? middleware.provideDocumentSymbols(document, token, _provideDocumentSymbols) : _provideDocumentSymbols(document, token);
}
};
const metaData = options.label !== void 0 ? { label: options.label } : void 0;
return [vscode_1.languages.registerDocumentSymbolProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, metaData), provider];
}
};
exports2.DocumentSymbolFeature = DocumentSymbolFeature;
}
});
// node_modules/vscode-languageclient/lib/common/workspaceSymbol.js
var require_workspaceSymbol = __commonJS({
"node_modules/vscode-languageclient/lib/common/workspaceSymbol.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WorkspaceSymbolFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var documentSymbol_1 = require_documentSymbol();
var UUID = require_uuid();
var WorkspaceSymbolFeature = class extends features_1.WorkspaceFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type);
}
fillClientCapabilities(capabilities) {
let symbolCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "symbol");
symbolCapabilities.dynamicRegistration = true;
symbolCapabilities.symbolKind = {
valueSet: documentSymbol_1.SupportedSymbolKinds
};
symbolCapabilities.tagSupport = {
valueSet: documentSymbol_1.SupportedSymbolTags
};
symbolCapabilities.resolveSupport = { properties: ["location.range"] };
}
initialize(capabilities) {
if (!capabilities.workspaceSymbolProvider) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: capabilities.workspaceSymbolProvider === true ? { workDoneProgress: false } : capabilities.workspaceSymbolProvider
});
}
registerLanguageProvider(options) {
const provider = {
provideWorkspaceSymbols: (query, token) => {
const client = this._client;
const provideWorkspaceSymbols = (query2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, { query: query2 }, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asSymbolInformations(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideWorkspaceSymbols ? middleware.provideWorkspaceSymbols(query, token, provideWorkspaceSymbols) : provideWorkspaceSymbols(query, token);
},
resolveWorkspaceSymbol: options.resolveProvider === true ? (item, token) => {
const client = this._client;
const resolveWorkspaceSymbol = (item2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, client.code2ProtocolConverter.asWorkspaceSymbol(item2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asSymbolInformation(result);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.resolveWorkspaceSymbol ? middleware.resolveWorkspaceSymbol(item, token, resolveWorkspaceSymbol) : resolveWorkspaceSymbol(item, token);
} : void 0
};
return [vscode_1.languages.registerWorkspaceSymbolProvider(provider), provider];
}
};
exports2.WorkspaceSymbolFeature = WorkspaceSymbolFeature;
}
});
// node_modules/vscode-languageclient/lib/common/reference.js
var require_reference = __commonJS({
"node_modules/vscode-languageclient/lib/common/reference.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ReferencesFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var ReferencesFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.ReferencesRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "references").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.referencesProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideReferences: (document, position, options2, token) => {
const client = this._client;
const _providerReferences = (document2, position2, options3, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, client.code2ProtocolConverter.asReferenceParams(document2, position2, options3), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asReferences(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideReferences ? middleware.provideReferences(document, position, options2, token, _providerReferences) : _providerReferences(document, position, options2, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerReferenceProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.ReferencesFeature = ReferencesFeature;
}
});
// node_modules/vscode-languageclient/lib/common/codeAction.js
var require_codeAction = __commonJS({
"node_modules/vscode-languageclient/lib/common/codeAction.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CodeActionFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var UUID = require_uuid();
var features_1 = require_features();
var CodeActionFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.CodeActionRequest.type);
}
fillClientCapabilities(capabilities) {
const cap = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "codeAction");
cap.dynamicRegistration = true;
cap.isPreferredSupport = true;
cap.disabledSupport = true;
cap.dataSupport = true;
cap.resolveSupport = {
properties: ["edit"]
};
cap.codeActionLiteralSupport = {
codeActionKind: {
valueSet: [
vscode_languageserver_protocol_1.CodeActionKind.Empty,
vscode_languageserver_protocol_1.CodeActionKind.QuickFix,
vscode_languageserver_protocol_1.CodeActionKind.Refactor,
vscode_languageserver_protocol_1.CodeActionKind.RefactorExtract,
vscode_languageserver_protocol_1.CodeActionKind.RefactorInline,
vscode_languageserver_protocol_1.CodeActionKind.RefactorRewrite,
vscode_languageserver_protocol_1.CodeActionKind.Source,
vscode_languageserver_protocol_1.CodeActionKind.SourceOrganizeImports
]
}
};
cap.honorsChangeAnnotations = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.codeActionProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideCodeActions: (document, range, context, token) => {
const client = this._client;
const _provideCodeActions = async (document2, range2, context2, token2) => {
const params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
range: client.code2ProtocolConverter.asRange(range2),
context: client.code2ProtocolConverter.asCodeActionContextSync(context2)
};
return client.sendRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, params, token2).then((values) => {
if (token2.isCancellationRequested || values === null || values === void 0) {
return null;
}
return client.protocol2CodeConverter.asCodeActionResult(values, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideCodeActions ? middleware.provideCodeActions(document, range, context, token, _provideCodeActions) : _provideCodeActions(document, range, context, token);
},
resolveCodeAction: options.resolveProvider ? (item, token) => {
const client = this._client;
const middleware = this._client.middleware;
const resolveCodeAction = async (item2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, client.code2ProtocolConverter.asCodeActionSync(item2), token2).then((result) => {
if (token2.isCancellationRequested) {
return item2;
}
return client.protocol2CodeConverter.asCodeAction(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, token2, error, item2);
});
};
return middleware.resolveCodeAction ? middleware.resolveCodeAction(item, token, resolveCodeAction) : resolveCodeAction(item, token);
} : void 0
};
return [vscode_1.languages.registerCodeActionsProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, options.codeActionKinds ? { providedCodeActionKinds: this._client.protocol2CodeConverter.asCodeActionKinds(options.codeActionKinds) } : void 0), provider];
}
};
exports2.CodeActionFeature = CodeActionFeature;
}
});
// node_modules/vscode-languageclient/lib/common/codeLens.js
var require_codeLens = __commonJS({
"node_modules/vscode-languageclient/lib/common/codeLens.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CodeLensFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var UUID = require_uuid();
var features_1 = require_features();
var CodeLensFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.CodeLensRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "codeLens").dynamicRegistration = true;
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "codeLens").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
const client = this._client;
client.onRequest(vscode_languageserver_protocol_1.CodeLensRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeCodeLensEmitter.fire();
}
});
const options = this.getRegistrationOptions(documentSelector2, capabilities.codeLensProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const eventEmitter = new vscode_1.EventEmitter();
const provider = {
onDidChangeCodeLenses: eventEmitter.event,
provideCodeLenses: (document, token) => {
const client = this._client;
const provideCodeLenses = (document2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, client.code2ProtocolConverter.asCodeLensParams(document2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCodeLenses(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideCodeLenses ? middleware.provideCodeLenses(document, token, provideCodeLenses) : provideCodeLenses(document, token);
},
resolveCodeLens: options.resolveProvider ? (codeLens, token) => {
const client = this._client;
const resolveCodeLens = (codeLens2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, client.code2ProtocolConverter.asCodeLens(codeLens2), token2).then((result) => {
if (token2.isCancellationRequested) {
return codeLens2;
}
return client.protocol2CodeConverter.asCodeLens(result);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, token2, error, codeLens2);
});
};
const middleware = client.middleware;
return middleware.resolveCodeLens ? middleware.resolveCodeLens(codeLens, token, resolveCodeLens) : resolveCodeLens(codeLens, token);
} : void 0
};
return [vscode_1.languages.registerCodeLensProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), { provider, onDidChangeCodeLensEmitter: eventEmitter }];
}
};
exports2.CodeLensFeature = CodeLensFeature;
}
});
// node_modules/vscode-languageclient/lib/common/formatting.js
var require_formatting = __commonJS({
"node_modules/vscode-languageclient/lib/common/formatting.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DocumentOnTypeFormattingFeature = exports2.DocumentRangeFormattingFeature = exports2.DocumentFormattingFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var UUID = require_uuid();
var features_1 = require_features();
var FileFormattingOptions;
(function(FileFormattingOptions2) {
function fromConfiguration(document) {
const filesConfig = vscode_1.workspace.getConfiguration("files", document);
return {
trimTrailingWhitespace: filesConfig.get("trimTrailingWhitespace"),
trimFinalNewlines: filesConfig.get("trimFinalNewlines"),
insertFinalNewline: filesConfig.get("insertFinalNewline")
};
}
FileFormattingOptions2.fromConfiguration = fromConfiguration;
})(FileFormattingOptions || (FileFormattingOptions = {}));
var DocumentFormattingFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentFormattingRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "formatting").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentFormattingProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDocumentFormattingEdits: (document, options2, token) => {
const client = this._client;
const provideDocumentFormattingEdits = (document2, options3, token2) => {
const params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
options: client.code2ProtocolConverter.asFormattingOptions(options3, FileFormattingOptions.fromConfiguration(document2))
};
return client.sendRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTextEdits(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentFormattingEdits ? middleware.provideDocumentFormattingEdits(document, options2, token, provideDocumentFormattingEdits) : provideDocumentFormattingEdits(document, options2, token);
}
};
return [vscode_1.languages.registerDocumentFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.DocumentFormattingFeature = DocumentFormattingFeature;
var DocumentRangeFormattingFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type);
}
fillClientCapabilities(capabilities) {
const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "rangeFormatting");
capability.dynamicRegistration = true;
capability.rangesSupport = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentRangeFormattingProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDocumentRangeFormattingEdits: (document, range, options2, token) => {
const client = this._client;
const provideDocumentRangeFormattingEdits = (document2, range2, options3, token2) => {
const params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
range: client.code2ProtocolConverter.asRange(range2),
options: client.code2ProtocolConverter.asFormattingOptions(options3, FileFormattingOptions.fromConfiguration(document2))
};
return client.sendRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTextEdits(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentRangeFormattingEdits ? middleware.provideDocumentRangeFormattingEdits(document, range, options2, token, provideDocumentRangeFormattingEdits) : provideDocumentRangeFormattingEdits(document, range, options2, token);
}
};
if (options.rangesSupport) {
provider.provideDocumentRangesFormattingEdits = (document, ranges, options2, token) => {
const client = this._client;
const provideDocumentRangesFormattingEdits = (document2, ranges2, options3, token2) => {
const params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
ranges: client.code2ProtocolConverter.asRanges(ranges2),
options: client.code2ProtocolConverter.asFormattingOptions(options3, FileFormattingOptions.fromConfiguration(document2))
};
return client.sendRequest(vscode_languageserver_protocol_1.DocumentRangesFormattingRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTextEdits(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentRangesFormattingRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentRangesFormattingEdits ? middleware.provideDocumentRangesFormattingEdits(document, ranges, options2, token, provideDocumentRangesFormattingEdits) : provideDocumentRangesFormattingEdits(document, ranges, options2, token);
};
}
return [vscode_1.languages.registerDocumentRangeFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.DocumentRangeFormattingFeature = DocumentRangeFormattingFeature;
var DocumentOnTypeFormattingFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "onTypeFormatting").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentOnTypeFormattingProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideOnTypeFormattingEdits: (document, position, ch, options2, token) => {
const client = this._client;
const provideOnTypeFormattingEdits = (document2, position2, ch2, options3, token2) => {
let params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
position: client.code2ProtocolConverter.asPosition(position2),
ch: ch2,
options: client.code2ProtocolConverter.asFormattingOptions(options3, FileFormattingOptions.fromConfiguration(document2))
};
return client.sendRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTextEdits(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideOnTypeFormattingEdits ? middleware.provideOnTypeFormattingEdits(document, position, ch, options2, token, provideOnTypeFormattingEdits) : provideOnTypeFormattingEdits(document, position, ch, options2, token);
}
};
const moreTriggerCharacter = options.moreTriggerCharacter || [];
return [vscode_1.languages.registerOnTypeFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, options.firstTriggerCharacter, ...moreTriggerCharacter), provider];
}
};
exports2.DocumentOnTypeFormattingFeature = DocumentOnTypeFormattingFeature;
}
});
// node_modules/vscode-languageclient/lib/common/rename.js
var require_rename = __commonJS({
"node_modules/vscode-languageclient/lib/common/rename.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.RenameFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var UUID = require_uuid();
var Is = require_is();
var features_1 = require_features();
var RenameFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.RenameRequest.type);
}
fillClientCapabilities(capabilities) {
let rename = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "rename");
rename.dynamicRegistration = true;
rename.prepareSupport = true;
rename.prepareSupportDefaultBehavior = vscode_languageserver_protocol_1.PrepareSupportDefaultBehavior.Identifier;
rename.honorsChangeAnnotations = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.renameProvider);
if (!options) {
return;
}
if (Is.boolean(capabilities.renameProvider)) {
options.prepareProvider = false;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideRenameEdits: (document, position, newName, token) => {
const client = this._client;
const provideRenameEdits = (document2, position2, newName2, token2) => {
let params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
position: client.code2ProtocolConverter.asPosition(position2),
newName: newName2
};
return client.sendRequest(vscode_languageserver_protocol_1.RenameRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asWorkspaceEdit(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.RenameRequest.type, token2, error, null, false);
});
};
const middleware = client.middleware;
return middleware.provideRenameEdits ? middleware.provideRenameEdits(document, position, newName, token, provideRenameEdits) : provideRenameEdits(document, position, newName, token);
},
prepareRename: options.prepareProvider ? (document, position, token) => {
const client = this._client;
const prepareRename = (document2, position2, token2) => {
let params = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
position: client.code2ProtocolConverter.asPosition(position2)
};
return client.sendRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
if (vscode_languageserver_protocol_1.Range.is(result)) {
return client.protocol2CodeConverter.asRange(result);
} else if (this.isDefaultBehavior(result)) {
return result.defaultBehavior === true ? null : Promise.reject(new Error(`The element can't be renamed.`));
} else if (result && vscode_languageserver_protocol_1.Range.is(result.range)) {
return {
range: client.protocol2CodeConverter.asRange(result.range),
placeholder: result.placeholder
};
}
return Promise.reject(new Error(`The element can't be renamed.`));
}, (error) => {
if (typeof error.message === "string") {
throw new Error(error.message);
} else {
throw new Error(`The element can't be renamed.`);
}
});
};
const middleware = client.middleware;
return middleware.prepareRename ? middleware.prepareRename(document, position, token, prepareRename) : prepareRename(document, position, token);
} : void 0
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerRenameProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
isDefaultBehavior(value) {
const candidate = value;
return candidate && Is.boolean(candidate.defaultBehavior);
}
};
exports2.RenameFeature = RenameFeature;
}
});
// node_modules/vscode-languageclient/lib/common/documentLink.js
var require_documentLink = __commonJS({
"node_modules/vscode-languageclient/lib/common/documentLink.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DocumentLinkFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var DocumentLinkFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentLinkRequest.type);
}
fillClientCapabilities(capabilities) {
const documentLinkCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "documentLink");
documentLinkCapabilities.dynamicRegistration = true;
documentLinkCapabilities.tooltipSupport = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.documentLinkProvider);
if (!options) {
return;
}
this.register({ id: UUID.generateUuid(), registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDocumentLinks: (document, token) => {
const client = this._client;
const provideDocumentLinks = (document2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, client.code2ProtocolConverter.asDocumentLinkParams(document2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDocumentLinks(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentLinks ? middleware.provideDocumentLinks(document, token, provideDocumentLinks) : provideDocumentLinks(document, token);
},
resolveDocumentLink: options.resolveProvider ? (link, token) => {
const client = this._client;
let resolveDocumentLink = (link2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, client.code2ProtocolConverter.asDocumentLink(link2), token2).then((result) => {
if (token2.isCancellationRequested) {
return link2;
}
return client.protocol2CodeConverter.asDocumentLink(result);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, token2, error, link2);
});
};
const middleware = client.middleware;
return middleware.resolveDocumentLink ? middleware.resolveDocumentLink(link, token, resolveDocumentLink) : resolveDocumentLink(link, token);
} : void 0
};
return [vscode_1.languages.registerDocumentLinkProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.DocumentLinkFeature = DocumentLinkFeature;
}
});
// node_modules/vscode-languageclient/lib/common/executeCommand.js
var require_executeCommand = __commonJS({
"node_modules/vscode-languageclient/lib/common/executeCommand.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ExecuteCommandFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var UUID = require_uuid();
var features_1 = require_features();
var ExecuteCommandFeature = class {
constructor(client) {
this._client = client;
this._commands = /* @__PURE__ */ new Map();
}
getState() {
return { kind: "workspace", id: this.registrationType.method, registrations: this._commands.size > 0 };
}
get registrationType() {
return vscode_languageserver_protocol_1.ExecuteCommandRequest.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "executeCommand").dynamicRegistration = true;
}
initialize(capabilities) {
if (!capabilities.executeCommandProvider) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: Object.assign({}, capabilities.executeCommandProvider)
});
}
register(data) {
const client = this._client;
const middleware = client.middleware;
const executeCommand = (command, args) => {
let params = {
command,
arguments: args
};
return client.sendRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, params).then(void 0, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, void 0, error, void 0);
});
};
if (data.registerOptions.commands) {
const disposables = [];
for (const command of data.registerOptions.commands) {
disposables.push(vscode_1.commands.registerCommand(command, (...args) => {
return middleware.executeCommand ? middleware.executeCommand(command, args, executeCommand) : executeCommand(command, args);
}));
}
this._commands.set(data.id, disposables);
}
}
unregister(id) {
let disposables = this._commands.get(id);
if (disposables) {
disposables.forEach((disposable) => disposable.dispose());
}
}
clear() {
this._commands.forEach((value) => {
value.forEach((disposable) => disposable.dispose());
});
this._commands.clear();
}
};
exports2.ExecuteCommandFeature = ExecuteCommandFeature;
}
});
// node_modules/vscode-languageclient/lib/common/fileSystemWatcher.js
var require_fileSystemWatcher = __commonJS({
"node_modules/vscode-languageclient/lib/common/fileSystemWatcher.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.FileSystemWatcherFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var FileSystemWatcherFeature = class {
constructor(client, notifyFileEvent) {
this._client = client;
this._notifyFileEvent = notifyFileEvent;
this._watchers = /* @__PURE__ */ new Map();
}
getState() {
return { kind: "workspace", id: this.registrationType.method, registrations: this._watchers.size > 0 };
}
get registrationType() {
return vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type;
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "didChangeWatchedFiles").dynamicRegistration = true;
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "didChangeWatchedFiles").relativePatternSupport = true;
}
initialize(_capabilities, _documentSelector) {
}
register(data) {
if (!Array.isArray(data.registerOptions.watchers)) {
return;
}
const disposables = [];
for (const watcher of data.registerOptions.watchers) {
const globPattern = this._client.protocol2CodeConverter.asGlobPattern(watcher.globPattern);
if (globPattern === void 0) {
continue;
}
let watchCreate = true, watchChange = true, watchDelete = true;
if (watcher.kind !== void 0 && watcher.kind !== null) {
watchCreate = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Create) !== 0;
watchChange = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Change) !== 0;
watchDelete = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Delete) !== 0;
}
const fileSystemWatcher = vscode_1.workspace.createFileSystemWatcher(globPattern, !watchCreate, !watchChange, !watchDelete);
this.hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, disposables);
disposables.push(fileSystemWatcher);
}
this._watchers.set(data.id, disposables);
}
registerRaw(id, fileSystemWatchers) {
let disposables = [];
for (let fileSystemWatcher of fileSystemWatchers) {
this.hookListeners(fileSystemWatcher, true, true, true, disposables);
}
this._watchers.set(id, disposables);
}
hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, listeners) {
if (watchCreate) {
fileSystemWatcher.onDidCreate((resource) => this._notifyFileEvent({
uri: this._client.code2ProtocolConverter.asUri(resource),
type: vscode_languageserver_protocol_1.FileChangeType.Created
}), null, listeners);
}
if (watchChange) {
fileSystemWatcher.onDidChange((resource) => this._notifyFileEvent({
uri: this._client.code2ProtocolConverter.asUri(resource),
type: vscode_languageserver_protocol_1.FileChangeType.Changed
}), null, listeners);
}
if (watchDelete) {
fileSystemWatcher.onDidDelete((resource) => this._notifyFileEvent({
uri: this._client.code2ProtocolConverter.asUri(resource),
type: vscode_languageserver_protocol_1.FileChangeType.Deleted
}), null, listeners);
}
}
unregister(id) {
let disposables = this._watchers.get(id);
if (disposables) {
for (let disposable of disposables) {
disposable.dispose();
}
}
}
clear() {
this._watchers.forEach((disposables) => {
for (let disposable of disposables) {
disposable.dispose();
}
});
this._watchers.clear();
}
};
exports2.FileSystemWatcherFeature = FileSystemWatcherFeature;
}
});
// node_modules/vscode-languageclient/lib/common/colorProvider.js
var require_colorProvider = __commonJS({
"node_modules/vscode-languageclient/lib/common/colorProvider.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ColorProviderFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var ColorProviderFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DocumentColorRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "colorProvider").dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
let [id, options] = this.getRegistration(documentSelector2, capabilities.colorProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideColorPresentations: (color, context, token) => {
const client = this._client;
const provideColorPresentations = (color2, context2, token2) => {
const requestParams = {
color: color2,
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(context2.document),
range: client.code2ProtocolConverter.asRange(context2.range)
};
return client.sendRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, requestParams, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return this._client.protocol2CodeConverter.asColorPresentations(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideColorPresentations ? middleware.provideColorPresentations(color, context, token, provideColorPresentations) : provideColorPresentations(color, context, token);
},
provideDocumentColors: (document, token) => {
const client = this._client;
const provideDocumentColors = (document2, token2) => {
const requestParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2)
};
return client.sendRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, requestParams, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return this._client.protocol2CodeConverter.asColorInformations(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDocumentColors ? middleware.provideDocumentColors(document, token, provideDocumentColors) : provideDocumentColors(document, token);
}
};
return [vscode_1.languages.registerColorProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.ColorProviderFeature = ColorProviderFeature;
}
});
// node_modules/vscode-languageclient/lib/common/implementation.js
var require_implementation = __commonJS({
"node_modules/vscode-languageclient/lib/common/implementation.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ImplementationFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var ImplementationFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.ImplementationRequest.type);
}
fillClientCapabilities(capabilities) {
let implementationSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "implementation");
implementationSupport.dynamicRegistration = true;
implementationSupport.linkSupport = true;
}
initialize(capabilities, documentSelector2) {
let [id, options] = this.getRegistration(documentSelector2, capabilities.implementationProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideImplementation: (document, position, token) => {
const client = this._client;
const provideImplementation = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDefinitionResult(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideImplementation ? middleware.provideImplementation(document, position, token, provideImplementation) : provideImplementation(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerImplementationProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.ImplementationFeature = ImplementationFeature;
}
});
// node_modules/vscode-languageclient/lib/common/typeDefinition.js
var require_typeDefinition = __commonJS({
"node_modules/vscode-languageclient/lib/common/typeDefinition.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TypeDefinitionFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var TypeDefinitionFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.TypeDefinitionRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "typeDefinition").dynamicRegistration = true;
let typeDefinitionSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "typeDefinition");
typeDefinitionSupport.dynamicRegistration = true;
typeDefinitionSupport.linkSupport = true;
}
initialize(capabilities, documentSelector2) {
let [id, options] = this.getRegistration(documentSelector2, capabilities.typeDefinitionProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideTypeDefinition: (document, position, token) => {
const client = this._client;
const provideTypeDefinition = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDefinitionResult(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideTypeDefinition ? middleware.provideTypeDefinition(document, position, token, provideTypeDefinition) : provideTypeDefinition(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerTypeDefinitionProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.TypeDefinitionFeature = TypeDefinitionFeature;
}
});
// node_modules/vscode-languageclient/lib/common/workspaceFolder.js
var require_workspaceFolder = __commonJS({
"node_modules/vscode-languageclient/lib/common/workspaceFolder.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WorkspaceFoldersFeature = exports2.arrayDiff = void 0;
var UUID = require_uuid();
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
function access(target, key) {
if (target === void 0 || target === null) {
return void 0;
}
return target[key];
}
function arrayDiff(left, right) {
return left.filter((element) => right.indexOf(element) < 0);
}
exports2.arrayDiff = arrayDiff;
var WorkspaceFoldersFeature = class {
constructor(client) {
this._client = client;
this._listeners = /* @__PURE__ */ new Map();
}
getState() {
return { kind: "workspace", id: this.registrationType.method, registrations: this._listeners.size > 0 };
}
get registrationType() {
return vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type;
}
fillInitializeParams(params) {
const folders = vscode_1.workspace.workspaceFolders;
this.initializeWithFolders(folders);
if (folders === void 0) {
params.workspaceFolders = null;
} else {
params.workspaceFolders = folders.map((folder) => this.asProtocol(folder));
}
}
initializeWithFolders(currentWorkspaceFolders) {
this._initialFolders = currentWorkspaceFolders;
}
fillClientCapabilities(capabilities) {
capabilities.workspace = capabilities.workspace || {};
capabilities.workspace.workspaceFolders = true;
}
initialize(capabilities) {
const client = this._client;
client.onRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, (token) => {
const workspaceFolders = () => {
const folders = vscode_1.workspace.workspaceFolders;
if (folders === void 0) {
return null;
}
const result = folders.map((folder) => {
return this.asProtocol(folder);
});
return result;
};
const middleware = client.middleware.workspace;
return middleware && middleware.workspaceFolders ? middleware.workspaceFolders(token, workspaceFolders) : workspaceFolders(token);
});
const value = access(access(access(capabilities, "workspace"), "workspaceFolders"), "changeNotifications");
let id;
if (typeof value === "string") {
id = value;
} else if (value === true) {
id = UUID.generateUuid();
}
if (id) {
this.register({ id, registerOptions: void 0 });
}
}
sendInitialEvent(currentWorkspaceFolders) {
let promise;
if (this._initialFolders && currentWorkspaceFolders) {
const removed = arrayDiff(this._initialFolders, currentWorkspaceFolders);
const added = arrayDiff(currentWorkspaceFolders, this._initialFolders);
if (added.length > 0 || removed.length > 0) {
promise = this.doSendEvent(added, removed);
}
} else if (this._initialFolders) {
promise = this.doSendEvent([], this._initialFolders);
} else if (currentWorkspaceFolders) {
promise = this.doSendEvent(currentWorkspaceFolders, []);
}
if (promise !== void 0) {
promise.catch((error) => {
this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
});
}
}
doSendEvent(addedFolders, removedFolders) {
let params = {
event: {
added: addedFolders.map((folder) => this.asProtocol(folder)),
removed: removedFolders.map((folder) => this.asProtocol(folder))
}
};
return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, params);
}
register(data) {
let id = data.id;
let client = this._client;
let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders((event) => {
let didChangeWorkspaceFolders = (event2) => {
return this.doSendEvent(event2.added, event2.removed);
};
let middleware = client.middleware.workspace;
const promise = middleware && middleware.didChangeWorkspaceFolders ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders) : didChangeWorkspaceFolders(event);
promise.catch((error) => {
this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
});
});
this._listeners.set(id, disposable);
this.sendInitialEvent(vscode_1.workspace.workspaceFolders);
}
unregister(id) {
let disposable = this._listeners.get(id);
if (disposable === void 0) {
return;
}
this._listeners.delete(id);
disposable.dispose();
}
clear() {
for (let disposable of this._listeners.values()) {
disposable.dispose();
}
this._listeners.clear();
}
asProtocol(workspaceFolder) {
if (workspaceFolder === void 0) {
return null;
}
return { uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), name: workspaceFolder.name };
}
};
exports2.WorkspaceFoldersFeature = WorkspaceFoldersFeature;
}
});
// node_modules/vscode-languageclient/lib/common/foldingRange.js
var require_foldingRange = __commonJS({
"node_modules/vscode-languageclient/lib/common/foldingRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.FoldingRangeFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var FoldingRangeFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.FoldingRangeRequest.type);
}
fillClientCapabilities(capabilities) {
let capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "foldingRange");
capability.dynamicRegistration = true;
capability.rangeLimit = 5e3;
capability.lineFoldingOnly = true;
capability.foldingRangeKind = { valueSet: [vscode_languageserver_protocol_1.FoldingRangeKind.Comment, vscode_languageserver_protocol_1.FoldingRangeKind.Imports, vscode_languageserver_protocol_1.FoldingRangeKind.Region] };
capability.foldingRange = { collapsedText: false };
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "foldingRange").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
this._client.onRequest(vscode_languageserver_protocol_1.FoldingRangeRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeFoldingRange.fire();
}
});
let [id, options] = this.getRegistration(documentSelector2, capabilities.foldingRangeProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const eventEmitter = new vscode_1.EventEmitter();
const provider = {
onDidChangeFoldingRanges: eventEmitter.event,
provideFoldingRanges: (document, context, token) => {
const client = this._client;
const provideFoldingRanges = (document2, _, token2) => {
const requestParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2)
};
return client.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, requestParams, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asFoldingRanges(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideFoldingRanges ? middleware.provideFoldingRanges(document, context, token, provideFoldingRanges) : provideFoldingRanges(document, context, token);
}
};
return [vscode_1.languages.registerFoldingRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), { provider, onDidChangeFoldingRange: eventEmitter }];
}
};
exports2.FoldingRangeFeature = FoldingRangeFeature;
}
});
// node_modules/vscode-languageclient/lib/common/declaration.js
var require_declaration = __commonJS({
"node_modules/vscode-languageclient/lib/common/declaration.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DeclarationFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var DeclarationFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.DeclarationRequest.type);
}
fillClientCapabilities(capabilities) {
const declarationSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "declaration");
declarationSupport.dynamicRegistration = true;
declarationSupport.linkSupport = true;
}
initialize(capabilities, documentSelector2) {
const [id, options] = this.getRegistration(documentSelector2, capabilities.declarationProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideDeclaration: (document, position, token) => {
const client = this._client;
const provideDeclaration = (document2, position2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asDeclarationResult(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideDeclaration ? middleware.provideDeclaration(document, position, token, provideDeclaration) : provideDeclaration(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerDeclarationProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.DeclarationFeature = DeclarationFeature;
}
});
// node_modules/vscode-languageclient/lib/common/selectionRange.js
var require_selectionRange = __commonJS({
"node_modules/vscode-languageclient/lib/common/selectionRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SelectionRangeFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var SelectionRangeFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.SelectionRangeRequest.type);
}
fillClientCapabilities(capabilities) {
const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "selectionRange");
capability.dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const [id, options] = this.getRegistration(documentSelector2, capabilities.selectionRangeProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideSelectionRanges: (document, positions, token) => {
const client = this._client;
const provideSelectionRanges = async (document2, positions2, token2) => {
const requestParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
positions: client.code2ProtocolConverter.asPositionsSync(positions2, token2)
};
return client.sendRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, requestParams, token2).then((ranges) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asSelectionRanges(ranges, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideSelectionRanges ? middleware.provideSelectionRanges(document, positions, token, provideSelectionRanges) : provideSelectionRanges(document, positions, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerSelectionRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.SelectionRangeFeature = SelectionRangeFeature;
}
});
// node_modules/vscode-languageclient/lib/common/progress.js
var require_progress = __commonJS({
"node_modules/vscode-languageclient/lib/common/progress.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProgressFeature = void 0;
var vscode_languageserver_protocol_1 = require_main3();
var progressPart_1 = require_progressPart();
function ensure(target, key) {
if (target[key] === void 0) {
target[key] = /* @__PURE__ */ Object.create(null);
}
return target[key];
}
var ProgressFeature = class {
constructor(_client) {
this._client = _client;
this.activeParts = /* @__PURE__ */ new Set();
}
getState() {
return { kind: "window", id: vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.method, registrations: this.activeParts.size > 0 };
}
fillClientCapabilities(capabilities) {
ensure(capabilities, "window").workDoneProgress = true;
}
initialize() {
const client = this._client;
const deleteHandler = (part) => {
this.activeParts.delete(part);
};
const createHandler = (params) => {
this.activeParts.add(new progressPart_1.ProgressPart(this._client, params.token, deleteHandler));
};
client.onRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, createHandler);
}
clear() {
for (const part of this.activeParts) {
part.done();
}
this.activeParts.clear();
}
};
exports2.ProgressFeature = ProgressFeature;
}
});
// node_modules/vscode-languageclient/lib/common/callHierarchy.js
var require_callHierarchy = __commonJS({
"node_modules/vscode-languageclient/lib/common/callHierarchy.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.CallHierarchyFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var CallHierarchyProvider = class {
constructor(client) {
this.client = client;
this.middleware = client.middleware;
}
prepareCallHierarchy(document, position, token) {
const client = this.client;
const middleware = this.middleware;
const prepareCallHierarchy = (document2, position2, token2) => {
const params = client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2);
return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCallHierarchyItems(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, token2, error, null);
});
};
return middleware.prepareCallHierarchy ? middleware.prepareCallHierarchy(document, position, token, prepareCallHierarchy) : prepareCallHierarchy(document, position, token);
}
provideCallHierarchyIncomingCalls(item, token) {
const client = this.client;
const middleware = this.middleware;
const provideCallHierarchyIncomingCalls = (item2, token2) => {
const params = {
item: client.code2ProtocolConverter.asCallHierarchyItem(item2)
};
return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCallHierarchyIncomingCalls(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type, token2, error, null);
});
};
return middleware.provideCallHierarchyIncomingCalls ? middleware.provideCallHierarchyIncomingCalls(item, token, provideCallHierarchyIncomingCalls) : provideCallHierarchyIncomingCalls(item, token);
}
provideCallHierarchyOutgoingCalls(item, token) {
const client = this.client;
const middleware = this.middleware;
const provideCallHierarchyOutgoingCalls = (item2, token2) => {
const params = {
item: client.code2ProtocolConverter.asCallHierarchyItem(item2)
};
return client.sendRequest(vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asCallHierarchyOutgoingCalls(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type, token2, error, null);
});
};
return middleware.provideCallHierarchyOutgoingCalls ? middleware.provideCallHierarchyOutgoingCalls(item, token, provideCallHierarchyOutgoingCalls) : provideCallHierarchyOutgoingCalls(item, token);
}
};
var CallHierarchyFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type);
}
fillClientCapabilities(cap) {
const capabilities = cap;
const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "callHierarchy");
capability.dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const [id, options] = this.getRegistration(documentSelector2, capabilities.callHierarchyProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const client = this._client;
const provider = new CallHierarchyProvider(client);
return [vscode_1.languages.registerCallHierarchyProvider(this._client.protocol2CodeConverter.asDocumentSelector(options.documentSelector), provider), provider];
}
};
exports2.CallHierarchyFeature = CallHierarchyFeature;
}
});
// node_modules/vscode-languageclient/lib/common/semanticTokens.js
var require_semanticTokens = __commonJS({
"node_modules/vscode-languageclient/lib/common/semanticTokens.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SemanticTokensFeature = void 0;
var vscode22 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var Is = require_is();
var SemanticTokensFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.SemanticTokensRegistrationType.type);
}
fillClientCapabilities(capabilities) {
const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "semanticTokens");
capability.dynamicRegistration = true;
capability.tokenTypes = [
vscode_languageserver_protocol_1.SemanticTokenTypes.namespace,
vscode_languageserver_protocol_1.SemanticTokenTypes.type,
vscode_languageserver_protocol_1.SemanticTokenTypes.class,
vscode_languageserver_protocol_1.SemanticTokenTypes.enum,
vscode_languageserver_protocol_1.SemanticTokenTypes.interface,
vscode_languageserver_protocol_1.SemanticTokenTypes.struct,
vscode_languageserver_protocol_1.SemanticTokenTypes.typeParameter,
vscode_languageserver_protocol_1.SemanticTokenTypes.parameter,
vscode_languageserver_protocol_1.SemanticTokenTypes.variable,
vscode_languageserver_protocol_1.SemanticTokenTypes.property,
vscode_languageserver_protocol_1.SemanticTokenTypes.enumMember,
vscode_languageserver_protocol_1.SemanticTokenTypes.event,
vscode_languageserver_protocol_1.SemanticTokenTypes.function,
vscode_languageserver_protocol_1.SemanticTokenTypes.method,
vscode_languageserver_protocol_1.SemanticTokenTypes.macro,
vscode_languageserver_protocol_1.SemanticTokenTypes.keyword,
vscode_languageserver_protocol_1.SemanticTokenTypes.modifier,
vscode_languageserver_protocol_1.SemanticTokenTypes.comment,
vscode_languageserver_protocol_1.SemanticTokenTypes.string,
vscode_languageserver_protocol_1.SemanticTokenTypes.number,
vscode_languageserver_protocol_1.SemanticTokenTypes.regexp,
vscode_languageserver_protocol_1.SemanticTokenTypes.operator,
vscode_languageserver_protocol_1.SemanticTokenTypes.decorator
];
capability.tokenModifiers = [
vscode_languageserver_protocol_1.SemanticTokenModifiers.declaration,
vscode_languageserver_protocol_1.SemanticTokenModifiers.definition,
vscode_languageserver_protocol_1.SemanticTokenModifiers.readonly,
vscode_languageserver_protocol_1.SemanticTokenModifiers.static,
vscode_languageserver_protocol_1.SemanticTokenModifiers.deprecated,
vscode_languageserver_protocol_1.SemanticTokenModifiers.abstract,
vscode_languageserver_protocol_1.SemanticTokenModifiers.async,
vscode_languageserver_protocol_1.SemanticTokenModifiers.modification,
vscode_languageserver_protocol_1.SemanticTokenModifiers.documentation,
vscode_languageserver_protocol_1.SemanticTokenModifiers.defaultLibrary
];
capability.formats = [vscode_languageserver_protocol_1.TokenFormat.Relative];
capability.requests = {
range: true,
full: {
delta: true
}
};
capability.multilineTokenSupport = false;
capability.overlappingTokenSupport = false;
capability.serverCancelSupport = true;
capability.augmentsSyntaxTokens = true;
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "semanticTokens").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
const client = this._client;
client.onRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeSemanticTokensEmitter.fire();
}
});
const [id, options] = this.getRegistration(documentSelector2, capabilities.semanticTokensProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const fullProvider = Is.boolean(options.full) ? options.full : options.full !== void 0;
const hasEditProvider = options.full !== void 0 && typeof options.full !== "boolean" && options.full.delta === true;
const eventEmitter = new vscode22.EventEmitter();
const documentProvider = fullProvider ? {
onDidChangeSemanticTokens: eventEmitter.event,
provideDocumentSemanticTokens: (document, token) => {
const client2 = this._client;
const middleware = client2.middleware;
const provideDocumentSemanticTokens = (document2, token2) => {
const params = {
textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier(document2)
};
return client2.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client2.protocol2CodeConverter.asSemanticTokens(result, token2);
}, (error) => {
return client2.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, token2, error, null);
});
};
return middleware.provideDocumentSemanticTokens ? middleware.provideDocumentSemanticTokens(document, token, provideDocumentSemanticTokens) : provideDocumentSemanticTokens(document, token);
},
provideDocumentSemanticTokensEdits: hasEditProvider ? (document, previousResultId, token) => {
const client2 = this._client;
const middleware = client2.middleware;
const provideDocumentSemanticTokensEdits = (document2, previousResultId2, token2) => {
const params = {
textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier(document2),
previousResultId: previousResultId2
};
return client2.sendRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, params, token2).then(async (result) => {
if (token2.isCancellationRequested) {
return null;
}
if (vscode_languageserver_protocol_1.SemanticTokens.is(result)) {
return await client2.protocol2CodeConverter.asSemanticTokens(result, token2);
} else {
return await client2.protocol2CodeConverter.asSemanticTokensEdits(result, token2);
}
}, (error) => {
return client2.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, token2, error, null);
});
};
return middleware.provideDocumentSemanticTokensEdits ? middleware.provideDocumentSemanticTokensEdits(document, previousResultId, token, provideDocumentSemanticTokensEdits) : provideDocumentSemanticTokensEdits(document, previousResultId, token);
} : void 0
} : void 0;
const hasRangeProvider = options.range === true;
const rangeProvider = hasRangeProvider ? {
provideDocumentRangeSemanticTokens: (document, range, token) => {
const client2 = this._client;
const middleware = client2.middleware;
const provideDocumentRangeSemanticTokens = (document2, range2, token2) => {
const params = {
textDocument: client2.code2ProtocolConverter.asTextDocumentIdentifier(document2),
range: client2.code2ProtocolConverter.asRange(range2)
};
return client2.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client2.protocol2CodeConverter.asSemanticTokens(result, token2);
}, (error) => {
return client2.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, token2, error, null);
});
};
return middleware.provideDocumentRangeSemanticTokens ? middleware.provideDocumentRangeSemanticTokens(document, range, token, provideDocumentRangeSemanticTokens) : provideDocumentRangeSemanticTokens(document, range, token);
}
} : void 0;
const disposables = [];
const client = this._client;
const legend = client.protocol2CodeConverter.asSemanticTokensLegend(options.legend);
const documentSelector2 = client.protocol2CodeConverter.asDocumentSelector(selector);
if (documentProvider !== void 0) {
disposables.push(vscode22.languages.registerDocumentSemanticTokensProvider(documentSelector2, documentProvider, legend));
}
if (rangeProvider !== void 0) {
disposables.push(vscode22.languages.registerDocumentRangeSemanticTokensProvider(documentSelector2, rangeProvider, legend));
}
return [new vscode22.Disposable(() => disposables.forEach((item) => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
}
};
exports2.SemanticTokensFeature = SemanticTokensFeature;
}
});
// node_modules/vscode-languageclient/lib/common/fileOperations.js
var require_fileOperations = __commonJS({
"node_modules/vscode-languageclient/lib/common/fileOperations.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.WillDeleteFilesFeature = exports2.WillRenameFilesFeature = exports2.WillCreateFilesFeature = exports2.DidDeleteFilesFeature = exports2.DidRenameFilesFeature = exports2.DidCreateFilesFeature = void 0;
var code = require("vscode");
var minimatch = require_minimatch();
var proto = require_main3();
var UUID = require_uuid();
function ensure(target, key) {
if (target[key] === void 0) {
target[key] = {};
}
return target[key];
}
function access(target, key) {
return target[key];
}
function assign(target, key, value) {
target[key] = value;
}
var FileOperationFeature = class _FileOperationFeature {
constructor(client, event, registrationType, clientCapability, serverCapability) {
this._client = client;
this._event = event;
this._registrationType = registrationType;
this._clientCapability = clientCapability;
this._serverCapability = serverCapability;
this._filters = /* @__PURE__ */ new Map();
}
getState() {
return { kind: "workspace", id: this._registrationType.method, registrations: this._filters.size > 0 };
}
filterSize() {
return this._filters.size;
}
get registrationType() {
return this._registrationType;
}
fillClientCapabilities(capabilities) {
const value = ensure(ensure(capabilities, "workspace"), "fileOperations");
assign(value, "dynamicRegistration", true);
assign(value, this._clientCapability, true);
}
initialize(capabilities) {
const options = capabilities.workspace?.fileOperations;
const capability = options !== void 0 ? access(options, this._serverCapability) : void 0;
if (capability?.filters !== void 0) {
try {
this.register({
id: UUID.generateUuid(),
registerOptions: { filters: capability.filters }
});
} catch (e) {
this._client.warn(`Ignoring invalid glob pattern for ${this._serverCapability} registration: ${e}`);
}
}
}
register(data) {
if (!this._listener) {
this._listener = this._event(this.send, this);
}
const minimatchFilter = data.registerOptions.filters.map((filter) => {
const matcher = new minimatch.Minimatch(filter.pattern.glob, _FileOperationFeature.asMinimatchOptions(filter.pattern.options));
if (!matcher.makeRe()) {
throw new Error(`Invalid pattern ${filter.pattern.glob}!`);
}
return { scheme: filter.scheme, matcher, kind: filter.pattern.matches };
});
this._filters.set(data.id, minimatchFilter);
}
unregister(id) {
this._filters.delete(id);
if (this._filters.size === 0 && this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
clear() {
this._filters.clear();
if (this._listener) {
this._listener.dispose();
this._listener = void 0;
}
}
getFileType(uri) {
return _FileOperationFeature.getFileType(uri);
}
async filter(event, prop) {
const fileMatches = await Promise.all(event.files.map(async (item) => {
const uri = prop(item);
const path11 = uri.fsPath.replace(/\\/g, "/");
for (const filters of this._filters.values()) {
for (const filter of filters) {
if (filter.scheme !== void 0 && filter.scheme !== uri.scheme) {
continue;
}
if (filter.matcher.match(path11)) {
if (filter.kind === void 0) {
return true;
}
const fileType = await this.getFileType(uri);
if (fileType === void 0) {
this._client.error(`Failed to determine file type for ${uri.toString()}.`);
return true;
}
if (fileType === code.FileType.File && filter.kind === proto.FileOperationPatternKind.file || fileType === code.FileType.Directory && filter.kind === proto.FileOperationPatternKind.folder) {
return true;
}
} else if (filter.kind === proto.FileOperationPatternKind.folder) {
const fileType = await _FileOperationFeature.getFileType(uri);
if (fileType === code.FileType.Directory && filter.matcher.match(`${path11}/`)) {
return true;
}
}
}
}
return false;
}));
const files = event.files.filter((_, index) => fileMatches[index]);
return { ...event, files };
}
static async getFileType(uri) {
try {
return (await code.workspace.fs.stat(uri)).type;
} catch (e) {
return void 0;
}
}
static asMinimatchOptions(options) {
const result = { dot: true };
if (options?.ignoreCase === true) {
result.nocase = true;
}
return result;
}
};
var NotificationFileOperationFeature = class extends FileOperationFeature {
constructor(client, event, notificationType, clientCapability, serverCapability, accessUri, createParams) {
super(client, event, notificationType, clientCapability, serverCapability);
this._notificationType = notificationType;
this._accessUri = accessUri;
this._createParams = createParams;
}
async send(originalEvent) {
const filteredEvent = await this.filter(originalEvent, this._accessUri);
if (filteredEvent.files.length) {
const next = async (event) => {
return this._client.sendNotification(this._notificationType, this._createParams(event));
};
return this.doSend(filteredEvent, next);
}
}
};
var CachingNotificationFileOperationFeature = class extends NotificationFileOperationFeature {
constructor() {
super(...arguments);
this._fsPathFileTypes = /* @__PURE__ */ new Map();
}
async getFileType(uri) {
const fsPath = uri.fsPath;
if (this._fsPathFileTypes.has(fsPath)) {
return this._fsPathFileTypes.get(fsPath);
}
const type = await FileOperationFeature.getFileType(uri);
if (type) {
this._fsPathFileTypes.set(fsPath, type);
}
return type;
}
async cacheFileTypes(event, prop) {
await this.filter(event, prop);
}
clearFileTypeCache() {
this._fsPathFileTypes.clear();
}
unregister(id) {
super.unregister(id);
if (this.filterSize() === 0 && this._willListener) {
this._willListener.dispose();
this._willListener = void 0;
}
}
clear() {
super.clear();
if (this._willListener) {
this._willListener.dispose();
this._willListener = void 0;
}
}
};
var DidCreateFilesFeature = class extends NotificationFileOperationFeature {
constructor(client) {
super(client, code.workspace.onDidCreateFiles, proto.DidCreateFilesNotification.type, "didCreate", "didCreate", (i) => i, client.code2ProtocolConverter.asDidCreateFilesParams);
}
doSend(event, next) {
const middleware = this._client.middleware.workspace;
return middleware?.didCreateFiles ? middleware.didCreateFiles(event, next) : next(event);
}
};
exports2.DidCreateFilesFeature = DidCreateFilesFeature;
var DidRenameFilesFeature = class extends CachingNotificationFileOperationFeature {
constructor(client) {
super(client, code.workspace.onDidRenameFiles, proto.DidRenameFilesNotification.type, "didRename", "didRename", (i) => i.oldUri, client.code2ProtocolConverter.asDidRenameFilesParams);
}
register(data) {
if (!this._willListener) {
this._willListener = code.workspace.onWillRenameFiles(this.willRename, this);
}
super.register(data);
}
willRename(e) {
e.waitUntil(this.cacheFileTypes(e, (i) => i.oldUri));
}
doSend(event, next) {
this.clearFileTypeCache();
const middleware = this._client.middleware.workspace;
return middleware?.didRenameFiles ? middleware.didRenameFiles(event, next) : next(event);
}
};
exports2.DidRenameFilesFeature = DidRenameFilesFeature;
var DidDeleteFilesFeature = class extends CachingNotificationFileOperationFeature {
constructor(client) {
super(client, code.workspace.onDidDeleteFiles, proto.DidDeleteFilesNotification.type, "didDelete", "didDelete", (i) => i, client.code2ProtocolConverter.asDidDeleteFilesParams);
}
register(data) {
if (!this._willListener) {
this._willListener = code.workspace.onWillDeleteFiles(this.willDelete, this);
}
super.register(data);
}
willDelete(e) {
e.waitUntil(this.cacheFileTypes(e, (i) => i));
}
doSend(event, next) {
this.clearFileTypeCache();
const middleware = this._client.middleware.workspace;
return middleware?.didDeleteFiles ? middleware.didDeleteFiles(event, next) : next(event);
}
};
exports2.DidDeleteFilesFeature = DidDeleteFilesFeature;
var RequestFileOperationFeature = class extends FileOperationFeature {
constructor(client, event, requestType, clientCapability, serverCapability, accessUri, createParams) {
super(client, event, requestType, clientCapability, serverCapability);
this._requestType = requestType;
this._accessUri = accessUri;
this._createParams = createParams;
}
async send(originalEvent) {
const waitUntil = this.waitUntil(originalEvent);
originalEvent.waitUntil(waitUntil);
}
async waitUntil(originalEvent) {
const filteredEvent = await this.filter(originalEvent, this._accessUri);
if (filteredEvent.files.length) {
const next = (event) => {
return this._client.sendRequest(this._requestType, this._createParams(event), event.token).then(this._client.protocol2CodeConverter.asWorkspaceEdit);
};
return this.doSend(filteredEvent, next);
} else {
return void 0;
}
}
};
var WillCreateFilesFeature = class extends RequestFileOperationFeature {
constructor(client) {
super(client, code.workspace.onWillCreateFiles, proto.WillCreateFilesRequest.type, "willCreate", "willCreate", (i) => i, client.code2ProtocolConverter.asWillCreateFilesParams);
}
doSend(event, next) {
const middleware = this._client.middleware.workspace;
return middleware?.willCreateFiles ? middleware.willCreateFiles(event, next) : next(event);
}
};
exports2.WillCreateFilesFeature = WillCreateFilesFeature;
var WillRenameFilesFeature = class extends RequestFileOperationFeature {
constructor(client) {
super(client, code.workspace.onWillRenameFiles, proto.WillRenameFilesRequest.type, "willRename", "willRename", (i) => i.oldUri, client.code2ProtocolConverter.asWillRenameFilesParams);
}
doSend(event, next) {
const middleware = this._client.middleware.workspace;
return middleware?.willRenameFiles ? middleware.willRenameFiles(event, next) : next(event);
}
};
exports2.WillRenameFilesFeature = WillRenameFilesFeature;
var WillDeleteFilesFeature = class extends RequestFileOperationFeature {
constructor(client) {
super(client, code.workspace.onWillDeleteFiles, proto.WillDeleteFilesRequest.type, "willDelete", "willDelete", (i) => i, client.code2ProtocolConverter.asWillDeleteFilesParams);
}
doSend(event, next) {
const middleware = this._client.middleware.workspace;
return middleware?.willDeleteFiles ? middleware.willDeleteFiles(event, next) : next(event);
}
};
exports2.WillDeleteFilesFeature = WillDeleteFilesFeature;
}
});
// node_modules/vscode-languageclient/lib/common/linkedEditingRange.js
var require_linkedEditingRange = __commonJS({
"node_modules/vscode-languageclient/lib/common/linkedEditingRange.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.LinkedEditingFeature = void 0;
var code = require("vscode");
var proto = require_main3();
var features_1 = require_features();
var LinkedEditingFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, proto.LinkedEditingRangeRequest.type);
}
fillClientCapabilities(capabilities) {
const linkedEditingSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "linkedEditingRange");
linkedEditingSupport.dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
let [id, options] = this.getRegistration(documentSelector2, capabilities.linkedEditingRangeProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideLinkedEditingRanges: (document, position, token) => {
const client = this._client;
const provideLinkedEditing = (document2, position2, token2) => {
return client.sendRequest(proto.LinkedEditingRangeRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asLinkedEditingRanges(result, token2);
}, (error) => {
return client.handleFailedRequest(proto.LinkedEditingRangeRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideLinkedEditingRange ? middleware.provideLinkedEditingRange(document, position, token, provideLinkedEditing) : provideLinkedEditing(document, position, token);
}
};
return [this.registerProvider(selector, provider), provider];
}
registerProvider(selector, provider) {
return code.languages.registerLinkedEditingRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.LinkedEditingFeature = LinkedEditingFeature;
}
});
// node_modules/vscode-languageclient/lib/common/typeHierarchy.js
var require_typeHierarchy = __commonJS({
"node_modules/vscode-languageclient/lib/common/typeHierarchy.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.TypeHierarchyFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var TypeHierarchyProvider = class {
constructor(client) {
this.client = client;
this.middleware = client.middleware;
}
prepareTypeHierarchy(document, position, token) {
const client = this.client;
const middleware = this.middleware;
const prepareTypeHierarchy = (document2, position2, token2) => {
const params = client.code2ProtocolConverter.asTextDocumentPositionParams(document2, position2);
return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTypeHierarchyItems(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, token2, error, null);
});
};
return middleware.prepareTypeHierarchy ? middleware.prepareTypeHierarchy(document, position, token, prepareTypeHierarchy) : prepareTypeHierarchy(document, position, token);
}
provideTypeHierarchySupertypes(item, token) {
const client = this.client;
const middleware = this.middleware;
const provideTypeHierarchySupertypes = (item2, token2) => {
const params = {
item: client.code2ProtocolConverter.asTypeHierarchyItem(item2)
};
return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTypeHierarchyItems(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type, token2, error, null);
});
};
return middleware.provideTypeHierarchySupertypes ? middleware.provideTypeHierarchySupertypes(item, token, provideTypeHierarchySupertypes) : provideTypeHierarchySupertypes(item, token);
}
provideTypeHierarchySubtypes(item, token) {
const client = this.client;
const middleware = this.middleware;
const provideTypeHierarchySubtypes = (item2, token2) => {
const params = {
item: client.code2ProtocolConverter.asTypeHierarchyItem(item2)
};
return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type, params, token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asTypeHierarchyItems(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type, token2, error, null);
});
};
return middleware.provideTypeHierarchySubtypes ? middleware.provideTypeHierarchySubtypes(item, token, provideTypeHierarchySubtypes) : provideTypeHierarchySubtypes(item, token);
}
};
var TypeHierarchyFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type);
}
fillClientCapabilities(capabilities) {
const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "typeHierarchy");
capability.dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const [id, options] = this.getRegistration(documentSelector2, capabilities.typeHierarchyProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const client = this._client;
const provider = new TypeHierarchyProvider(client);
return [vscode_1.languages.registerTypeHierarchyProvider(client.protocol2CodeConverter.asDocumentSelector(options.documentSelector), provider), provider];
}
};
exports2.TypeHierarchyFeature = TypeHierarchyFeature;
}
});
// node_modules/vscode-languageclient/lib/common/inlineValue.js
var require_inlineValue = __commonJS({
"node_modules/vscode-languageclient/lib/common/inlineValue.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlineValueFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var InlineValueFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.InlineValueRequest.type);
}
fillClientCapabilities(capabilities) {
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "inlineValue").dynamicRegistration = true;
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "inlineValue").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
this._client.onRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeInlineValues.fire();
}
});
const [id, options] = this.getRegistration(documentSelector2, capabilities.inlineValueProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const eventEmitter = new vscode_1.EventEmitter();
const provider = {
onDidChangeInlineValues: eventEmitter.event,
provideInlineValues: (document, viewPort, context, token) => {
const client = this._client;
const provideInlineValues = (document2, viewPort2, context2, token2) => {
const requestParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
range: client.code2ProtocolConverter.asRange(viewPort2),
context: client.code2ProtocolConverter.asInlineValueContext(context2)
};
return client.sendRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, requestParams, token2).then((values) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asInlineValues(values, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, token2, error, null);
});
};
const middleware = client.middleware;
return middleware.provideInlineValues ? middleware.provideInlineValues(document, viewPort, context, token, provideInlineValues) : provideInlineValues(document, viewPort, context, token);
}
};
return [this.registerProvider(selector, provider), { provider, onDidChangeInlineValues: eventEmitter }];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerInlineValuesProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.InlineValueFeature = InlineValueFeature;
}
});
// node_modules/vscode-languageclient/lib/common/inlayHint.js
var require_inlayHint = __commonJS({
"node_modules/vscode-languageclient/lib/common/inlayHint.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlayHintsFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var InlayHintsFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.InlayHintRequest.type);
}
fillClientCapabilities(capabilities) {
const inlayHint = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "inlayHint");
inlayHint.dynamicRegistration = true;
inlayHint.resolveSupport = {
properties: ["tooltip", "textEdits", "label.tooltip", "label.location", "label.command"]
};
(0, features_1.ensure)((0, features_1.ensure)(capabilities, "workspace"), "inlayHint").refreshSupport = true;
}
initialize(capabilities, documentSelector2) {
this._client.onRequest(vscode_languageserver_protocol_1.InlayHintRefreshRequest.type, async () => {
for (const provider of this.getAllProviders()) {
provider.onDidChangeInlayHints.fire();
}
});
const [id, options] = this.getRegistration(documentSelector2, capabilities.inlayHintProvider);
if (!id || !options) {
return;
}
this.register({ id, registerOptions: options });
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const eventEmitter = new vscode_1.EventEmitter();
const provider = {
onDidChangeInlayHints: eventEmitter.event,
provideInlayHints: (document, viewPort, token) => {
const client = this._client;
const provideInlayHints = async (document2, viewPort2, token2) => {
const requestParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document2),
range: client.code2ProtocolConverter.asRange(viewPort2)
};
try {
const values = await client.sendRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, requestParams, token2);
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asInlayHints(values, token2);
} catch (error) {
return client.handleFailedRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, token2, error, null);
}
};
const middleware = client.middleware;
return middleware.provideInlayHints ? middleware.provideInlayHints(document, viewPort, token, provideInlayHints) : provideInlayHints(document, viewPort, token);
}
};
provider.resolveInlayHint = options.resolveProvider === true ? (hint, token) => {
const client = this._client;
const resolveInlayHint = async (item, token2) => {
try {
const value = await client.sendRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, client.code2ProtocolConverter.asInlayHint(item), token2);
if (token2.isCancellationRequested) {
return null;
}
const result = client.protocol2CodeConverter.asInlayHint(value, token2);
return token2.isCancellationRequested ? null : result;
} catch (error) {
return client.handleFailedRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, token2, error, null);
}
};
const middleware = client.middleware;
return middleware.resolveInlayHint ? middleware.resolveInlayHint(hint, token, resolveInlayHint) : resolveInlayHint(hint, token);
} : void 0;
return [this.registerProvider(selector, provider), { provider, onDidChangeInlayHints: eventEmitter }];
}
registerProvider(selector, provider) {
return vscode_1.languages.registerInlayHintsProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
}
};
exports2.InlayHintsFeature = InlayHintsFeature;
}
});
// node_modules/vscode-languageclient/lib/common/inlineCompletion.js
var require_inlineCompletion = __commonJS({
"node_modules/vscode-languageclient/lib/common/inlineCompletion.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.InlineCompletionItemFeature = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var features_1 = require_features();
var UUID = require_uuid();
var InlineCompletionItemFeature = class extends features_1.TextDocumentLanguageFeature {
constructor(client) {
super(client, vscode_languageserver_protocol_1.InlineCompletionRequest.type);
}
fillClientCapabilities(capabilities) {
let inlineCompletion = (0, features_1.ensure)((0, features_1.ensure)(capabilities, "textDocument"), "inlineCompletion");
inlineCompletion.dynamicRegistration = true;
}
initialize(capabilities, documentSelector2) {
const options = this.getRegistrationOptions(documentSelector2, capabilities.inlineCompletionProvider);
if (!options) {
return;
}
this.register({
id: UUID.generateUuid(),
registerOptions: options
});
}
registerLanguageProvider(options) {
const selector = options.documentSelector;
const provider = {
provideInlineCompletionItems: (document, position, context, token) => {
const client = this._client;
const middleware = this._client.middleware;
const provideInlineCompletionItems = (document2, position2, context2, token2) => {
return client.sendRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, client.code2ProtocolConverter.asInlineCompletionParams(document2, position2, context2), token2).then((result) => {
if (token2.isCancellationRequested) {
return null;
}
return client.protocol2CodeConverter.asInlineCompletionResult(result, token2);
}, (error) => {
return client.handleFailedRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, token2, error, null);
});
};
return middleware.provideInlineCompletionItems ? middleware.provideInlineCompletionItems(document, position, context, token, provideInlineCompletionItems) : provideInlineCompletionItems(document, position, context, token);
}
};
return [vscode_1.languages.registerInlineCompletionItemProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
}
};
exports2.InlineCompletionItemFeature = InlineCompletionItemFeature;
}
});
// node_modules/vscode-languageclient/lib/common/client.js
var require_client = __commonJS({
"node_modules/vscode-languageclient/lib/common/client.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ProposedFeatures = exports2.BaseLanguageClient = exports2.MessageTransports = exports2.SuspendMode = exports2.State = exports2.CloseAction = exports2.ErrorAction = exports2.RevealOutputChannelOn = void 0;
var vscode_1 = require("vscode");
var vscode_languageserver_protocol_1 = require_main3();
var c2p = require_codeConverter();
var p2c = require_protocolConverter();
var Is = require_is();
var async_1 = require_async();
var UUID = require_uuid();
var progressPart_1 = require_progressPart();
var features_1 = require_features();
var diagnostic_1 = require_diagnostic();
var notebook_1 = require_notebook();
var configuration_1 = require_configuration();
var textSynchronization_1 = require_textSynchronization();
var completion_1 = require_completion();
var hover_1 = require_hover();
var definition_1 = require_definition();
var signatureHelp_1 = require_signatureHelp();
var documentHighlight_1 = require_documentHighlight();
var documentSymbol_1 = require_documentSymbol();
var workspaceSymbol_1 = require_workspaceSymbol();
var reference_1 = require_reference();
var codeAction_1 = require_codeAction();
var codeLens_1 = require_codeLens();
var formatting_1 = require_formatting();
var rename_1 = require_rename();
var documentLink_1 = require_documentLink();
var executeCommand_1 = require_executeCommand();
var fileSystemWatcher_1 = require_fileSystemWatcher();
var colorProvider_1 = require_colorProvider();
var implementation_1 = require_implementation();
var typeDefinition_1 = require_typeDefinition();
var workspaceFolder_1 = require_workspaceFolder();
var foldingRange_1 = require_foldingRange();
var declaration_1 = require_declaration();
var selectionRange_1 = require_selectionRange();
var progress_1 = require_progress();
var callHierarchy_1 = require_callHierarchy();
var semanticTokens_1 = require_semanticTokens();
var fileOperations_1 = require_fileOperations();
var linkedEditingRange_1 = require_linkedEditingRange();
var typeHierarchy_1 = require_typeHierarchy();
var inlineValue_1 = require_inlineValue();
var inlayHint_1 = require_inlayHint();
var inlineCompletion_1 = require_inlineCompletion();
var RevealOutputChannelOn2;
(function(RevealOutputChannelOn3) {
RevealOutputChannelOn3[RevealOutputChannelOn3["Debug"] = 0] = "Debug";
RevealOutputChannelOn3[RevealOutputChannelOn3["Info"] = 1] = "Info";
RevealOutputChannelOn3[RevealOutputChannelOn3["Warn"] = 2] = "Warn";
RevealOutputChannelOn3[RevealOutputChannelOn3["Error"] = 3] = "Error";
RevealOutputChannelOn3[RevealOutputChannelOn3["Never"] = 4] = "Never";
})(RevealOutputChannelOn2 || (exports2.RevealOutputChannelOn = RevealOutputChannelOn2 = {}));
var ErrorAction2;
(function(ErrorAction3) {
ErrorAction3[ErrorAction3["Continue"] = 1] = "Continue";
ErrorAction3[ErrorAction3["Shutdown"] = 2] = "Shutdown";
})(ErrorAction2 || (exports2.ErrorAction = ErrorAction2 = {}));
var CloseAction2;
(function(CloseAction3) {
CloseAction3[CloseAction3["DoNotRestart"] = 1] = "DoNotRestart";
CloseAction3[CloseAction3["Restart"] = 2] = "Restart";
})(CloseAction2 || (exports2.CloseAction = CloseAction2 = {}));
var State;
(function(State2) {
State2[State2["Stopped"] = 1] = "Stopped";
State2[State2["Starting"] = 3] = "Starting";
State2[State2["Running"] = 2] = "Running";
})(State || (exports2.State = State = {}));
var SuspendMode;
(function(SuspendMode2) {
SuspendMode2["off"] = "off";
SuspendMode2["on"] = "on";
})(SuspendMode || (exports2.SuspendMode = SuspendMode = {}));
var ResolvedClientOptions;
(function(ResolvedClientOptions2) {
function sanitizeIsTrusted(isTrusted) {
if (isTrusted === void 0 || isTrusted === null) {
return false;
}
if (typeof isTrusted === "boolean" || typeof isTrusted === "object" && isTrusted !== null && Is.stringArray(isTrusted.enabledCommands)) {
return isTrusted;
}
return false;
}
ResolvedClientOptions2.sanitizeIsTrusted = sanitizeIsTrusted;
})(ResolvedClientOptions || (ResolvedClientOptions = {}));
var DefaultErrorHandler = class {
constructor(client, maxRestartCount) {
this.client = client;
this.maxRestartCount = maxRestartCount;
this.restarts = [];
}
error(_error, _message, count) {
if (count && count <= 3) {
return { action: ErrorAction2.Continue };
}
return { action: ErrorAction2.Shutdown };
}
closed() {
this.restarts.push(Date.now());
if (this.restarts.length <= this.maxRestartCount) {
return { action: CloseAction2.Restart };
} else {
let diff = this.restarts[this.restarts.length - 1] - this.restarts[0];
if (diff <= 3 * 60 * 1e3) {
return { action: CloseAction2.DoNotRestart, message: `The ${this.client.name} server crashed ${this.maxRestartCount + 1} times in the last 3 minutes. The server will not be restarted. See the output for more information.` };
} else {
this.restarts.shift();
return { action: CloseAction2.Restart };
}
}
}
};
var ClientState;
(function(ClientState2) {
ClientState2["Initial"] = "initial";
ClientState2["Starting"] = "starting";
ClientState2["StartFailed"] = "startFailed";
ClientState2["Running"] = "running";
ClientState2["Stopping"] = "stopping";
ClientState2["Stopped"] = "stopped";
})(ClientState || (ClientState = {}));
var MessageTransports;
(function(MessageTransports2) {
function is(value) {
let candidate = value;
return candidate && vscode_languageserver_protocol_1.MessageReader.is(value.reader) && vscode_languageserver_protocol_1.MessageWriter.is(value.writer);
}
MessageTransports2.is = is;
})(MessageTransports || (exports2.MessageTransports = MessageTransports = {}));
var BaseLanguageClient = class _BaseLanguageClient {
constructor(id, name, clientOptions) {
this._traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text;
this._diagnosticQueue = /* @__PURE__ */ new Map();
this._diagnosticQueueState = { state: "idle" };
this._features = [];
this._dynamicFeatures = /* @__PURE__ */ new Map();
this.workspaceEditLock = new async_1.Semaphore(1);
this._id = id;
this._name = name;
clientOptions = clientOptions || {};
const markdown = { isTrusted: false, supportHtml: false };
if (clientOptions.markdown !== void 0) {
markdown.isTrusted = ResolvedClientOptions.sanitizeIsTrusted(clientOptions.markdown.isTrusted);
markdown.supportHtml = clientOptions.markdown.supportHtml === true;
}
this._clientOptions = {
documentSelector: clientOptions.documentSelector ?? [],
synchronize: clientOptions.synchronize ?? {},
diagnosticCollectionName: clientOptions.diagnosticCollectionName,
outputChannelName: clientOptions.outputChannelName ?? this._name,
revealOutputChannelOn: clientOptions.revealOutputChannelOn ?? RevealOutputChannelOn2.Error,
stdioEncoding: clientOptions.stdioEncoding ?? "utf8",
initializationOptions: clientOptions.initializationOptions,
initializationFailedHandler: clientOptions.initializationFailedHandler,
progressOnInitialization: !!clientOptions.progressOnInitialization,
errorHandler: clientOptions.errorHandler ?? this.createDefaultErrorHandler(clientOptions.connectionOptions?.maxRestartCount),
middleware: clientOptions.middleware ?? {},
uriConverters: clientOptions.uriConverters,
workspaceFolder: clientOptions.workspaceFolder,
connectionOptions: clientOptions.connectionOptions,
markdown,
// suspend: {
// mode: clientOptions.suspend?.mode ?? SuspendMode.off,
// callback: clientOptions.suspend?.callback ?? (() => Promise.resolve(true)),
// interval: clientOptions.suspend?.interval ? Math.max(clientOptions.suspend.interval, defaultInterval) : defaultInterval
// },
diagnosticPullOptions: clientOptions.diagnosticPullOptions ?? { onChange: true, onSave: false },
notebookDocumentOptions: clientOptions.notebookDocumentOptions ?? {}
};
this._clientOptions.synchronize = this._clientOptions.synchronize || {};
this._state = ClientState.Initial;
this._ignoredRegistrations = /* @__PURE__ */ new Set();
this._listeners = [];
this._notificationHandlers = /* @__PURE__ */ new Map();
this._pendingNotificationHandlers = /* @__PURE__ */ new Map();
this._notificationDisposables = /* @__PURE__ */ new Map();
this._requestHandlers = /* @__PURE__ */ new Map();
this._pendingRequestHandlers = /* @__PURE__ */ new Map();
this._requestDisposables = /* @__PURE__ */ new Map();
this._progressHandlers = /* @__PURE__ */ new Map();
this._pendingProgressHandlers = /* @__PURE__ */ new Map();
this._progressDisposables = /* @__PURE__ */ new Map();
this._connection = void 0;
this._initializeResult = void 0;
if (clientOptions.outputChannel) {
this._outputChannel = clientOptions.outputChannel;
this._disposeOutputChannel = false;
} else {
this._outputChannel = void 0;
this._disposeOutputChannel = true;
}
this._traceOutputChannel = clientOptions.traceOutputChannel;
this._diagnostics = void 0;
this._pendingOpenNotifications = /* @__PURE__ */ new Set();
this._pendingChangeSemaphore = new async_1.Semaphore(1);
this._pendingChangeDelayer = new async_1.Delayer(250);
this._fileEvents = [];
this._fileEventDelayer = new async_1.Delayer(250);
this._onStop = void 0;
this._telemetryEmitter = new vscode_languageserver_protocol_1.Emitter();
this._stateChangeEmitter = new vscode_languageserver_protocol_1.Emitter();
this._trace = vscode_languageserver_protocol_1.Trace.Off;
this._tracer = {
log: (messageOrDataObject, data) => {
if (Is.string(messageOrDataObject)) {
this.logTrace(messageOrDataObject, data);
} else {
this.logObjectTrace(messageOrDataObject);
}
}
};
this._c2p = c2p.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.code2Protocol : void 0);
this._p2c = p2c.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.protocol2Code : void 0, this._clientOptions.markdown.isTrusted, this._clientOptions.markdown.supportHtml);
this._syncedDocuments = /* @__PURE__ */ new Map();
this.registerBuiltinFeatures();
}
get name() {
return this._name;
}
get middleware() {
return this._clientOptions.middleware ?? /* @__PURE__ */ Object.create(null);
}
get clientOptions() {
return this._clientOptions;
}
get protocol2CodeConverter() {
return this._p2c;
}
get code2ProtocolConverter() {
return this._c2p;
}
get onTelemetry() {
return this._telemetryEmitter.event;
}
get onDidChangeState() {
return this._stateChangeEmitter.event;
}
get outputChannel() {
if (!this._outputChannel) {
this._outputChannel = vscode_1.window.createOutputChannel(this._clientOptions.outputChannelName ? this._clientOptions.outputChannelName : this._name);
}
return this._outputChannel;
}
get traceOutputChannel() {
if (this._traceOutputChannel) {
return this._traceOutputChannel;
}
return this.outputChannel;
}
get diagnostics() {
return this._diagnostics;
}
get state() {
return this.getPublicState();
}
get $state() {
return this._state;
}
set $state(value) {
let oldState = this.getPublicState();
this._state = value;
let newState = this.getPublicState();
if (newState !== oldState) {
this._stateChangeEmitter.fire({ oldState, newState });
}
}
getPublicState() {
switch (this.$state) {
case ClientState.Starting:
return State.Starting;
case ClientState.Running:
return State.Running;
default:
return State.Stopped;
}
}
get initializeResult() {
return this._initializeResult;
}
async sendRequest(type, ...params) {
if (this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped) {
return Promise.reject(new vscode_languageserver_protocol_1.ResponseError(vscode_languageserver_protocol_1.ErrorCodes.ConnectionInactive, `Client is not running`));
}
const connection = await this.$start();
if (this._didChangeTextDocumentFeature.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
await this.sendPendingFullTextDocumentChanges(connection);
}
const _sendRequest = this._clientOptions.middleware?.sendRequest;
if (_sendRequest !== void 0) {
let param = void 0;
let token = void 0;
if (params.length === 1) {
if (vscode_languageserver_protocol_1.CancellationToken.is(params[0])) {
token = params[0];
} else {
param = params[0];
}
} else if (params.length === 2) {
param = params[0];
token = params[1];
}
return _sendRequest(type, param, token, (type2, param2, token2) => {
const params2 = [];
if (param2 !== void 0) {
params2.push(param2);
}
if (token2 !== void 0) {
params2.push(token2);
}
return connection.sendRequest(type2, ...params2);
});
} else {
return connection.sendRequest(type, ...params);
}
}
onRequest(type, handler) {
const method = typeof type === "string" ? type : type.method;
this._requestHandlers.set(method, handler);
const connection = this.activeConnection();
let disposable;
if (connection !== void 0) {
this._requestDisposables.set(method, connection.onRequest(type, handler));
disposable = {
dispose: () => {
const disposable2 = this._requestDisposables.get(method);
if (disposable2 !== void 0) {
disposable2.dispose();
this._requestDisposables.delete(method);
}
}
};
} else {
this._pendingRequestHandlers.set(method, handler);
disposable = {
dispose: () => {
this._pendingRequestHandlers.delete(method);
const disposable2 = this._requestDisposables.get(method);
if (disposable2 !== void 0) {
disposable2.dispose();
this._requestDisposables.delete(method);
}
}
};
}
return {
dispose: () => {
this._requestHandlers.delete(method);
disposable.dispose();
}
};
}
async sendNotification(type, params) {
if (this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped) {
return Promise.reject(new vscode_languageserver_protocol_1.ResponseError(vscode_languageserver_protocol_1.ErrorCodes.ConnectionInactive, `Client is not running`));
}
const needsPendingFullTextDocumentSync = this._didChangeTextDocumentFeature.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full;
let openNotification;
if (needsPendingFullTextDocumentSync && typeof type !== "string" && type.method === vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.method) {
openNotification = params?.textDocument.uri;
this._pendingOpenNotifications.add(openNotification);
}
const connection = await this.$start();
if (needsPendingFullTextDocumentSync) {
await this.sendPendingFullTextDocumentChanges(connection);
}
if (openNotification !== void 0) {
this._pendingOpenNotifications.delete(openNotification);
}
const _sendNotification = this._clientOptions.middleware?.sendNotification;
return _sendNotification ? _sendNotification(type, connection.sendNotification.bind(connection), params) : connection.sendNotification(type, params);
}
onNotification(type, handler) {
const method = typeof type === "string" ? type : type.method;
this._notificationHandlers.set(method, handler);
const connection = this.activeConnection();
let disposable;
if (connection !== void 0) {
this._notificationDisposables.set(method, connection.onNotification(type, handler));
disposable = {
dispose: () => {
const disposable2 = this._notificationDisposables.get(method);
if (disposable2 !== void 0) {
disposable2.dispose();
this._notificationDisposables.delete(method);
}
}
};
} else {
this._pendingNotificationHandlers.set(method, handler);
disposable = {
dispose: () => {
this._pendingNotificationHandlers.delete(method);
const disposable2 = this._notificationDisposables.get(method);
if (disposable2 !== void 0) {
disposable2.dispose();
this._notificationDisposables.delete(method);
}
}
};
}
return {
dispose: () => {
this._notificationHandlers.delete(method);
disposable.dispose();
}
};
}
async sendProgress(type, token, value) {
if (this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped) {
return Promise.reject(new vscode_languageserver_protocol_1.ResponseError(vscode_languageserver_protocol_1.ErrorCodes.ConnectionInactive, `Client is not running`));
}
try {
const connection = await this.$start();
return connection.sendProgress(type, token, value);
} catch (error) {
this.error(`Sending progress for token ${token} failed.`, error);
throw error;
}
}
onProgress(type, token, handler) {
this._progressHandlers.set(token, { type, handler });
const connection = this.activeConnection();
let disposable;
const handleWorkDoneProgress = this._clientOptions.middleware?.handleWorkDoneProgress;
const realHandler = vscode_languageserver_protocol_1.WorkDoneProgress.is(type) && handleWorkDoneProgress !== void 0 ? (params) => {
handleWorkDoneProgress(token, params, () => handler(params));
} : handler;
if (connection !== void 0) {
this._progressDisposables.set(token, connection.onProgress(type, token, realHandler));
disposable = {
dispose: () => {
const disposable2 = this._progressDisposables.get(token);
if (disposable2 !== void 0) {
disposable2.dispose();
this._progressDisposables.delete(token);
}
}
};
} else {
this._pendingProgressHandlers.set(token, { type, handler });
disposable = {
dispose: () => {
this._pendingProgressHandlers.delete(token);
const disposable2 = this._progressDisposables.get(token);
if (disposable2 !== void 0) {
disposable2.dispose();
this._progressDisposables.delete(token);
}
}
};
}
return {
dispose: () => {
this._progressHandlers.delete(token);
disposable.dispose();
}
};
}
createDefaultErrorHandler(maxRestartCount) {
if (maxRestartCount !== void 0 && maxRestartCount < 0) {
throw new Error(`Invalid maxRestartCount: ${maxRestartCount}`);
}
return new DefaultErrorHandler(this, maxRestartCount ?? 4);
}
async setTrace(value) {
this._trace = value;
const connection = this.activeConnection();
if (connection !== void 0) {
await connection.trace(this._trace, this._tracer, {
sendNotification: false,
traceFormat: this._traceFormat
});
}
}
data2String(data) {
if (data instanceof vscode_languageserver_protocol_1.ResponseError) {
const responseError = data;
return ` Message: ${responseError.message}
Code: ${responseError.code} ${responseError.data ? "\n" + responseError.data.toString() : ""}`;
}
if (data instanceof Error) {
if (Is.string(data.stack)) {
return data.stack;
}
return data.message;
}
if (Is.string(data)) {
return data;
}
return data.toString();
}
debug(message, data, showNotification = true) {
this.logOutputMessage(vscode_languageserver_protocol_1.MessageType.Debug, RevealOutputChannelOn2.Debug, "Debug", message, data, showNotification);
}
info(message, data, showNotification = true) {
this.logOutputMessage(vscode_languageserver_protocol_1.MessageType.Info, RevealOutputChannelOn2.Info, "Info", message, data, showNotification);
}
warn(message, data, showNotification = true) {
this.logOutputMessage(vscode_languageserver_protocol_1.MessageType.Warning, RevealOutputChannelOn2.Warn, "Warn", message, data, showNotification);
}
error(message, data, showNotification = true) {
this.logOutputMessage(vscode_languageserver_protocol_1.MessageType.Error, RevealOutputChannelOn2.Error, "Error", message, data, showNotification);
}
logOutputMessage(type, reveal, name, message, data, showNotification) {
this.outputChannel.appendLine(`[${name.padEnd(5)} - ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${message}`);
if (data !== null && data !== void 0) {
this.outputChannel.appendLine(this.data2String(data));
}
if (showNotification === "force" || showNotification && this._clientOptions.revealOutputChannelOn <= reveal) {
this.showNotificationMessage(type, message);
}
}
showNotificationMessage(type, message) {
message = message ?? "A request has failed. See the output for more information.";
const messageFunc = type === vscode_languageserver_protocol_1.MessageType.Error ? vscode_1.window.showErrorMessage : type === vscode_languageserver_protocol_1.MessageType.Warning ? vscode_1.window.showWarningMessage : vscode_1.window.showInformationMessage;
void messageFunc(message, "Go to output").then((selection) => {
if (selection !== void 0) {
this.outputChannel.show(true);
}
});
}
logTrace(message, data) {
this.traceOutputChannel.appendLine(`[Trace - ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${message}`);
if (data) {
this.traceOutputChannel.appendLine(this.data2String(data));
}
}
logObjectTrace(data) {
if (data.isLSPMessage && data.type) {
this.traceOutputChannel.append(`[LSP - ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `);
} else {
this.traceOutputChannel.append(`[Trace - ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `);
}
if (data) {
this.traceOutputChannel.appendLine(`${JSON.stringify(data)}`);
}
}
needsStart() {
return this.$state === ClientState.Initial || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped;
}
needsStop() {
return this.$state === ClientState.Starting || this.$state === ClientState.Running;
}
activeConnection() {
return this.$state === ClientState.Running && this._connection !== void 0 ? this._connection : void 0;
}
isRunning() {
return this.$state === ClientState.Running;
}
async start() {
if (this._disposed === "disposing" || this._disposed === "disposed") {
throw new Error(`Client got disposed and can't be restarted.`);
}
if (this.$state === ClientState.Stopping) {
throw new Error(`Client is currently stopping. Can only restart a full stopped client`);
}
if (this._onStart !== void 0) {
return this._onStart;
}
const [promise, resolve3, reject] = this.createOnStartPromise();
this._onStart = promise;
if (this._diagnostics === void 0) {
this._diagnostics = this._clientOptions.diagnosticCollectionName ? vscode_1.languages.createDiagnosticCollection(this._clientOptions.diagnosticCollectionName) : vscode_1.languages.createDiagnosticCollection();
}
for (const [method, handler] of this._notificationHandlers) {
if (!this._pendingNotificationHandlers.has(method)) {
this._pendingNotificationHandlers.set(method, handler);
}
}
for (const [method, handler] of this._requestHandlers) {
if (!this._pendingRequestHandlers.has(method)) {
this._pendingRequestHandlers.set(method, handler);
}
}
for (const [token, data] of this._progressHandlers) {
if (!this._pendingProgressHandlers.has(token)) {
this._pendingProgressHandlers.set(token, data);
}
}
this.$state = ClientState.Starting;
try {
const connection = await this.createConnection();
connection.onNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, (message) => {
switch (message.type) {
case vscode_languageserver_protocol_1.MessageType.Error:
this.error(message.message, void 0, false);
break;
case vscode_languageserver_protocol_1.MessageType.Warning:
this.warn(message.message, void 0, false);
break;
case vscode_languageserver_protocol_1.MessageType.Info:
this.info(message.message, void 0, false);
break;
case vscode_languageserver_protocol_1.MessageType.Debug:
this.debug(message.message, void 0, false);
break;
default:
this.outputChannel.appendLine(message.message);
}
});
connection.onNotification(vscode_languageserver_protocol_1.ShowMessageNotification.type, (message) => {
switch (message.type) {
case vscode_languageserver_protocol_1.MessageType.Error:
void vscode_1.window.showErrorMessage(message.message);
break;
case vscode_languageserver_protocol_1.MessageType.Warning:
void vscode_1.window.showWarningMessage(message.message);
break;
case vscode_languageserver_protocol_1.MessageType.Info:
void vscode_1.window.showInformationMessage(message.message);
break;
default:
void vscode_1.window.showInformationMessage(message.message);
}
});
connection.onRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, (params) => {
let messageFunc;
switch (params.type) {
case vscode_languageserver_protocol_1.MessageType.Error:
messageFunc = vscode_1.window.showErrorMessage;
break;
case vscode_languageserver_protocol_1.MessageType.Warning:
messageFunc = vscode_1.window.showWarningMessage;
break;
case vscode_languageserver_protocol_1.MessageType.Info:
messageFunc = vscode_1.window.showInformationMessage;
break;
default:
messageFunc = vscode_1.window.showInformationMessage;
}
let actions = params.actions || [];
return messageFunc(params.message, ...actions);
});
connection.onNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, (data) => {
this._telemetryEmitter.fire(data);
});
connection.onRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, async (params) => {
const showDocument = async (params2) => {
const uri = this.protocol2CodeConverter.asUri(params2.uri);
try {
if (params2.external === true) {
const success = await vscode_1.env.openExternal(uri);
return { success };
} else {
const options = {};
if (params2.selection !== void 0) {
options.selection = this.protocol2CodeConverter.asRange(params2.selection);
}
if (params2.takeFocus === void 0 || params2.takeFocus === false) {
options.preserveFocus = true;
} else if (params2.takeFocus === true) {
options.preserveFocus = false;
}
await vscode_1.window.showTextDocument(uri, options);
return { success: true };
}
} catch (error) {
return { success: false };
}
};
const middleware = this._clientOptions.middleware.window?.showDocument;
if (middleware !== void 0) {
return middleware(params, showDocument);
} else {
return showDocument(params);
}
});
connection.listen();
await this.initialize(connection);
resolve3();
} catch (error) {
this.$state = ClientState.StartFailed;
this.error(`${this._name} client: couldn't create connection to server.`, error, "force");
reject(error);
}
return this._onStart;
}
createOnStartPromise() {
let resolve3;
let reject;
const promise = new Promise((_resolve, _reject) => {
resolve3 = _resolve;
reject = _reject;
});
return [promise, resolve3, reject];
}
async initialize(connection) {
this.refreshTrace(connection, false);
const initOption = this._clientOptions.initializationOptions;
const [rootPath, workspaceFolders] = this._clientOptions.workspaceFolder !== void 0 ? [this._clientOptions.workspaceFolder.uri.fsPath, [{ uri: this._c2p.asUri(this._clientOptions.workspaceFolder.uri), name: this._clientOptions.workspaceFolder.name }]] : [this._clientGetRootPath(), null];
const initParams = {
processId: null,
clientInfo: {
name: vscode_1.env.appName,
version: vscode_1.version
},
locale: this.getLocale(),
rootPath: rootPath ? rootPath : null,
rootUri: rootPath ? this._c2p.asUri(vscode_1.Uri.file(rootPath)) : null,
capabilities: this.computeClientCapabilities(),
initializationOptions: Is.func(initOption) ? initOption() : initOption,
trace: vscode_languageserver_protocol_1.Trace.toString(this._trace),
workspaceFolders
};
this.fillInitializeParams(initParams);
if (this._clientOptions.progressOnInitialization) {
const token = UUID.generateUuid();
const part = new progressPart_1.ProgressPart(connection, token);
initParams.workDoneToken = token;
try {
const result = await this.doInitialize(connection, initParams);
part.done();
return result;
} catch (error) {
part.cancel();
throw error;
}
} else {
return this.doInitialize(connection, initParams);
}
}
async doInitialize(connection, initParams) {
try {
const result = await connection.initialize(initParams);
if (result.capabilities.positionEncoding !== void 0 && result.capabilities.positionEncoding !== vscode_languageserver_protocol_1.PositionEncodingKind.UTF16) {
throw new Error(`Unsupported position encoding (${result.capabilities.positionEncoding}) received from server ${this.name}`);
}
this._initializeResult = result;
this.$state = ClientState.Running;
let textDocumentSyncOptions = void 0;
if (Is.number(result.capabilities.textDocumentSync)) {
if (result.capabilities.textDocumentSync === vscode_languageserver_protocol_1.TextDocumentSyncKind.None) {
textDocumentSyncOptions = {
openClose: false,
change: vscode_languageserver_protocol_1.TextDocumentSyncKind.None,
save: void 0
};
} else {
textDocumentSyncOptions = {
openClose: true,
change: result.capabilities.textDocumentSync,
save: {
includeText: false
}
};
}
} else if (result.capabilities.textDocumentSync !== void 0 && result.capabilities.textDocumentSync !== null) {
textDocumentSyncOptions = result.capabilities.textDocumentSync;
}
this._capabilities = Object.assign({}, result.capabilities, { resolvedTextDocumentSync: textDocumentSyncOptions });
connection.onNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, (params) => this.handleDiagnostics(params));
connection.onRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, (params) => this.handleRegistrationRequest(params));
connection.onRequest("client/registerFeature", (params) => this.handleRegistrationRequest(params));
connection.onRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, (params) => this.handleUnregistrationRequest(params));
connection.onRequest("client/unregisterFeature", (params) => this.handleUnregistrationRequest(params));
connection.onRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, (params) => this.handleApplyWorkspaceEdit(params));
for (const [method, handler] of this._pendingNotificationHandlers) {
this._notificationDisposables.set(method, connection.onNotification(method, handler));
}
this._pendingNotificationHandlers.clear();
for (const [method, handler] of this._pendingRequestHandlers) {
this._requestDisposables.set(method, connection.onRequest(method, handler));
}
this._pendingRequestHandlers.clear();
for (const [token, data] of this._pendingProgressHandlers) {
this._progressDisposables.set(token, connection.onProgress(data.type, token, data.handler));
}
this._pendingProgressHandlers.clear();
await connection.sendNotification(vscode_languageserver_protocol_1.InitializedNotification.type, {});
this.hookFileEvents(connection);
this.hookConfigurationChanged(connection);
this.initializeFeatures(connection);
return result;
} catch (error) {
if (this._clientOptions.initializationFailedHandler) {
if (this._clientOptions.initializationFailedHandler(error)) {
void this.initialize(connection);
} else {
void this.stop();
}
} else if (error instanceof vscode_languageserver_protocol_1.ResponseError && error.data && error.data.retry) {
void vscode_1.window.showErrorMessage(error.message, { title: "Retry", id: "retry" }).then((item) => {
if (item && item.id === "retry") {
void this.initialize(connection);
} else {
void this.stop();
}
});
} else {
if (error && error.message) {
void vscode_1.window.showErrorMessage(error.message);
}
this.error("Server initialization failed.", error);
void this.stop();
}
throw error;
}
}
_clientGetRootPath() {
let folders = vscode_1.workspace.workspaceFolders;
if (!folders || folders.length === 0) {
return void 0;
}
let folder = folders[0];
if (folder.uri.scheme === "file") {
return folder.uri.fsPath;
}
return void 0;
}
stop(timeout = 2e3) {
return this.shutdown("stop", timeout);
}
dispose(timeout = 2e3) {
try {
this._disposed = "disposing";
return this.stop(timeout);
} finally {
this._disposed = "disposed";
}
}
async shutdown(mode, timeout) {
if (this.$state === ClientState.Stopped || this.$state === ClientState.Initial) {
return;
}
if (this.$state === ClientState.Stopping) {
if (this._onStop !== void 0) {
return this._onStop;
} else {
throw new Error(`Client is stopping but no stop promise available.`);
}
}
const connection = this.activeConnection();
if (connection === void 0 || this.$state !== ClientState.Running) {
throw new Error(`Client is not running and can't be stopped. It's current state is: ${this.$state}`);
}
this._initializeResult = void 0;
this.$state = ClientState.Stopping;
this.cleanUp(mode);
const tp = new Promise((c) => {
(0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(c, timeout);
});
const shutdown = (async (connection2) => {
await connection2.shutdown();
await connection2.exit();
return connection2;
})(connection);
return this._onStop = Promise.race([tp, shutdown]).then((connection2) => {
if (connection2 !== void 0) {
connection2.end();
connection2.dispose();
} else {
this.error(`Stopping server timed out`, void 0, false);
throw new Error(`Stopping the server timed out`);
}
}, (error) => {
this.error(`Stopping server failed`, error, false);
throw error;
}).finally(() => {
this.$state = ClientState.Stopped;
mode === "stop" && this.cleanUpChannel();
this._onStart = void 0;
this._onStop = void 0;
this._connection = void 0;
this._ignoredRegistrations.clear();
});
}
cleanUp(mode) {
this._fileEvents = [];
this._fileEventDelayer.cancel();
const disposables = this._listeners.splice(0, this._listeners.length);
for (const disposable of disposables) {
disposable.dispose();
}
if (this._syncedDocuments) {
this._syncedDocuments.clear();
}
for (const feature of Array.from(this._features.entries()).map((entry) => entry[1]).reverse()) {
feature.clear();
}
if (mode === "stop" && this._diagnostics !== void 0) {
this._diagnostics.dispose();
this._diagnostics = void 0;
}
if (this._idleInterval !== void 0) {
this._idleInterval.dispose();
this._idleInterval = void 0;
}
}
cleanUpChannel() {
if (this._outputChannel !== void 0 && this._disposeOutputChannel) {
this._outputChannel.dispose();
this._outputChannel = void 0;
}
}
notifyFileEvent(event) {
const client = this;
async function didChangeWatchedFile(event2) {
client._fileEvents.push(event2);
return client._fileEventDelayer.trigger(async () => {
await client.sendNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, { changes: client._fileEvents });
client._fileEvents = [];
});
}
const workSpaceMiddleware = this.clientOptions.middleware?.workspace;
(workSpaceMiddleware?.didChangeWatchedFile ? workSpaceMiddleware.didChangeWatchedFile(event, didChangeWatchedFile) : didChangeWatchedFile(event)).catch((error) => {
client.error(`Notify file events failed.`, error);
});
}
async sendPendingFullTextDocumentChanges(connection) {
return this._pendingChangeSemaphore.lock(async () => {
try {
const changes = this._didChangeTextDocumentFeature.getPendingDocumentChanges(this._pendingOpenNotifications);
if (changes.length === 0) {
return;
}
for (const document of changes) {
const params = this.code2ProtocolConverter.asChangeTextDocumentParams(document);
await connection.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
this._didChangeTextDocumentFeature.notificationSent(document, vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
}
} catch (error) {
this.error(`Sending pending changes failed`, error, false);
throw error;
}
});
}
triggerPendingChangeDelivery() {
this._pendingChangeDelayer.trigger(async () => {
const connection = this.activeConnection();
if (connection === void 0) {
this.triggerPendingChangeDelivery();
return;
}
await this.sendPendingFullTextDocumentChanges(connection);
}).catch((error) => this.error(`Delivering pending changes failed`, error, false));
}
handleDiagnostics(params) {
if (!this._diagnostics) {
return;
}
const key = params.uri;
if (this._diagnosticQueueState.state === "busy" && this._diagnosticQueueState.document === key) {
this._diagnosticQueueState.tokenSource.cancel();
}
this._diagnosticQueue.set(params.uri, params.diagnostics);
this.triggerDiagnosticQueue();
}
triggerDiagnosticQueue() {
(0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
this.workDiagnosticQueue();
});
}
workDiagnosticQueue() {
if (this._diagnosticQueueState.state === "busy") {
return;
}
const next = this._diagnosticQueue.entries().next();
if (next.done === true) {
return;
}
const [document, diagnostics] = next.value;
this._diagnosticQueue.delete(document);
const tokenSource = new vscode_1.CancellationTokenSource();
this._diagnosticQueueState = { state: "busy", document, tokenSource };
this._p2c.asDiagnostics(diagnostics, tokenSource.token).then((converted) => {
if (!tokenSource.token.isCancellationRequested) {
const uri = this._p2c.asUri(document);
const middleware = this.clientOptions.middleware;
if (middleware.handleDiagnostics) {
middleware.handleDiagnostics(uri, converted, (uri2, diagnostics2) => this.setDiagnostics(uri2, diagnostics2));
} else {
this.setDiagnostics(uri, converted);
}
}
}).finally(() => {
this._diagnosticQueueState = { state: "idle" };
this.triggerDiagnosticQueue();
});
}
setDiagnostics(uri, diagnostics) {
if (!this._diagnostics) {
return;
}
this._diagnostics.set(uri, diagnostics);
}
getLocale() {
return vscode_1.env.language;
}
async $start() {
if (this.$state === ClientState.StartFailed) {
throw new Error(`Previous start failed. Can't restart server.`);
}
await this.start();
const connection = this.activeConnection();
if (connection === void 0) {
throw new Error(`Starting server failed`);
}
return connection;
}
async createConnection() {
let errorHandler = (error, message, count) => {
this.handleConnectionError(error, message, count).catch((error2) => this.error(`Handling connection error failed`, error2));
};
let closeHandler = () => {
this.handleConnectionClosed().catch((error) => this.error(`Handling connection close failed`, error));
};
const transports = await this.createMessageTransports(this._clientOptions.stdioEncoding || "utf8");
this._connection = createConnection(transports.reader, transports.writer, errorHandler, closeHandler, this._clientOptions.connectionOptions);
return this._connection;
}
async handleConnectionClosed() {
if (this.$state === ClientState.Stopped) {
return;
}
try {
if (this._connection !== void 0) {
this._connection.dispose();
}
} catch (error) {
}
let handlerResult = { action: CloseAction2.DoNotRestart };
if (this.$state !== ClientState.Stopping) {
try {
handlerResult = await this._clientOptions.errorHandler.closed();
} catch (error) {
}
}
this._connection = void 0;
if (handlerResult.action === CloseAction2.DoNotRestart) {
this.error(handlerResult.message ?? "Connection to server got closed. Server will not be restarted.", void 0, handlerResult.handled === true ? false : "force");
this.cleanUp("stop");
if (this.$state === ClientState.Starting) {
this.$state = ClientState.StartFailed;
} else {
this.$state = ClientState.Stopped;
}
this._onStop = Promise.resolve();
this._onStart = void 0;
} else if (handlerResult.action === CloseAction2.Restart) {
this.info(handlerResult.message ?? "Connection to server got closed. Server will restart.", !handlerResult.handled);
this.cleanUp("restart");
this.$state = ClientState.Initial;
this._onStop = Promise.resolve();
this._onStart = void 0;
this.start().catch((error) => this.error(`Restarting server failed`, error, "force"));
}
}
async handleConnectionError(error, message, count) {
const handlerResult = await this._clientOptions.errorHandler.error(error, message, count);
if (handlerResult.action === ErrorAction2.Shutdown) {
this.error(handlerResult.message ?? `Client ${this._name}: connection to server is erroring.
${error.message}
Shutting down server.`, void 0, handlerResult.handled === true ? false : "force");
this.stop().catch((error2) => {
this.error(`Stopping server failed`, error2, false);
});
} else {
this.error(handlerResult.message ?? `Client ${this._name}: connection to server is erroring.
${error.message}`, void 0, handlerResult.handled === true ? false : "force");
}
}
hookConfigurationChanged(connection) {
this._listeners.push(vscode_1.workspace.onDidChangeConfiguration(() => {
this.refreshTrace(connection, true);
}));
}
refreshTrace(connection, sendNotification = false) {
const config = vscode_1.workspace.getConfiguration(this._id);
let trace = vscode_languageserver_protocol_1.Trace.Off;
let traceFormat = vscode_languageserver_protocol_1.TraceFormat.Text;
if (config) {
const traceConfig = config.get("trace.server", "off");
if (typeof traceConfig === "string") {
trace = vscode_languageserver_protocol_1.Trace.fromString(traceConfig);
} else {
trace = vscode_languageserver_protocol_1.Trace.fromString(config.get("trace.server.verbosity", "off"));
traceFormat = vscode_languageserver_protocol_1.TraceFormat.fromString(config.get("trace.server.format", "text"));
}
}
this._trace = trace;
this._traceFormat = traceFormat;
connection.trace(this._trace, this._tracer, {
sendNotification,
traceFormat: this._traceFormat
}).catch((error) => {
this.error(`Updating trace failed with error`, error, false);
});
}
hookFileEvents(_connection) {
let fileEvents = this._clientOptions.synchronize.fileEvents;
if (!fileEvents) {
return;
}
let watchers;
if (Is.array(fileEvents)) {
watchers = fileEvents;
} else {
watchers = [fileEvents];
}
if (!watchers) {
return;
}
this._dynamicFeatures.get(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type.method).registerRaw(UUID.generateUuid(), watchers);
}
registerFeatures(features) {
for (let feature of features) {
this.registerFeature(feature);
}
}
registerFeature(feature) {
this._features.push(feature);
if (features_1.DynamicFeature.is(feature)) {
const registrationType = feature.registrationType;
this._dynamicFeatures.set(registrationType.method, feature);
}
}
getFeature(request) {
return this._dynamicFeatures.get(request);
}
hasDedicatedTextSynchronizationFeature(textDocument) {
const feature = this.getFeature(vscode_languageserver_protocol_1.NotebookDocumentSyncRegistrationType.method);
if (feature === void 0 || !(feature instanceof notebook_1.NotebookDocumentSyncFeature)) {
return false;
}
return feature.handles(textDocument);
}
registerBuiltinFeatures() {
const pendingFullTextDocumentChanges = /* @__PURE__ */ new Map();
this.registerFeature(new configuration_1.ConfigurationFeature(this));
this.registerFeature(new textSynchronization_1.DidOpenTextDocumentFeature(this, this._syncedDocuments));
this._didChangeTextDocumentFeature = new textSynchronization_1.DidChangeTextDocumentFeature(this, pendingFullTextDocumentChanges);
this._didChangeTextDocumentFeature.onPendingChangeAdded(() => {
this.triggerPendingChangeDelivery();
});
this.registerFeature(this._didChangeTextDocumentFeature);
this.registerFeature(new textSynchronization_1.WillSaveFeature(this));
this.registerFeature(new textSynchronization_1.WillSaveWaitUntilFeature(this));
this.registerFeature(new textSynchronization_1.DidSaveTextDocumentFeature(this));
this.registerFeature(new textSynchronization_1.DidCloseTextDocumentFeature(this, this._syncedDocuments, pendingFullTextDocumentChanges));
this.registerFeature(new fileSystemWatcher_1.FileSystemWatcherFeature(this, (event) => this.notifyFileEvent(event)));
this.registerFeature(new completion_1.CompletionItemFeature(this));
this.registerFeature(new hover_1.HoverFeature(this));
this.registerFeature(new signatureHelp_1.SignatureHelpFeature(this));
this.registerFeature(new definition_1.DefinitionFeature(this));
this.registerFeature(new reference_1.ReferencesFeature(this));
this.registerFeature(new documentHighlight_1.DocumentHighlightFeature(this));
this.registerFeature(new documentSymbol_1.DocumentSymbolFeature(this));
this.registerFeature(new workspaceSymbol_1.WorkspaceSymbolFeature(this));
this.registerFeature(new codeAction_1.CodeActionFeature(this));
this.registerFeature(new codeLens_1.CodeLensFeature(this));
this.registerFeature(new formatting_1.DocumentFormattingFeature(this));
this.registerFeature(new formatting_1.DocumentRangeFormattingFeature(this));
this.registerFeature(new formatting_1.DocumentOnTypeFormattingFeature(this));
this.registerFeature(new rename_1.RenameFeature(this));
this.registerFeature(new documentLink_1.DocumentLinkFeature(this));
this.registerFeature(new executeCommand_1.ExecuteCommandFeature(this));
this.registerFeature(new configuration_1.SyncConfigurationFeature(this));
this.registerFeature(new typeDefinition_1.TypeDefinitionFeature(this));
this.registerFeature(new implementation_1.ImplementationFeature(this));
this.registerFeature(new colorProvider_1.ColorProviderFeature(this));
if (this.clientOptions.workspaceFolder === void 0) {
this.registerFeature(new workspaceFolder_1.WorkspaceFoldersFeature(this));
}
this.registerFeature(new foldingRange_1.FoldingRangeFeature(this));
this.registerFeature(new declaration_1.DeclarationFeature(this));
this.registerFeature(new selectionRange_1.SelectionRangeFeature(this));
this.registerFeature(new progress_1.ProgressFeature(this));
this.registerFeature(new callHierarchy_1.CallHierarchyFeature(this));
this.registerFeature(new semanticTokens_1.SemanticTokensFeature(this));
this.registerFeature(new linkedEditingRange_1.LinkedEditingFeature(this));
this.registerFeature(new fileOperations_1.DidCreateFilesFeature(this));
this.registerFeature(new fileOperations_1.DidRenameFilesFeature(this));
this.registerFeature(new fileOperations_1.DidDeleteFilesFeature(this));
this.registerFeature(new fileOperations_1.WillCreateFilesFeature(this));
this.registerFeature(new fileOperations_1.WillRenameFilesFeature(this));
this.registerFeature(new fileOperations_1.WillDeleteFilesFeature(this));
this.registerFeature(new typeHierarchy_1.TypeHierarchyFeature(this));
this.registerFeature(new inlineValue_1.InlineValueFeature(this));
this.registerFeature(new inlayHint_1.InlayHintsFeature(this));
this.registerFeature(new diagnostic_1.DiagnosticFeature(this));
this.registerFeature(new notebook_1.NotebookDocumentSyncFeature(this));
}
registerProposedFeatures() {
this.registerFeatures(ProposedFeatures.createAll(this));
}
fillInitializeParams(params) {
for (let feature of this._features) {
if (Is.func(feature.fillInitializeParams)) {
feature.fillInitializeParams(params);
}
}
}
computeClientCapabilities() {
const result = {};
(0, features_1.ensure)(result, "workspace").applyEdit = true;
const workspaceEdit = (0, features_1.ensure)((0, features_1.ensure)(result, "workspace"), "workspaceEdit");
workspaceEdit.documentChanges = true;
workspaceEdit.resourceOperations = [vscode_languageserver_protocol_1.ResourceOperationKind.Create, vscode_languageserver_protocol_1.ResourceOperationKind.Rename, vscode_languageserver_protocol_1.ResourceOperationKind.Delete];
workspaceEdit.failureHandling = vscode_languageserver_protocol_1.FailureHandlingKind.TextOnlyTransactional;
workspaceEdit.normalizesLineEndings = true;
workspaceEdit.changeAnnotationSupport = {
groupsOnLabel: true
};
const diagnostics = (0, features_1.ensure)((0, features_1.ensure)(result, "textDocument"), "publishDiagnostics");
diagnostics.relatedInformation = true;
diagnostics.versionSupport = false;
diagnostics.tagSupport = { valueSet: [vscode_languageserver_protocol_1.DiagnosticTag.Unnecessary, vscode_languageserver_protocol_1.DiagnosticTag.Deprecated] };
diagnostics.codeDescriptionSupport = true;
diagnostics.dataSupport = true;
const windowCapabilities = (0, features_1.ensure)(result, "window");
const showMessage = (0, features_1.ensure)(windowCapabilities, "showMessage");
showMessage.messageActionItem = { additionalPropertiesSupport: true };
const showDocument = (0, features_1.ensure)(windowCapabilities, "showDocument");
showDocument.support = true;
const generalCapabilities = (0, features_1.ensure)(result, "general");
generalCapabilities.staleRequestSupport = {
cancel: true,
retryOnContentModified: Array.from(_BaseLanguageClient.RequestsToCancelOnContentModified)
};
generalCapabilities.regularExpressions = { engine: "ECMAScript", version: "ES2020" };
generalCapabilities.markdown = {
parser: "marked",
version: "1.1.0"
};
generalCapabilities.positionEncodings = ["utf-16"];
if (this._clientOptions.markdown.supportHtml) {
generalCapabilities.markdown.allowedTags = ["ul", "li", "p", "code", "blockquote", "ol", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "em", "pre", "table", "thead", "tbody", "tr", "th", "td", "div", "del", "a", "strong", "br", "img", "span"];
}
for (let feature of this._features) {
feature.fillClientCapabilities(result);
}
return result;
}
initializeFeatures(_connection) {
const documentSelector2 = this._clientOptions.documentSelector;
for (const feature of this._features) {
if (Is.func(feature.preInitialize)) {
feature.preInitialize(this._capabilities, documentSelector2);
}
}
for (const feature of this._features) {
feature.initialize(this._capabilities, documentSelector2);
}
}
async handleRegistrationRequest(params) {
const middleware = this.clientOptions.middleware?.handleRegisterCapability;
if (middleware) {
return middleware(params, (nextParams) => this.doRegisterCapability(nextParams));
} else {
return this.doRegisterCapability(params);
}
}
async doRegisterCapability(params) {
if (!this.isRunning()) {
for (const registration of params.registrations) {
this._ignoredRegistrations.add(registration.id);
}
return;
}
for (const registration of params.registrations) {
const feature = this._dynamicFeatures.get(registration.method);
if (feature === void 0) {
return Promise.reject(new Error(`No feature implementation for ${registration.method} found. Registration failed.`));
}
const options = registration.registerOptions ?? {};
options.documentSelector = options.documentSelector ?? this._clientOptions.documentSelector;
const data = {
id: registration.id,
registerOptions: options
};
try {
feature.register(data);
} catch (err) {
return Promise.reject(err);
}
}
}
async handleUnregistrationRequest(params) {
const middleware = this.clientOptions.middleware?.handleUnregisterCapability;
if (middleware) {
return middleware(params, (nextParams) => this.doUnregisterCapability(nextParams));
} else {
return this.doUnregisterCapability(params);
}
}
async doUnregisterCapability(params) {
for (const unregistration of params.unregisterations) {
if (this._ignoredRegistrations.has(unregistration.id)) {
continue;
}
const feature = this._dynamicFeatures.get(unregistration.method);
if (!feature) {
return Promise.reject(new Error(`No feature implementation for ${unregistration.method} found. Unregistration failed.`));
}
feature.unregister(unregistration.id);
}
}
async handleApplyWorkspaceEdit(params) {
const workspaceEdit = params.edit;
const converted = await this.workspaceEditLock.lock(() => {
return this._p2c.asWorkspaceEdit(workspaceEdit);
});
const openTextDocuments = /* @__PURE__ */ new Map();
vscode_1.workspace.textDocuments.forEach((document) => openTextDocuments.set(document.uri.toString(), document));
let versionMismatch = false;
if (workspaceEdit.documentChanges) {
for (const change of workspaceEdit.documentChanges) {
if (vscode_languageserver_protocol_1.TextDocumentEdit.is(change) && change.textDocument.version && change.textDocument.version >= 0) {
const changeUri = this._p2c.asUri(change.textDocument.uri).toString();
const textDocument = openTextDocuments.get(changeUri);
if (textDocument && textDocument.version !== change.textDocument.version) {
versionMismatch = true;
break;
}
}
}
}
if (versionMismatch) {
return Promise.resolve({ applied: false });
}
return Is.asPromise(vscode_1.workspace.applyEdit(converted).then((value) => {
return { applied: value };
}));
}
handleFailedRequest(type, token, error, defaultValue, showNotification = true) {
if (error instanceof vscode_languageserver_protocol_1.ResponseError) {
if (error.code === vscode_languageserver_protocol_1.ErrorCodes.PendingResponseRejected || error.code === vscode_languageserver_protocol_1.ErrorCodes.ConnectionInactive) {
return defaultValue;
}
if (error.code === vscode_languageserver_protocol_1.LSPErrorCodes.RequestCancelled || error.code === vscode_languageserver_protocol_1.LSPErrorCodes.ServerCancelled) {
if (token !== void 0 && token.isCancellationRequested) {
return defaultValue;
} else {
if (error.data !== void 0) {
throw new features_1.LSPCancellationError(error.data);
} else {
throw new vscode_1.CancellationError();
}
}
} else if (error.code === vscode_languageserver_protocol_1.LSPErrorCodes.ContentModified) {
if (_BaseLanguageClient.RequestsToCancelOnContentModified.has(type.method) || _BaseLanguageClient.CancellableResolveCalls.has(type.method)) {
throw new vscode_1.CancellationError();
} else {
return defaultValue;
}
}
}
this.error(`Request ${type.method} failed.`, error, showNotification);
throw error;
}
};
exports2.BaseLanguageClient = BaseLanguageClient;
BaseLanguageClient.RequestsToCancelOnContentModified = /* @__PURE__ */ new Set([
vscode_languageserver_protocol_1.SemanticTokensRequest.method,
vscode_languageserver_protocol_1.SemanticTokensRangeRequest.method,
vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.method
]);
BaseLanguageClient.CancellableResolveCalls = /* @__PURE__ */ new Set([
vscode_languageserver_protocol_1.CompletionResolveRequest.method,
vscode_languageserver_protocol_1.CodeLensResolveRequest.method,
vscode_languageserver_protocol_1.CodeActionResolveRequest.method,
vscode_languageserver_protocol_1.InlayHintResolveRequest.method,
vscode_languageserver_protocol_1.DocumentLinkResolveRequest.method,
vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.method
]);
var ConsoleLogger = class {
error(message) {
(0, vscode_languageserver_protocol_1.RAL)().console.error(message);
}
warn(message) {
(0, vscode_languageserver_protocol_1.RAL)().console.warn(message);
}
info(message) {
(0, vscode_languageserver_protocol_1.RAL)().console.info(message);
}
log(message) {
(0, vscode_languageserver_protocol_1.RAL)().console.log(message);
}
};
function createConnection(input, output, errorHandler, closeHandler, options) {
const logger2 = new ConsoleLogger();
const connection = (0, vscode_languageserver_protocol_1.createProtocolConnection)(input, output, logger2, options);
connection.onError((data) => {
errorHandler(data[0], data[1], data[2]);
});
connection.onClose(closeHandler);
const result = {
listen: () => connection.listen(),
sendRequest: connection.sendRequest,
onRequest: connection.onRequest,
hasPendingResponse: connection.hasPendingResponse,
sendNotification: connection.sendNotification,
onNotification: connection.onNotification,
onProgress: connection.onProgress,
sendProgress: connection.sendProgress,
trace: (value, tracer, sendNotificationOrTraceOptions) => {
const defaultTraceOptions = {
sendNotification: false,
traceFormat: vscode_languageserver_protocol_1.TraceFormat.Text
};
if (sendNotificationOrTraceOptions === void 0) {
return connection.trace(value, tracer, defaultTraceOptions);
} else if (Is.boolean(sendNotificationOrTraceOptions)) {
return connection.trace(value, tracer, sendNotificationOrTraceOptions);
} else {
return connection.trace(value, tracer, sendNotificationOrTraceOptions);
}
},
initialize: (params) => {
return connection.sendRequest(vscode_languageserver_protocol_1.InitializeRequest.type, params);
},
shutdown: () => {
return connection.sendRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, void 0);
},
exit: () => {
return connection.sendNotification(vscode_languageserver_protocol_1.ExitNotification.type);
},
end: () => connection.end(),
dispose: () => connection.dispose()
};
return result;
}
var ProposedFeatures;
(function(ProposedFeatures2) {
function createAll(_client) {
let result = [
new inlineCompletion_1.InlineCompletionItemFeature(_client)
];
return result;
}
ProposedFeatures2.createAll = createAll;
})(ProposedFeatures || (exports2.ProposedFeatures = ProposedFeatures = {}));
}
});
// node_modules/vscode-languageclient/lib/node/processes.js
var require_processes = __commonJS({
"node_modules/vscode-languageclient/lib/node/processes.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.terminate = void 0;
var cp2 = require("child_process");
var path_1 = require("path");
var isWindows2 = process.platform === "win32";
var isMacintosh = process.platform === "darwin";
var isLinux2 = process.platform === "linux";
function terminate(process3, cwd) {
if (isWindows2) {
try {
let options = {
stdio: ["pipe", "pipe", "ignore"]
};
if (cwd) {
options.cwd = cwd;
}
cp2.execFileSync("taskkill", ["/T", "/F", "/PID", process3.pid.toString()], options);
return true;
} catch (err) {
return false;
}
} else if (isLinux2 || isMacintosh) {
try {
var cmd = (0, path_1.join)(__dirname, "terminateProcess.sh");
var result = cp2.spawnSync(cmd, [process3.pid.toString()]);
return result.error ? false : true;
} catch (err) {
return false;
}
} else {
process3.kill("SIGKILL");
return true;
}
}
exports2.terminate = terminate;
}
});
// node_modules/vscode-languageserver-protocol/node.js
var require_node2 = __commonJS({
"node_modules/vscode-languageserver-protocol/node.js"(exports2, module2) {
"use strict";
module2.exports = require_main3();
}
});
// node_modules/semver/internal/debug.js
var require_debug = __commonJS({
"node_modules/semver/internal/debug.js"(exports2, module2) {
"use strict";
var debug3 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
};
module2.exports = debug3;
}
});
// node_modules/semver/internal/constants.js
var require_constants = __commonJS({
"node_modules/semver/internal/constants.js"(exports2, module2) {
"use strict";
var SEMVER_SPEC_VERSION = "2.0.0";
var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
9007199254740991;
var MAX_SAFE_COMPONENT_LENGTH = 16;
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
var RELEASE_TYPES = [
"major",
"premajor",
"minor",
"preminor",
"patch",
"prepatch",
"prerelease"
];
module2.exports = {
MAX_LENGTH,
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_SAFE_INTEGER,
RELEASE_TYPES,
SEMVER_SPEC_VERSION,
FLAG_INCLUDE_PRERELEASE: 1,
FLAG_LOOSE: 2
};
}
});
// node_modules/semver/internal/re.js
var require_re = __commonJS({
"node_modules/semver/internal/re.js"(exports2, module2) {
"use strict";
var {
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_LENGTH
} = require_constants();
var debug3 = require_debug();
exports2 = module2.exports = {};
var re = exports2.re = [];
var safeRe = exports2.safeRe = [];
var src = exports2.src = [];
var safeSrc = exports2.safeSrc = [];
var t = exports2.t = {};
var R = 0;
var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
var safeRegexReplacements = [
["\\s", 1],
["\\d", MAX_LENGTH],
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
];
var makeSafeRegex = (value) => {
for (const [token, max] of safeRegexReplacements) {
value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
}
return value;
};
var createToken = (name, value, isGlobal) => {
const safe = makeSafeRegex(value);
const index = R++;
debug3(name, index, value);
t[name] = index;
src[index] = value;
safeSrc[index] = safe;
re[index] = new RegExp(value, isGlobal ? "g" : void 0);
safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
};
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
createToken("FULL", `^${src[t.FULLPLAIN]}$`);
createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
createToken("GTLT", "((?:<|>)?=?)");
createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
createToken("COERCERTL", src[t.COERCE], true);
createToken("COERCERTLFULL", src[t.COERCEFULL], true);
createToken("LONETILDE", "(?:~>?)");
createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
exports2.tildeTrimReplace = "$1~";
createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
createToken("LONECARET", "(?:\\^)");
createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
exports2.caretTrimReplace = "$1^";
createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
exports2.comparatorTrimReplace = "$1$2$3";
createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
createToken("STAR", "(<|>)?=?\\s*\\*");
createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
}
});
// node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
"node_modules/semver/internal/parse-options.js"(exports2, module2) {
"use strict";
var looseOption = Object.freeze({ loose: true });
var emptyOpts = Object.freeze({});
var parseOptions = (options) => {
if (!options) {
return emptyOpts;
}
if (typeof options !== "object") {
return looseOption;
}
return options;
};
module2.exports = parseOptions;
}
});
// node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
"node_modules/semver/internal/identifiers.js"(exports2, module2) {
"use strict";
var numeric = /^[0-9]+$/;
var compareIdentifiers = (a, b) => {
const anum = numeric.test(a);
const bnum = numeric.test(b);
if (anum && bnum) {
a = +a;
b = +b;
}
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
};
var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
module2.exports = {
compareIdentifiers,
rcompareIdentifiers
};
}
});
// node_modules/semver/classes/semver.js
var require_semver = __commonJS({
"node_modules/semver/classes/semver.js"(exports2, module2) {
"use strict";
var debug3 = require_debug();
var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
var { safeRe: re, t } = require_re();
var parseOptions = require_parse_options();
var { compareIdentifiers } = require_identifiers();
var SemVer3 = class _SemVer {
constructor(version, options) {
options = parseOptions(options);
if (version instanceof _SemVer) {
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
return version;
} else {
version = version.version;
}
} else if (typeof version !== "string") {
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
}
if (version.length > MAX_LENGTH) {
throw new TypeError(
`version is longer than ${MAX_LENGTH} characters`
);
}
debug3("SemVer", version, options);
this.options = options;
this.loose = !!options.loose;
this.includePrerelease = !!options.includePrerelease;
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
if (!m) {
throw new TypeError(`Invalid Version: ${version}`);
}
this.raw = version;
this.major = +m[1];
this.minor = +m[2];
this.patch = +m[3];
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
throw new TypeError("Invalid major version");
}
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
throw new TypeError("Invalid minor version");
}
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
throw new TypeError("Invalid patch version");
}
if (!m[4]) {
this.prerelease = [];
} else {
this.prerelease = m[4].split(".").map((id) => {
if (/^[0-9]+$/.test(id)) {
const num = +id;
if (num >= 0 && num < MAX_SAFE_INTEGER) {
return num;
}
}
return id;
});
}
this.build = m[5] ? m[5].split(".") : [];
this.format();
}
format() {
this.version = `${this.major}.${this.minor}.${this.patch}`;
if (this.prerelease.length) {
this.version += `-${this.prerelease.join(".")}`;
}
return this.version;
}
toString() {
return this.version;
}
compare(other) {
debug3("SemVer.compare", this.version, this.options, other);
if (!(other instanceof _SemVer)) {
if (typeof other === "string" && other === this.version) {
return 0;
}
other = new _SemVer(other, this.options);
}
if (other.version === this.version) {
return 0;
}
return this.compareMain(other) || this.comparePre(other);
}
compareMain(other) {
if (!(other instanceof _SemVer)) {
other = new _SemVer(other, this.options);
}
return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
}
comparePre(other) {
if (!(other instanceof _SemVer)) {
other = new _SemVer(other, this.options);
}
if (this.prerelease.length && !other.prerelease.length) {
return -1;
} else if (!this.prerelease.length && other.prerelease.length) {
return 1;
} else if (!this.prerelease.length && !other.prerelease.length) {
return 0;
}
let i = 0;
do {
const a = this.prerelease[i];
const b = other.prerelease[i];
debug3("prerelease compare", i, a, b);
if (a === void 0 && b === void 0) {
return 0;
} else if (b === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers(a, b);
}
} while (++i);
}
compareBuild(other) {
if (!(other instanceof _SemVer)) {
other = new _SemVer(other, this.options);
}
let i = 0;
do {
const a = this.build[i];
const b = other.build[i];
debug3("build compare", i, a, b);
if (a === void 0 && b === void 0) {
return 0;
} else if (b === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers(a, b);
}
} while (++i);
}
// preminor will bump the version up to the next minor release, and immediately
// down to pre-release. premajor and prepatch work the same way.
inc(release, identifier, identifierBase) {
if (release.startsWith("pre")) {
if (!identifier && identifierBase === false) {
throw new Error("invalid increment argument: identifier is empty");
}
if (identifier) {
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
if (!match || match[1] !== identifier) {
throw new Error(`invalid identifier: ${identifier}`);
}
}
}
switch (release) {
case "premajor":
this.prerelease.length = 0;
this.patch = 0;
this.minor = 0;
this.major++;
this.inc("pre", identifier, identifierBase);
break;
case "preminor":
this.prerelease.length = 0;
this.patch = 0;
this.minor++;
this.inc("pre", identifier, identifierBase);
break;
case "prepatch":
this.prerelease.length = 0;
this.inc("patch", identifier, identifierBase);
this.inc("pre", identifier, identifierBase);
break;
// If the input is a non-prerelease version, this acts the same as
// prepatch.
case "prerelease":
if (this.prerelease.length === 0) {
this.inc("patch", identifier, identifierBase);
}
this.inc("pre", identifier, identifierBase);
break;
case "release":
if (this.prerelease.length === 0) {
throw new Error(`version ${this.raw} is not a prerelease`);
}
this.prerelease.length = 0;
break;
case "major":
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
this.major++;
}
this.minor = 0;
this.patch = 0;
this.prerelease = [];
break;
case "minor":
if (this.patch !== 0 || this.prerelease.length === 0) {
this.minor++;
}
this.patch = 0;
this.prerelease = [];
break;
case "patch":
if (this.prerelease.length === 0) {
this.patch++;
}
this.prerelease = [];
break;
// This probably shouldn't be used publicly.
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
case "pre": {
const base = Number(identifierBase) ? 1 : 0;
if (this.prerelease.length === 0) {
this.prerelease = [base];
} else {
let i = this.prerelease.length;
while (--i >= 0) {
if (typeof this.prerelease[i] === "number") {
this.prerelease[i]++;
i = -2;
}
}
if (i === -1) {
if (identifier === this.prerelease.join(".") && identifierBase === false) {
throw new Error("invalid increment argument: identifier already exists");
}
this.prerelease.push(base);
}
}
if (identifier) {
let prerelease = [identifier, base];
if (identifierBase === false) {
prerelease = [identifier];
}
if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
if (isNaN(this.prerelease[1])) {
this.prerelease = prerelease;
}
} else {
this.prerelease = prerelease;
}
}
break;
}
default:
throw new Error(`invalid increment argument: ${release}`);
}
this.raw = this.format();
if (this.build.length) {
this.raw += `+${this.build.join(".")}`;
}
return this;
}
};
module2.exports = SemVer3;
}
});
// node_modules/semver/functions/parse.js
var require_parse = __commonJS({
"node_modules/semver/functions/parse.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var parse = (version, options, throwErrors = false) => {
if (version instanceof SemVer3) {
return version;
}
try {
return new SemVer3(version, options);
} catch (er) {
if (!throwErrors) {
return null;
}
throw er;
}
};
module2.exports = parse;
}
});
// node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
"node_modules/semver/internal/lrucache.js"(exports2, module2) {
"use strict";
var LRUCache = class {
constructor() {
this.max = 1e3;
this.map = /* @__PURE__ */ new Map();
}
get(key) {
const value = this.map.get(key);
if (value === void 0) {
return void 0;
} else {
this.map.delete(key);
this.map.set(key, value);
return value;
}
}
delete(key) {
return this.map.delete(key);
}
set(key, value) {
const deleted = this.delete(key);
if (!deleted && value !== void 0) {
if (this.map.size >= this.max) {
const firstKey = this.map.keys().next().value;
this.delete(firstKey);
}
this.map.set(key, value);
}
return this;
}
};
module2.exports = LRUCache;
}
});
// node_modules/semver/functions/compare.js
var require_compare = __commonJS({
"node_modules/semver/functions/compare.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var compare = (a, b, loose) => new SemVer3(a, loose).compare(new SemVer3(b, loose));
module2.exports = compare;
}
});
// node_modules/semver/functions/eq.js
var require_eq = __commonJS({
"node_modules/semver/functions/eq.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var eq = (a, b, loose) => compare(a, b, loose) === 0;
module2.exports = eq;
}
});
// node_modules/semver/functions/neq.js
var require_neq = __commonJS({
"node_modules/semver/functions/neq.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var neq = (a, b, loose) => compare(a, b, loose) !== 0;
module2.exports = neq;
}
});
// node_modules/semver/functions/gt.js
var require_gt = __commonJS({
"node_modules/semver/functions/gt.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var gt = (a, b, loose) => compare(a, b, loose) > 0;
module2.exports = gt;
}
});
// node_modules/semver/functions/gte.js
var require_gte = __commonJS({
"node_modules/semver/functions/gte.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var gte = (a, b, loose) => compare(a, b, loose) >= 0;
module2.exports = gte;
}
});
// node_modules/semver/functions/lt.js
var require_lt = __commonJS({
"node_modules/semver/functions/lt.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var lt = (a, b, loose) => compare(a, b, loose) < 0;
module2.exports = lt;
}
});
// node_modules/semver/functions/lte.js
var require_lte = __commonJS({
"node_modules/semver/functions/lte.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var lte = (a, b, loose) => compare(a, b, loose) <= 0;
module2.exports = lte;
}
});
// node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
"node_modules/semver/functions/cmp.js"(exports2, module2) {
"use strict";
var eq = require_eq();
var neq = require_neq();
var gt = require_gt();
var gte = require_gte();
var lt = require_lt();
var lte = require_lte();
var cmp = (a, op, b, loose) => {
switch (op) {
case "===":
if (typeof a === "object") {
a = a.version;
}
if (typeof b === "object") {
b = b.version;
}
return a === b;
case "!==":
if (typeof a === "object") {
a = a.version;
}
if (typeof b === "object") {
b = b.version;
}
return a !== b;
case "":
case "=":
case "==":
return eq(a, b, loose);
case "!=":
return neq(a, b, loose);
case ">":
return gt(a, b, loose);
case ">=":
return gte(a, b, loose);
case "<":
return lt(a, b, loose);
case "<=":
return lte(a, b, loose);
default:
throw new TypeError(`Invalid operator: ${op}`);
}
};
module2.exports = cmp;
}
});
// node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
"node_modules/semver/classes/comparator.js"(exports2, module2) {
"use strict";
var ANY = Symbol("SemVer ANY");
var Comparator = class _Comparator {
static get ANY() {
return ANY;
}
constructor(comp, options) {
options = parseOptions(options);
if (comp instanceof _Comparator) {
if (comp.loose === !!options.loose) {
return comp;
} else {
comp = comp.value;
}
}
comp = comp.trim().split(/\s+/).join(" ");
debug3("comparator", comp, options);
this.options = options;
this.loose = !!options.loose;
this.parse(comp);
if (this.semver === ANY) {
this.value = "";
} else {
this.value = this.operator + this.semver.version;
}
debug3("comp", this);
}
parse(comp) {
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
const m = comp.match(r);
if (!m) {
throw new TypeError(`Invalid comparator: ${comp}`);
}
this.operator = m[1] !== void 0 ? m[1] : "";
if (this.operator === "=") {
this.operator = "";
}
if (!m[2]) {
this.semver = ANY;
} else {
this.semver = new SemVer3(m[2], this.options.loose);
}
}
toString() {
return this.value;
}
test(version) {
debug3("Comparator.test", version, this.options.loose);
if (this.semver === ANY || version === ANY) {
return true;
}
if (typeof version === "string") {
try {
version = new SemVer3(version, this.options);
} catch (er) {
return false;
}
}
return cmp(version, this.operator, this.semver, this.options);
}
intersects(comp, options) {
if (!(comp instanceof _Comparator)) {
throw new TypeError("a Comparator is required");
}
if (this.operator === "") {
if (this.value === "") {
return true;
}
return new Range5(comp.value, options).test(this.value);
} else if (comp.operator === "") {
if (comp.value === "") {
return true;
}
return new Range5(this.value, options).test(comp.semver);
}
options = parseOptions(options);
if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
return false;
}
if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
return false;
}
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
return true;
}
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
return true;
}
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
return true;
}
if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
return true;
}
if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
return true;
}
return false;
}
};
module2.exports = Comparator;
var parseOptions = require_parse_options();
var { safeRe: re, t } = require_re();
var cmp = require_cmp();
var debug3 = require_debug();
var SemVer3 = require_semver();
var Range5 = require_range();
}
});
// node_modules/semver/classes/range.js
var require_range = __commonJS({
"node_modules/semver/classes/range.js"(exports2, module2) {
"use strict";
var SPACE_CHARACTERS = /\s+/g;
var Range5 = class _Range {
constructor(range, options) {
options = parseOptions(options);
if (range instanceof _Range) {
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
return range;
} else {
return new _Range(range.raw, options);
}
}
if (range instanceof Comparator) {
this.raw = range.value;
this.set = [[range]];
this.formatted = void 0;
return this;
}
this.options = options;
this.loose = !!options.loose;
this.includePrerelease = !!options.includePrerelease;
this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
if (!this.set.length) {
throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
}
if (this.set.length > 1) {
const first = this.set[0];
this.set = this.set.filter((c) => !isNullSet(c[0]));
if (this.set.length === 0) {
this.set = [first];
} else if (this.set.length > 1) {
for (const c of this.set) {
if (c.length === 1 && isAny(c[0])) {
this.set = [c];
break;
}
}
}
}
this.formatted = void 0;
}
get range() {
if (this.formatted === void 0) {
this.formatted = "";
for (let i = 0; i < this.set.length; i++) {
if (i > 0) {
this.formatted += "||";
}
const comps = this.set[i];
for (let k = 0; k < comps.length; k++) {
if (k > 0) {
this.formatted += " ";
}
this.formatted += comps[k].toString().trim();
}
}
}
return this.formatted;
}
format() {
return this.range;
}
toString() {
return this.range;
}
parseRange(range) {
const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
const memoKey = memoOpts + ":" + range;
const cached = cache.get(memoKey);
if (cached) {
return cached;
}
const loose = this.options.loose;
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
debug3("hyphen replace", range);
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
debug3("comparator trim", range);
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
debug3("tilde trim", range);
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
debug3("caret trim", range);
let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
if (loose) {
rangeList = rangeList.filter((comp) => {
debug3("loose invalid filter", comp, this.options);
return !!comp.match(re[t.COMPARATORLOOSE]);
});
}
debug3("range list", rangeList);
const rangeMap = /* @__PURE__ */ new Map();
const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
for (const comp of comparators) {
if (isNullSet(comp)) {
return [comp];
}
rangeMap.set(comp.value, comp);
}
if (rangeMap.size > 1 && rangeMap.has("")) {
rangeMap.delete("");
}
const result = [...rangeMap.values()];
cache.set(memoKey, result);
return result;
}
intersects(range, options) {
if (!(range instanceof _Range)) {
throw new TypeError("a Range is required");
}
return this.set.some((thisComparators) => {
return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
return rangeComparators.every((rangeComparator) => {
return thisComparator.intersects(rangeComparator, options);
});
});
});
});
}
// if ANY of the sets match ALL of its comparators, then pass
test(version) {
if (!version) {
return false;
}
if (typeof version === "string") {
try {
version = new SemVer3(version, this.options);
} catch (er) {
return false;
}
}
for (let i = 0; i < this.set.length; i++) {
if (testSet(this.set[i], version, this.options)) {
return true;
}
}
return false;
}
};
module2.exports = Range5;
var LRU = require_lrucache();
var cache = new LRU();
var parseOptions = require_parse_options();
var Comparator = require_comparator();
var debug3 = require_debug();
var SemVer3 = require_semver();
var {
safeRe: re,
t,
comparatorTrimReplace,
tildeTrimReplace,
caretTrimReplace
} = require_re();
var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
var isNullSet = (c) => c.value === "<0.0.0-0";
var isAny = (c) => c.value === "";
var isSatisfiable = (comparators, options) => {
let result = true;
const remainingComparators = comparators.slice();
let testComparator = remainingComparators.pop();
while (result && remainingComparators.length) {
result = remainingComparators.every((otherComparator) => {
return testComparator.intersects(otherComparator, options);
});
testComparator = remainingComparators.pop();
}
return result;
};
var parseComparator = (comp, options) => {
debug3("comp", comp, options);
comp = replaceCarets(comp, options);
debug3("caret", comp);
comp = replaceTildes(comp, options);
debug3("tildes", comp);
comp = replaceXRanges(comp, options);
debug3("xrange", comp);
comp = replaceStars(comp, options);
debug3("stars", comp);
return comp;
};
var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
var replaceTildes = (comp, options) => {
return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
};
var replaceTilde = (comp, options) => {
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
return comp.replace(r, (_, M, m, p, pr) => {
debug3("tilde", comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = "";
} else if (isX(m)) {
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
} else if (isX(p)) {
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
} else if (pr) {
debug3("replaceTilde pr", pr);
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
} else {
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
}
debug3("tilde return", ret);
return ret;
});
};
var replaceCarets = (comp, options) => {
return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
};
var replaceCaret = (comp, options) => {
debug3("caret", comp, options);
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
const z = options.includePrerelease ? "-0" : "";
return comp.replace(r, (_, M, m, p, pr) => {
debug3("caret", comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = "";
} else if (isX(m)) {
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
} else if (isX(p)) {
if (M === "0") {
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
} else {
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
}
} else if (pr) {
debug3("replaceCaret pr", pr);
if (M === "0") {
if (m === "0") {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
}
} else {
debug3("no pr");
if (M === "0") {
if (m === "0") {
ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
}
}
debug3("caret return", ret);
return ret;
});
};
var replaceXRanges = (comp, options) => {
debug3("replaceXRanges", comp, options);
return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
};
var replaceXRange = (comp, options) => {
comp = comp.trim();
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
debug3("xRange", comp, ret, gtlt, M, m, p, pr);
const xM = isX(M);
const xm = xM || isX(m);
const xp = xm || isX(p);
const anyX = xp;
if (gtlt === "=" && anyX) {
gtlt = "";
}
pr = options.includePrerelease ? "-0" : "";
if (xM) {
if (gtlt === ">" || gtlt === "<") {
ret = "<0.0.0-0";
} else {
ret = "*";
}
} else if (gtlt && anyX) {
if (xm) {
m = 0;
}
p = 0;
if (gtlt === ">") {
gtlt = ">=";
if (xm) {
M = +M + 1;
m = 0;
p = 0;
} else {
m = +m + 1;
p = 0;
}
} else if (gtlt === "<=") {
gtlt = "<";
if (xm) {
M = +M + 1;
} else {
m = +m + 1;
}
}
if (gtlt === "<") {
pr = "-0";
}
ret = `${gtlt + M}.${m}.${p}${pr}`;
} else if (xm) {
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
} else if (xp) {
ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
}
debug3("xRange return", ret);
return ret;
});
};
var replaceStars = (comp, options) => {
debug3("replaceStars", comp, options);
return comp.trim().replace(re[t.STAR], "");
};
var replaceGTE0 = (comp, options) => {
debug3("replaceGTE0", comp, options);
return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
};
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
if (isX(fM)) {
from = "";
} else if (isX(fm)) {
from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
} else if (isX(fp)) {
from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
} else if (fpr) {
from = `>=${from}`;
} else {
from = `>=${from}${incPr ? "-0" : ""}`;
}
if (isX(tM)) {
to = "";
} else if (isX(tm)) {
to = `<${+tM + 1}.0.0-0`;
} else if (isX(tp)) {
to = `<${tM}.${+tm + 1}.0-0`;
} else if (tpr) {
to = `<=${tM}.${tm}.${tp}-${tpr}`;
} else if (incPr) {
to = `<${tM}.${tm}.${+tp + 1}-0`;
} else {
to = `<=${to}`;
}
return `${from} ${to}`.trim();
};
var testSet = (set, version, options) => {
for (let i = 0; i < set.length; i++) {
if (!set[i].test(version)) {
return false;
}
}
if (version.prerelease.length && !options.includePrerelease) {
for (let i = 0; i < set.length; i++) {
debug3(set[i].semver);
if (set[i].semver === Comparator.ANY) {
continue;
}
if (set[i].semver.prerelease.length > 0) {
const allowed = set[i].semver;
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
return true;
}
}
}
return false;
}
return true;
};
}
});
// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
"node_modules/semver/functions/satisfies.js"(exports2, module2) {
"use strict";
var Range5 = require_range();
var satisfies2 = (version, range, options) => {
try {
range = new Range5(range, options);
} catch (er) {
return false;
}
return range.test(version);
};
module2.exports = satisfies2;
}
});
// node_modules/vscode-languageclient/lib/common/api.js
var require_api3 = __commonJS({
"node_modules/vscode-languageclient/lib/common/api.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.DiagnosticPullMode = exports2.vsdiag = void 0;
__exportStar(require_main3(), exports2);
__exportStar(require_features(), exports2);
var diagnostic_1 = require_diagnostic();
Object.defineProperty(exports2, "vsdiag", { enumerable: true, get: function() {
return diagnostic_1.vsdiag;
} });
Object.defineProperty(exports2, "DiagnosticPullMode", { enumerable: true, get: function() {
return diagnostic_1.DiagnosticPullMode;
} });
__exportStar(require_client(), exports2);
}
});
// node_modules/vscode-languageclient/lib/node/main.js
var require_main4 = __commonJS({
"node_modules/vscode-languageclient/lib/node/main.js"(exports2) {
"use strict";
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}));
var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
};
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SettingMonitor = exports2.LanguageClient = exports2.TransportKind = void 0;
var cp2 = require("child_process");
var fs = require("fs");
var path11 = require("path");
var vscode_1 = require("vscode");
var Is = require_is();
var client_1 = require_client();
var processes_1 = require_processes();
var node_1 = require_node2();
var semverParse = require_parse();
var semverSatisfies = require_satisfies();
__exportStar(require_node2(), exports2);
__exportStar(require_api3(), exports2);
var REQUIRED_VSCODE_VERSION = "^1.82.0";
var TransportKind;
(function(TransportKind2) {
TransportKind2[TransportKind2["stdio"] = 0] = "stdio";
TransportKind2[TransportKind2["ipc"] = 1] = "ipc";
TransportKind2[TransportKind2["pipe"] = 2] = "pipe";
TransportKind2[TransportKind2["socket"] = 3] = "socket";
})(TransportKind || (exports2.TransportKind = TransportKind = {}));
var Transport;
(function(Transport2) {
function isSocket(value) {
const candidate = value;
return candidate && candidate.kind === TransportKind.socket && Is.number(candidate.port);
}
Transport2.isSocket = isSocket;
})(Transport || (Transport = {}));
var Executable;
(function(Executable2) {
function is(value) {
return Is.string(value.command);
}
Executable2.is = is;
})(Executable || (Executable = {}));
var NodeModule;
(function(NodeModule2) {
function is(value) {
return Is.string(value.module);
}
NodeModule2.is = is;
})(NodeModule || (NodeModule = {}));
var StreamInfo;
(function(StreamInfo2) {
function is(value) {
let candidate = value;
return candidate && candidate.writer !== void 0 && candidate.reader !== void 0;
}
StreamInfo2.is = is;
})(StreamInfo || (StreamInfo = {}));
var ChildProcessInfo;
(function(ChildProcessInfo2) {
function is(value) {
let candidate = value;
return candidate && candidate.process !== void 0 && typeof candidate.detached === "boolean";
}
ChildProcessInfo2.is = is;
})(ChildProcessInfo || (ChildProcessInfo = {}));
var LanguageClient8 = class extends client_1.BaseLanguageClient {
constructor(arg1, arg2, arg3, arg4, arg5) {
let id;
let name;
let serverOptions;
let clientOptions;
let forceDebug;
if (Is.string(arg2)) {
id = arg1;
name = arg2;
serverOptions = arg3;
clientOptions = arg4;
forceDebug = !!arg5;
} else {
id = arg1.toLowerCase();
name = arg1;
serverOptions = arg2;
clientOptions = arg3;
forceDebug = arg4;
}
if (forceDebug === void 0) {
forceDebug = false;
}
super(id, name, clientOptions);
this._serverOptions = serverOptions;
this._forceDebug = forceDebug;
this._isInDebugMode = forceDebug;
try {
this.checkVersion();
} catch (error) {
if (Is.string(error.message)) {
this.outputChannel.appendLine(error.message);
}
throw error;
}
}
checkVersion() {
const codeVersion = semverParse(vscode_1.version);
if (!codeVersion) {
throw new Error(`No valid VS Code version detected. Version string is: ${vscode_1.version}`);
}
if (codeVersion.prerelease && codeVersion.prerelease.length > 0) {
codeVersion.prerelease = [];
}
if (!semverSatisfies(codeVersion, REQUIRED_VSCODE_VERSION)) {
throw new Error(`The language client requires VS Code version ${REQUIRED_VSCODE_VERSION} but received version ${vscode_1.version}`);
}
}
get isInDebugMode() {
return this._isInDebugMode;
}
async restart() {
await this.stop();
if (this.isInDebugMode) {
await new Promise((resolve3) => setTimeout(resolve3, 1e3));
await this.start();
} else {
await this.start();
}
}
stop(timeout = 2e3) {
return super.stop(timeout).finally(() => {
if (this._serverProcess) {
const toCheck = this._serverProcess;
this._serverProcess = void 0;
if (this._isDetached === void 0 || !this._isDetached) {
this.checkProcessDied(toCheck);
}
this._isDetached = void 0;
}
});
}
checkProcessDied(childProcess) {
if (!childProcess || childProcess.pid === void 0) {
return;
}
setTimeout(() => {
try {
if (childProcess.pid !== void 0) {
process.kill(childProcess.pid, 0);
(0, processes_1.terminate)(childProcess);
}
} catch (error) {
}
}, 2e3);
}
handleConnectionClosed() {
this._serverProcess = void 0;
return super.handleConnectionClosed();
}
fillInitializeParams(params) {
super.fillInitializeParams(params);
if (params.processId === null) {
params.processId = process.pid;
}
}
createMessageTransports(encoding) {
function getEnvironment(env2, fork) {
if (!env2 && !fork) {
return void 0;
}
const result = /* @__PURE__ */ Object.create(null);
Object.keys(process.env).forEach((key) => result[key] = process.env[key]);
if (fork) {
result["ELECTRON_RUN_AS_NODE"] = "1";
result["ELECTRON_NO_ASAR"] = "1";
}
if (env2) {
Object.keys(env2).forEach((key) => result[key] = env2[key]);
}
return result;
}
const debugStartWith = ["--debug=", "--debug-brk=", "--inspect=", "--inspect-brk="];
const debugEquals = ["--debug", "--debug-brk", "--inspect", "--inspect-brk"];
function startedInDebugMode() {
let args = process.execArgv;
if (args) {
return args.some((arg) => {
return debugStartWith.some((value) => arg.startsWith(value)) || debugEquals.some((value) => arg === value);
});
}
return false;
}
function assertStdio(process3) {
if (process3.stdin === null || process3.stdout === null || process3.stderr === null) {
throw new Error("Process created without stdio streams");
}
}
const server = this._serverOptions;
if (Is.func(server)) {
return server().then((result) => {
if (client_1.MessageTransports.is(result)) {
this._isDetached = !!result.detached;
return result;
} else if (StreamInfo.is(result)) {
this._isDetached = !!result.detached;
return { reader: new node_1.StreamMessageReader(result.reader), writer: new node_1.StreamMessageWriter(result.writer) };
} else {
let cp3;
if (ChildProcessInfo.is(result)) {
cp3 = result.process;
this._isDetached = result.detached;
} else {
cp3 = result;
this._isDetached = false;
}
cp3.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return { reader: new node_1.StreamMessageReader(cp3.stdout), writer: new node_1.StreamMessageWriter(cp3.stdin) };
}
});
}
let json;
let runDebug = server;
if (runDebug.run || runDebug.debug) {
if (this._forceDebug || startedInDebugMode()) {
json = runDebug.debug;
this._isInDebugMode = true;
} else {
json = runDebug.run;
this._isInDebugMode = false;
}
} else {
json = server;
}
return this._getServerWorkingDir(json.options).then((serverWorkingDir) => {
if (NodeModule.is(json) && json.module) {
let node = json;
let transport = node.transport || TransportKind.stdio;
if (node.runtime) {
const args = [];
const options = node.options ?? /* @__PURE__ */ Object.create(null);
if (options.execArgv) {
options.execArgv.forEach((element) => args.push(element));
}
args.push(node.module);
if (node.args) {
node.args.forEach((element) => args.push(element));
}
const execOptions = /* @__PURE__ */ Object.create(null);
execOptions.cwd = serverWorkingDir;
execOptions.env = getEnvironment(options.env, false);
const runtime = this._getRuntimePath(node.runtime, serverWorkingDir);
let pipeName = void 0;
if (transport === TransportKind.ipc) {
execOptions.stdio = [null, null, null, "ipc"];
args.push("--node-ipc");
} else if (transport === TransportKind.stdio) {
args.push("--stdio");
} else if (transport === TransportKind.pipe) {
pipeName = (0, node_1.generateRandomPipeName)();
args.push(`--pipe=${pipeName}`);
} else if (Transport.isSocket(transport)) {
args.push(`--socket=${transport.port}`);
}
args.push(`--clientProcessId=${process.pid.toString()}`);
if (transport === TransportKind.ipc || transport === TransportKind.stdio) {
const serverProcess = cp2.spawn(runtime, args, execOptions);
if (!serverProcess || !serverProcess.pid) {
return handleChildProcessStartError(serverProcess, `Launching server using runtime ${runtime} failed.`);
}
this._serverProcess = serverProcess;
serverProcess.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
if (transport === TransportKind.ipc) {
serverProcess.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return Promise.resolve({ reader: new node_1.IPCMessageReader(serverProcess), writer: new node_1.IPCMessageWriter(serverProcess) });
} else {
return Promise.resolve({ reader: new node_1.StreamMessageReader(serverProcess.stdout), writer: new node_1.StreamMessageWriter(serverProcess.stdin) });
}
} else if (transport === TransportKind.pipe) {
return (0, node_1.createClientPipeTransport)(pipeName).then((transport2) => {
const process3 = cp2.spawn(runtime, args, execOptions);
if (!process3 || !process3.pid) {
return handleChildProcessStartError(process3, `Launching server using runtime ${runtime} failed.`);
}
this._serverProcess = process3;
process3.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
process3.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return transport2.onConnected().then((protocol) => {
return { reader: protocol[0], writer: protocol[1] };
});
});
} else if (Transport.isSocket(transport)) {
return (0, node_1.createClientSocketTransport)(transport.port).then((transport2) => {
const process3 = cp2.spawn(runtime, args, execOptions);
if (!process3 || !process3.pid) {
return handleChildProcessStartError(process3, `Launching server using runtime ${runtime} failed.`);
}
this._serverProcess = process3;
process3.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
process3.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return transport2.onConnected().then((protocol) => {
return { reader: protocol[0], writer: protocol[1] };
});
});
}
} else {
let pipeName = void 0;
return new Promise((resolve3, reject) => {
const args = (node.args && node.args.slice()) ?? [];
if (transport === TransportKind.ipc) {
args.push("--node-ipc");
} else if (transport === TransportKind.stdio) {
args.push("--stdio");
} else if (transport === TransportKind.pipe) {
pipeName = (0, node_1.generateRandomPipeName)();
args.push(`--pipe=${pipeName}`);
} else if (Transport.isSocket(transport)) {
args.push(`--socket=${transport.port}`);
}
args.push(`--clientProcessId=${process.pid.toString()}`);
const options = node.options ?? /* @__PURE__ */ Object.create(null);
options.env = getEnvironment(options.env, true);
options.execArgv = options.execArgv || [];
options.cwd = serverWorkingDir;
options.silent = true;
if (transport === TransportKind.ipc || transport === TransportKind.stdio) {
const sp = cp2.fork(node.module, args || [], options);
assertStdio(sp);
this._serverProcess = sp;
sp.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
if (transport === TransportKind.ipc) {
sp.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
resolve3({ reader: new node_1.IPCMessageReader(this._serverProcess), writer: new node_1.IPCMessageWriter(this._serverProcess) });
} else {
resolve3({ reader: new node_1.StreamMessageReader(sp.stdout), writer: new node_1.StreamMessageWriter(sp.stdin) });
}
} else if (transport === TransportKind.pipe) {
(0, node_1.createClientPipeTransport)(pipeName).then((transport2) => {
const sp = cp2.fork(node.module, args || [], options);
assertStdio(sp);
this._serverProcess = sp;
sp.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
sp.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
transport2.onConnected().then((protocol) => {
resolve3({ reader: protocol[0], writer: protocol[1] });
}, reject);
}, reject);
} else if (Transport.isSocket(transport)) {
(0, node_1.createClientSocketTransport)(transport.port).then((transport2) => {
const sp = cp2.fork(node.module, args || [], options);
assertStdio(sp);
this._serverProcess = sp;
sp.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
sp.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
transport2.onConnected().then((protocol) => {
resolve3({ reader: protocol[0], writer: protocol[1] });
}, reject);
}, reject);
}
});
}
} else if (Executable.is(json) && json.command) {
const command = json;
const args = json.args !== void 0 ? json.args.slice(0) : [];
let pipeName = void 0;
const transport = json.transport;
if (transport === TransportKind.stdio) {
args.push("--stdio");
} else if (transport === TransportKind.pipe) {
pipeName = (0, node_1.generateRandomPipeName)();
args.push(`--pipe=${pipeName}`);
} else if (Transport.isSocket(transport)) {
args.push(`--socket=${transport.port}`);
} else if (transport === TransportKind.ipc) {
throw new Error(`Transport kind ipc is not support for command executable`);
}
const options = Object.assign({}, command.options);
options.cwd = options.cwd || serverWorkingDir;
if (transport === void 0 || transport === TransportKind.stdio) {
const serverProcess = cp2.spawn(command.command, args, options);
if (!serverProcess || !serverProcess.pid) {
return handleChildProcessStartError(serverProcess, `Launching server using command ${command.command} failed.`);
}
serverProcess.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
this._serverProcess = serverProcess;
this._isDetached = !!options.detached;
return Promise.resolve({ reader: new node_1.StreamMessageReader(serverProcess.stdout), writer: new node_1.StreamMessageWriter(serverProcess.stdin) });
} else if (transport === TransportKind.pipe) {
return (0, node_1.createClientPipeTransport)(pipeName).then((transport2) => {
const serverProcess = cp2.spawn(command.command, args, options);
if (!serverProcess || !serverProcess.pid) {
return handleChildProcessStartError(serverProcess, `Launching server using command ${command.command} failed.`);
}
this._serverProcess = serverProcess;
this._isDetached = !!options.detached;
serverProcess.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
serverProcess.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return transport2.onConnected().then((protocol) => {
return { reader: protocol[0], writer: protocol[1] };
});
});
} else if (Transport.isSocket(transport)) {
return (0, node_1.createClientSocketTransport)(transport.port).then((transport2) => {
const serverProcess = cp2.spawn(command.command, args, options);
if (!serverProcess || !serverProcess.pid) {
return handleChildProcessStartError(serverProcess, `Launching server using command ${command.command} failed.`);
}
this._serverProcess = serverProcess;
this._isDetached = !!options.detached;
serverProcess.stderr.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
serverProcess.stdout.on("data", (data) => this.outputChannel.append(Is.string(data) ? data : data.toString(encoding)));
return transport2.onConnected().then((protocol) => {
return { reader: protocol[0], writer: protocol[1] };
});
});
}
}
return Promise.reject(new Error(`Unsupported server configuration ` + JSON.stringify(server, null, 4)));
}).finally(() => {
if (this._serverProcess !== void 0) {
this._serverProcess.on("exit", (code, signal) => {
if (code !== null) {
this.error(`Server process exited with code ${code}.`, void 0, false);
}
if (signal !== null) {
this.error(`Server process exited with signal ${signal}.`, void 0, false);
}
});
}
});
}
_getRuntimePath(runtime, serverWorkingDirectory) {
if (path11.isAbsolute(runtime)) {
return runtime;
}
const mainRootPath = this._mainGetRootPath();
if (mainRootPath !== void 0) {
const result = path11.join(mainRootPath, runtime);
if (fs.existsSync(result)) {
return result;
}
}
if (serverWorkingDirectory !== void 0) {
const result = path11.join(serverWorkingDirectory, runtime);
if (fs.existsSync(result)) {
return result;
}
}
return runtime;
}
_mainGetRootPath() {
let folders = vscode_1.workspace.workspaceFolders;
if (!folders || folders.length === 0) {
return void 0;
}
let folder = folders[0];
if (folder.uri.scheme === "file") {
return folder.uri.fsPath;
}
return void 0;
}
_getServerWorkingDir(options) {
let cwd = options && options.cwd;
if (!cwd) {
cwd = this.clientOptions.workspaceFolder ? this.clientOptions.workspaceFolder.uri.fsPath : this._mainGetRootPath();
}
if (cwd) {
return new Promise((s) => {
fs.lstat(cwd, (err, stats) => {
s(!err && stats.isDirectory() ? cwd : void 0);
});
});
}
return Promise.resolve(void 0);
}
};
exports2.LanguageClient = LanguageClient8;
var SettingMonitor = class {
constructor(_client, _setting) {
this._client = _client;
this._setting = _setting;
this._listeners = [];
}
start() {
vscode_1.workspace.onDidChangeConfiguration(this.onDidChangeConfiguration, this, this._listeners);
this.onDidChangeConfiguration();
return new vscode_1.Disposable(() => {
if (this._client.needsStop()) {
void this._client.stop();
}
});
}
onDidChangeConfiguration() {
let index = this._setting.indexOf(".");
let primary = index >= 0 ? this._setting.substr(0, index) : this._setting;
let rest = index >= 0 ? this._setting.substr(index + 1) : void 0;
let enabled = rest ? vscode_1.workspace.getConfiguration(primary).get(rest, false) : vscode_1.workspace.getConfiguration(primary);
if (enabled && this._client.needsStart()) {
this._client.start().catch((error) => this._client.error("Start failed after configuration change", error, "force"));
} else if (!enabled && this._client.needsStop()) {
void this._client.stop().catch((error) => this._client.error("Stop failed after configuration change", error, "force"));
}
}
};
exports2.SettingMonitor = SettingMonitor;
function handleChildProcessStartError(process3, message) {
if (process3 === null) {
return Promise.reject(message);
}
return new Promise((_, reject) => {
process3.on("error", (err) => {
reject(`${message} ${err}`);
});
setImmediate(() => reject(message));
});
}
}
});
// node_modules/vscode-languageclient/node.js
var require_node3 = __commonJS({
"node_modules/vscode-languageclient/node.js"(exports2, module2) {
"use strict";
module2.exports = require_main4();
}
});
// node_modules/untildify/index.js
var require_untildify = __commonJS({
"node_modules/untildify/index.js"(exports2, module2) {
"use strict";
var os5 = require("os");
var homeDirectory = os5.homedir();
module2.exports = (pathWithTilde) => {
if (typeof pathWithTilde !== "string") {
throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
}
return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
};
}
});
// src/utils.ts
var utils_exports = {};
__export(utils_exports, {
PowerShellLanguageId: () => PowerShellLanguageId,
ShellIntegrationScript: () => ShellIntegrationScript,
checkIfDirectoryExists: () => checkIfDirectoryExists,
checkIfFileExists: () => checkIfFileExists,
escapeSingleQuotes: () => escapeSingleQuotes,
getPipePath: () => getPipePath,
getTimestampString: () => getTimestampString,
isLinux: () => isLinux,
isMacOS: () => isMacOS,
isWindows: () => isWindows,
readDirectory: () => readDirectory,
sleep: () => sleep,
stripQuotePair: () => stripQuotePair
});
function escapeSingleQuotes(p) {
return p.replace(new RegExp("'", "g"), "''");
}
function stripQuotePair(p) {
if (p === void 0) {
return p;
}
if (p.startsWith("'") && p.endsWith("'") || p.startsWith('"') && p.endsWith('"')) {
return p.slice(1, -1);
}
return p;
}
function getPipePath(pipeName) {
if (os.platform() === "win32") {
return "\\\\.\\pipe\\" + pipeName;
} else {
return path.join(os.tmpdir(), `CoreFxPipe_${pipeName}`);
}
}
async function checkIfFileOrDirectoryExists(targetPath, type) {
if (targetPath === "") {
return false;
}
try {
const stat = await vscode3.workspace.fs.stat(
targetPath instanceof vscode3.Uri ? targetPath : vscode3.Uri.file(targetPath)
);
return (stat.type & type) !== 0;
} catch {
return false;
}
}
async function checkIfFileExists(filePath) {
return await checkIfFileOrDirectoryExists(filePath, vscode3.FileType.File);
}
async function checkIfDirectoryExists(directoryPath) {
return await checkIfFileOrDirectoryExists(
directoryPath,
vscode3.FileType.Directory
);
}
async function readDirectory(directoryPath) {
const items = await vscode3.workspace.fs.readDirectory(
directoryPath instanceof vscode3.Uri ? directoryPath : vscode3.Uri.file(directoryPath)
);
return items.map(([name, _type]) => name);
}
function getTimestampString() {
const time = /* @__PURE__ */ new Date();
return `[${time.getHours()}:${time.getMinutes()}:${time.getSeconds()}]`;
}
function sleep(ms) {
return new Promise((resolve3) => setTimeout(resolve3, ms));
}
var os, path, vscode3, PowerShellLanguageId, ShellIntegrationScript, isMacOS, isWindows, isLinux;
var init_utils = __esm({
"src/utils.ts"() {
"use strict";
os = require("os");
path = require("path");
vscode3 = require("vscode");
PowerShellLanguageId = "powershell";
ShellIntegrationScript = path.join(
vscode3.env.appRoot,
"out",
"vs",
"workbench",
"contrib",
"terminal",
"common",
"scripts",
"shellIntegration.ps1"
);
isMacOS = process.platform === "darwin";
isWindows = process.platform === "win32";
isLinux = !isMacOS && !isWindows;
}
});
// node_modules/semver/functions/valid.js
var require_valid = __commonJS({
"node_modules/semver/functions/valid.js"(exports2, module2) {
"use strict";
var parse = require_parse();
var valid = (version, options) => {
const v = parse(version, options);
return v ? v.version : null;
};
module2.exports = valid;
}
});
// node_modules/semver/functions/clean.js
var require_clean = __commonJS({
"node_modules/semver/functions/clean.js"(exports2, module2) {
"use strict";
var parse = require_parse();
var clean = (version, options) => {
const s = parse(version.trim().replace(/^[=v]+/, ""), options);
return s ? s.version : null;
};
module2.exports = clean;
}
});
// node_modules/semver/functions/inc.js
var require_inc = __commonJS({
"node_modules/semver/functions/inc.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var inc = (version, release, options, identifier, identifierBase) => {
if (typeof options === "string") {
identifierBase = identifier;
identifier = options;
options = void 0;
}
try {
return new SemVer3(
version instanceof SemVer3 ? version.version : version,
options
).inc(release, identifier, identifierBase).version;
} catch (er) {
return null;
}
};
module2.exports = inc;
}
});
// node_modules/semver/functions/diff.js
var require_diff = __commonJS({
"node_modules/semver/functions/diff.js"(exports2, module2) {
"use strict";
var parse = require_parse();
var diff = (version1, version2) => {
const v1 = parse(version1, null, true);
const v2 = parse(version2, null, true);
const comparison = v1.compare(v2);
if (comparison === 0) {
return null;
}
const v1Higher = comparison > 0;
const highVersion = v1Higher ? v1 : v2;
const lowVersion = v1Higher ? v2 : v1;
const highHasPre = !!highVersion.prerelease.length;
const lowHasPre = !!lowVersion.prerelease.length;
if (lowHasPre && !highHasPre) {
if (!lowVersion.patch && !lowVersion.minor) {
return "major";
}
if (lowVersion.compareMain(highVersion) === 0) {
if (lowVersion.minor && !lowVersion.patch) {
return "minor";
}
return "patch";
}
}
const prefix = highHasPre ? "pre" : "";
if (v1.major !== v2.major) {
return prefix + "major";
}
if (v1.minor !== v2.minor) {
return prefix + "minor";
}
if (v1.patch !== v2.patch) {
return prefix + "patch";
}
return "prerelease";
};
module2.exports = diff;
}
});
// node_modules/semver/functions/major.js
var require_major = __commonJS({
"node_modules/semver/functions/major.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var major = (a, loose) => new SemVer3(a, loose).major;
module2.exports = major;
}
});
// node_modules/semver/functions/minor.js
var require_minor = __commonJS({
"node_modules/semver/functions/minor.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var minor = (a, loose) => new SemVer3(a, loose).minor;
module2.exports = minor;
}
});
// node_modules/semver/functions/patch.js
var require_patch = __commonJS({
"node_modules/semver/functions/patch.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var patch = (a, loose) => new SemVer3(a, loose).patch;
module2.exports = patch;
}
});
// node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
"node_modules/semver/functions/prerelease.js"(exports2, module2) {
"use strict";
var parse = require_parse();
var prerelease = (version, options) => {
const parsed = parse(version, options);
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
};
module2.exports = prerelease;
}
});
// node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
"node_modules/semver/functions/rcompare.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var rcompare = (a, b, loose) => compare(b, a, loose);
module2.exports = rcompare;
}
});
// node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
"node_modules/semver/functions/compare-loose.js"(exports2, module2) {
"use strict";
var compare = require_compare();
var compareLoose = (a, b) => compare(a, b, true);
module2.exports = compareLoose;
}
});
// node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
"node_modules/semver/functions/compare-build.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var compareBuild = (a, b, loose) => {
const versionA = new SemVer3(a, loose);
const versionB = new SemVer3(b, loose);
return versionA.compare(versionB) || versionA.compareBuild(versionB);
};
module2.exports = compareBuild;
}
});
// node_modules/semver/functions/sort.js
var require_sort = __commonJS({
"node_modules/semver/functions/sort.js"(exports2, module2) {
"use strict";
var compareBuild = require_compare_build();
var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
module2.exports = sort;
}
});
// node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
"node_modules/semver/functions/rsort.js"(exports2, module2) {
"use strict";
var compareBuild = require_compare_build();
var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
module2.exports = rsort;
}
});
// node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
"node_modules/semver/functions/coerce.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var parse = require_parse();
var { safeRe: re, t } = require_re();
var coerce = (version, options) => {
if (version instanceof SemVer3) {
return version;
}
if (typeof version === "number") {
version = String(version);
}
if (typeof version !== "string") {
return null;
}
options = options || {};
let match = null;
if (!options.rtl) {
match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
} else {
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
let next;
while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
if (!match || next.index + next[0].length !== match.index + match[0].length) {
match = next;
}
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
}
coerceRtlRegex.lastIndex = -1;
}
if (match === null) {
return null;
}
const major = match[2];
const minor = match[3] || "0";
const patch = match[4] || "0";
const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
};
module2.exports = coerce;
}
});
// node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
"node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
"use strict";
var Range5 = require_range();
var toComparators = (range, options) => new Range5(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
module2.exports = toComparators;
}
});
// node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
"node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var Range5 = require_range();
var maxSatisfying = (versions, range, options) => {
let max = null;
let maxSV = null;
let rangeObj = null;
try {
rangeObj = new Range5(range, options);
} catch (er) {
return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!max || maxSV.compare(v) === -1) {
max = v;
maxSV = new SemVer3(max, options);
}
}
});
return max;
};
module2.exports = maxSatisfying;
}
});
// node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
"node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var Range5 = require_range();
var minSatisfying = (versions, range, options) => {
let min = null;
let minSV = null;
let rangeObj = null;
try {
rangeObj = new Range5(range, options);
} catch (er) {
return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!min || minSV.compare(v) === 1) {
min = v;
minSV = new SemVer3(min, options);
}
}
});
return min;
};
module2.exports = minSatisfying;
}
});
// node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
"node_modules/semver/ranges/min-version.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var Range5 = require_range();
var gt = require_gt();
var minVersion = (range, loose) => {
range = new Range5(range, loose);
let minver = new SemVer3("0.0.0");
if (range.test(minver)) {
return minver;
}
minver = new SemVer3("0.0.0-0");
if (range.test(minver)) {
return minver;
}
minver = null;
for (let i = 0; i < range.set.length; ++i) {
const comparators = range.set[i];
let setMin = null;
comparators.forEach((comparator) => {
const compver = new SemVer3(comparator.semver.version);
switch (comparator.operator) {
case ">":
if (compver.prerelease.length === 0) {
compver.patch++;
} else {
compver.prerelease.push(0);
}
compver.raw = compver.format();
/* fallthrough */
case "":
case ">=":
if (!setMin || gt(compver, setMin)) {
setMin = compver;
}
break;
case "<":
case "<=":
break;
/* istanbul ignore next */
default:
throw new Error(`Unexpected operation: ${comparator.operator}`);
}
});
if (setMin && (!minver || gt(minver, setMin))) {
minver = setMin;
}
}
if (minver && range.test(minver)) {
return minver;
}
return null;
};
module2.exports = minVersion;
}
});
// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
"node_modules/semver/ranges/valid.js"(exports2, module2) {
"use strict";
var Range5 = require_range();
var validRange = (range, options) => {
try {
return new Range5(range, options).range || "*";
} catch (er) {
return null;
}
};
module2.exports = validRange;
}
});
// node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
"node_modules/semver/ranges/outside.js"(exports2, module2) {
"use strict";
var SemVer3 = require_semver();
var Comparator = require_comparator();
var { ANY } = Comparator;
var Range5 = require_range();
var satisfies2 = require_satisfies();
var gt = require_gt();
var lt = require_lt();
var lte = require_lte();
var gte = require_gte();
var outside = (version, range, hilo, options) => {
version = new SemVer3(version, options);
range = new Range5(range, options);
let gtfn, ltefn, ltfn, comp, ecomp;
switch (hilo) {
case ">":
gtfn = gt;
ltefn = lte;
ltfn = lt;
comp = ">";
ecomp = ">=";
break;
case "<":
gtfn = lt;
ltefn = gte;
ltfn = gt;
comp = "<";
ecomp = "<=";
break;
default:
throw new TypeError('Must provide a hilo val of "<" or ">"');
}
if (satisfies2(version, range, options)) {
return false;
}
for (let i = 0; i < range.set.length; ++i) {
const comparators = range.set[i];
let high = null;
let low = null;
comparators.forEach((comparator) => {
if (comparator.semver === ANY) {
comparator = new Comparator(">=0.0.0");
}
high = high || comparator;
low = low || comparator;
if (gtfn(comparator.semver, high.semver, options)) {
high = comparator;
} else if (ltfn(comparator.semver, low.semver, options)) {
low = comparator;
}
});
if (high.operator === comp || high.operator === ecomp) {
return false;
}
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
return false;
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
return false;
}
}
return true;
};
module2.exports = outside;
}
});
// node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
"node_modules/semver/ranges/gtr.js"(exports2, module2) {
"use strict";
var outside = require_outside();
var gtr = (version, range, options) => outside(version, range, ">", options);
module2.exports = gtr;
}
});
// node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
"node_modules/semver/ranges/ltr.js"(exports2, module2) {
"use strict";
var outside = require_outside();
var ltr = (version, range, options) => outside(version, range, "<", options);
module2.exports = ltr;
}
});
// node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
"node_modules/semver/ranges/intersects.js"(exports2, module2) {
"use strict";
var Range5 = require_range();
var intersects = (r1, r2, options) => {
r1 = new Range5(r1, options);
r2 = new Range5(r2, options);
return r1.intersects(r2, options);
};
module2.exports = intersects;
}
});
// node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
"node_modules/semver/ranges/simplify.js"(exports2, module2) {
"use strict";
var satisfies2 = require_satisfies();
var compare = require_compare();
module2.exports = (versions, range, options) => {
const set = [];
let first = null;
let prev = null;
const v = versions.sort((a, b) => compare(a, b, options));
for (const version of v) {
const included = satisfies2(version, range, options);
if (included) {
prev = version;
if (!first) {
first = version;
}
} else {
if (prev) {
set.push([first, prev]);
}
prev = null;
first = null;
}
}
if (first) {
set.push([first, null]);
}
const ranges = [];
for (const [min, max] of set) {
if (min === max) {
ranges.push(min);
} else if (!max && min === v[0]) {
ranges.push("*");
} else if (!max) {
ranges.push(`>=${min}`);
} else if (min === v[0]) {
ranges.push(`<=${max}`);
} else {
ranges.push(`${min} - ${max}`);
}
}
const simplified = ranges.join(" || ");
const original = typeof range.raw === "string" ? range.raw : String(range);
return simplified.length < original.length ? simplified : range;
};
}
});
// node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
"node_modules/semver/ranges/subset.js"(exports2, module2) {
"use strict";
var Range5 = require_range();
var Comparator = require_comparator();
var { ANY } = Comparator;
var satisfies2 = require_satisfies();
var compare = require_compare();
var subset = (sub, dom, options = {}) => {
if (sub === dom) {
return true;
}
sub = new Range5(sub, options);
dom = new Range5(dom, options);
let sawNonNull = false;
OUTER: for (const simpleSub of sub.set) {
for (const simpleDom of dom.set) {
const isSub = simpleSubset(simpleSub, simpleDom, options);
sawNonNull = sawNonNull || isSub !== null;
if (isSub) {
continue OUTER;
}
}
if (sawNonNull) {
return false;
}
}
return true;
};
var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
var minimumVersion = [new Comparator(">=0.0.0")];
var simpleSubset = (sub, dom, options) => {
if (sub === dom) {
return true;
}
if (sub.length === 1 && sub[0].semver === ANY) {
if (dom.length === 1 && dom[0].semver === ANY) {
return true;
} else if (options.includePrerelease) {
sub = minimumVersionWithPreRelease;
} else {
sub = minimumVersion;
}
}
if (dom.length === 1 && dom[0].semver === ANY) {
if (options.includePrerelease) {
return true;
} else {
dom = minimumVersion;
}
}
const eqSet = /* @__PURE__ */ new Set();
let gt, lt;
for (const c of sub) {
if (c.operator === ">" || c.operator === ">=") {
gt = higherGT(gt, c, options);
} else if (c.operator === "<" || c.operator === "<=") {
lt = lowerLT(lt, c, options);
} else {
eqSet.add(c.semver);
}
}
if (eqSet.size > 1) {
return null;
}
let gtltComp;
if (gt && lt) {
gtltComp = compare(gt.semver, lt.semver, options);
if (gtltComp > 0) {
return null;
} else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
return null;
}
}
for (const eq of eqSet) {
if (gt && !satisfies2(eq, String(gt), options)) {
return null;
}
if (lt && !satisfies2(eq, String(lt), options)) {
return null;
}
for (const c of dom) {
if (!satisfies2(eq, String(c), options)) {
return false;
}
}
return true;
}
let higher, lower;
let hasDomLT, hasDomGT;
let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
needDomLTPre = false;
}
for (const c of dom) {
hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
if (gt) {
if (needDomGTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
needDomGTPre = false;
}
}
if (c.operator === ">" || c.operator === ">=") {
higher = higherGT(gt, c, options);
if (higher === c && higher !== gt) {
return false;
}
} else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options)) {
return false;
}
}
if (lt) {
if (needDomLTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
needDomLTPre = false;
}
}
if (c.operator === "<" || c.operator === "<=") {
lower = lowerLT(lt, c, options);
if (lower === c && lower !== lt) {
return false;
}
} else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
return false;
}
}
if (!c.operator && (lt || gt) && gtltComp !== 0) {
return false;
}
}
if (gt && hasDomLT && !lt && gtltComp !== 0) {
return false;
}
if (lt && hasDomGT && !gt && gtltComp !== 0) {
return false;
}
if (needDomGTPre || needDomLTPre) {
return false;
}
return true;
};
var higherGT = (a, b, options) => {
if (!a) {
return b;
}
const comp = compare(a.semver, b.semver, options);
return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
};
var lowerLT = (a, b, options) => {
if (!a) {
return b;
}
const comp = compare(a.semver, b.semver, options);
return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
};
module2.exports = subset;
}
});
// node_modules/semver/index.js
var require_semver2 = __commonJS({
"node_modules/semver/index.js"(exports2, module2) {
"use strict";
var internalRe = require_re();
var constants = require_constants();
var SemVer3 = require_semver();
var identifiers = require_identifiers();
var parse = require_parse();
var valid = require_valid();
var clean = require_clean();
var inc = require_inc();
var diff = require_diff();
var major = require_major();
var minor = require_minor();
var patch = require_patch();
var prerelease = require_prerelease();
var compare = require_compare();
var rcompare = require_rcompare();
var compareLoose = require_compare_loose();
var compareBuild = require_compare_build();
var sort = require_sort();
var rsort = require_rsort();
var gt = require_gt();
var lt = require_lt();
var eq = require_eq();
var neq = require_neq();
var gte = require_gte();
var lte = require_lte();
var cmp = require_cmp();
var coerce = require_coerce();
var Comparator = require_comparator();
var Range5 = require_range();
var satisfies2 = require_satisfies();
var toComparators = require_to_comparators();
var maxSatisfying = require_max_satisfying();
var minSatisfying = require_min_satisfying();
var minVersion = require_min_version();
var validRange = require_valid2();
var outside = require_outside();
var gtr = require_gtr();
var ltr = require_ltr();
var intersects = require_intersects();
var simplifyRange = require_simplify();
var subset = require_subset();
module2.exports = {
parse,
valid,
clean,
inc,
diff,
major,
minor,
patch,
prerelease,
compare,
rcompare,
compareLoose,
compareBuild,
sort,
rsort,
gt,
lt,
eq,
neq,
gte,
lte,
cmp,
coerce,
Comparator,
Range: Range5,
satisfies: satisfies2,
toComparators,
maxSatisfying,
minSatisfying,
minVersion,
validRange,
outside,
gtr,
ltr,
intersects,
simplifyRange,
subset,
SemVer: SemVer3,
re: internalRe.re,
src: internalRe.src,
tokens: internalRe.t,
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
RELEASE_TYPES: constants.RELEASE_TYPES,
compareIdentifiers: identifiers.compareIdentifiers,
rcompareIdentifiers: identifiers.rcompareIdentifiers
};
}
});
// src/extension.ts
var extension_exports = {};
__export(extension_exports, {
activate: () => activate,
deactivate: () => deactivate
});
module.exports = __toCommonJS(extension_exports);
var import_extension_telemetry = __toESM(require_telemetryReporter());
var import_vscode_languageclient10 = __toESM(require_main4());
// src/features/CodeActions.ts
var vscode = require("vscode");
var CodeActionsFeature = class {
constructor(log) {
this.log = log;
this.command = vscode.commands.registerCommand(
"PowerShell.ShowCodeActionDocumentation",
async (ruleName) => {
await this.showRuleDocumentation(ruleName);
}
);
}
command;
dispose() {
this.command.dispose();
}
async showRuleDocumentation(ruleId) {
const pssaDocBaseURL = "https://docs.microsoft.com/powershell/utility-modules/psscriptanalyzer/rules/";
if (!ruleId) {
this.log.writeWarning(
"Cannot show documentation for code action, no ruleName was supplied."
);
return;
}
if (ruleId.startsWith("PS")) {
ruleId = ruleId.substring(2);
}
await vscode.commands.executeCommand(
"vscode.open",
vscode.Uri.parse(pssaDocBaseURL + ruleId)
);
}
};
// src/features/Console.ts
var import_vscode_languageclient = __toESM(require_main4());
var import_node2 = __toESM(require_node3());
// src/controls/checkboxQuickPick.ts
var vscode2 = require("vscode");
var confirmItemLabel = "$(checklist) Confirm";
var checkedPrefix = "[ $(check) ]";
var uncheckedPrefix = "[ ]";
var defaultPlaceHolder = "Select 'Confirm' to confirm or press 'Esc' key to cancel";
var defaultOptions = {
confirmPlaceHolder: defaultPlaceHolder
};
async function showCheckboxQuickPick(items, options = defaultOptions) {
const selectedItem = await showInner(items, options);
return selectedItem !== void 0 ? items : void 0;
}
function getQuickPickItems(items) {
const quickPickItems = [];
quickPickItems.push({ label: confirmItemLabel, description: "" });
for (const item of items) {
quickPickItems.push({
label: convertToCheckBox(item),
description: item.description
});
}
return quickPickItems;
}
async function showInner(items, options) {
const selection = await vscode2.window.showQuickPick(
getQuickPickItems(items),
{
ignoreFocusOut: true,
matchOnDescription: true,
placeHolder: options.confirmPlaceHolder
}
);
if (selection === void 0) {
return void 0;
}
if (selection.label === confirmItemLabel) {
return selection;
}
const index = getItemIndex(items, selection.label);
if (index >= 0) {
toggleSelection(items[index]);
} else {
console.log(
`Couldn't find CheckboxQuickPickItem for label '${selection.label}'`
);
}
return showInner(items, options);
}
function getItemIndex(items, itemLabel) {
const trimmedLabel = itemLabel.substring(itemLabel.indexOf("]") + 2);
return items.findIndex((item) => item.label === trimmedLabel);
}
function toggleSelection(item) {
item.isSelected = !item.isSelected;
}
function convertToCheckBox(item) {
return `${item.isSelected ? checkedPrefix : uncheckedPrefix} ${item.label}`;
}
// src/languageClientConsumer.ts
var import_vscode = require("vscode");
var import_node = __toESM(require_node3());
var LanguageClientConsumer = class _LanguageClientConsumer {
static languageClientPromise;
static getLanguageClientResolve;
// This is called in the session manager when the client is started (so we
// can wait for that). It's what actually resolves the promise.
static onLanguageClientStarted(languageClient) {
this.languageClientPromise ??= Promise.resolve(languageClient);
this.getLanguageClientResolve?.(languageClient);
}
// This is called in the session manager when the client exits so we can
// make a new promise.
static onLanguageClientExited() {
this.languageClientPromise = void 0;
this.getLanguageClientResolve = void 0;
}
// We should have a promise as defined in resetLanguageClient, but if we
// don't, create it.
static async getLanguageClient() {
_LanguageClientConsumer.languageClientPromise?.catch(() => {
_LanguageClientConsumer.languageClientPromise = void 0;
});
_LanguageClientConsumer.languageClientPromise ??= _LanguageClientConsumer.createLanguageClientPromise();
return _LanguageClientConsumer.languageClientPromise;
}
// This waits for the language client to start and shows a cancellable
// loading message. (It just wrap the static method below.)
static async createLanguageClientPromise() {
return import_vscode.window.withProgress(
{
location: import_vscode.ProgressLocation.Notification,
title: "Please wait, starting PowerShell Extension Terminal...",
cancellable: true
},
(_progress, token) => {
token.onCancellationRequested(() => {
void import_vscode.window.showErrorMessage(
"Cancelled PowerShell Extension Terminal start-up."
);
});
return new Promise((resolve3, reject) => {
_LanguageClientConsumer.getLanguageClientResolve = resolve3;
token.onCancellationRequested(() => {
reject(
new Error(
"Cancelled PowerShell Extension Terminal start-up."
)
);
});
});
}
);
}
};
// src/settings.ts
var import_untildify = __toESM(require_untildify());
var vscode4 = require("vscode");
var utils = (init_utils(), __toCommonJS(utils_exports));
var os2 = require("os");
var path2 = require("path");
var PartialSettings = class {
};
var Settings = class extends PartialSettings {
powerShellAdditionalExePaths = {};
powerShellDefaultVersion = "";
promptToUpdatePowerShell = true;
suppressAdditionalExeNotFoundWarning = false;
startAsLoginShell = new StartAsLoginShellSettings();
startAutomatically = true;
enableProfileLoading = true;
helpCompletion = "BlockComment" /* BlockComment */;
scriptAnalysis = new ScriptAnalysisSettings();
debugging = new DebuggingSettings();
developer = new DeveloperSettings();
codeFormatting = new CodeFormattingSettings();
integratedConsole = new IntegratedConsoleSettings();
sideBar = new SideBarSettings();
pester = new PesterSettings();
buttons = new ButtonSettings();
cwd = "";
// NOTE: use validateCwdSetting() instead of this directly!
enableReferencesCodeLens = true;
analyzeOpenDocumentsOnly = false;
// TODO: Add (deprecated) useX86Host (for testing)
};
var CodeFormattingSettings = class extends PartialSettings {
autoCorrectAliases = false;
avoidSemicolonsAsLineTerminators = false;
preset = "Custom" /* Custom */;
openBraceOnSameLine = true;
newLineAfterOpenBrace = true;
newLineAfterCloseBrace = true;
pipelineIndentationStyle = "NoIndentation" /* NoIndentation */;
whitespaceBeforeOpenBrace = true;
whitespaceBeforeOpenParen = true;
whitespaceAroundOperator = true;
whitespaceAfterSeparator = true;
whitespaceBetweenParameters = false;
whitespaceInsideBrace = true;
addWhitespaceAroundPipe = true;
trimWhitespaceAroundPipe = false;
ignoreOneLineBlock = true;
alignPropertyValuePairs = true;
useConstantStrings = false;
useCorrectCasing = false;
};
var ScriptAnalysisSettings = class extends PartialSettings {
enable = true;
settingsPath = "PSScriptAnalyzerSettings.psd1";
};
var DebuggingSettings = class extends PartialSettings {
createTemporaryIntegratedConsole = false;
executeMode = "DotSource" /* DotSource */;
};
var DeveloperSettings = class extends PartialSettings {
featureFlags = [];
// From `<root>/out/main.js` we go to the directory before <root> and
// then into the other repo.
bundledModulesPath = "../../PowerShellEditorServices/module";
editorServicesWaitForDebugger = false;
setExecutionPolicy = true;
waitForSessionFileTimeoutSeconds = 240;
};
var StartAsLoginShellSettings = class extends PartialSettings {
osx = true;
linux = false;
};
var IntegratedConsoleSettings = class extends PartialSettings {
showOnStartup = true;
startInBackground = false;
focusConsoleOnExecute = true;
useLegacyReadLine = false;
forceClearScrollbackBuffer = false;
suppressStartupBanner = false;
startLocation = "Panel" /* Panel */;
};
var SideBarSettings = class extends PartialSettings {
CommandExplorerVisibility = false;
CommandExplorerExcludeFilter = [];
};
var PesterSettings = class extends PartialSettings {
useLegacyCodeLens = true;
outputVerbosity = "FromPreference";
debugOutputVerbosity = "Diagnostic";
};
var ButtonSettings = class extends PartialSettings {
showRunButtons = true;
showPanelMovementButtons = false;
};
function getSetting(key, value, configuration) {
if (key !== void 0 && !(value instanceof PartialSettings)) {
return configuration.get(key, value);
}
for (const property in value) {
const subKey = key !== void 0 ? `${key}.${property}` : property;
value[property] = getSetting(subKey, value[property], configuration);
}
return value;
}
function getSettings() {
const configuration = vscode4.workspace.getConfiguration(utils.PowerShellLanguageId);
return getSetting(void 0, new Settings(), configuration);
}
function getEffectiveConfigurationTarget(settingName) {
const configuration = vscode4.workspace.getConfiguration(
utils.PowerShellLanguageId
);
const detail = configuration.inspect(settingName);
if (detail === void 0) {
return void 0;
} else if (typeof detail.workspaceFolderValue !== "undefined") {
return vscode4.ConfigurationTarget.WorkspaceFolder;
} else if (typeof detail.workspaceValue !== "undefined") {
return vscode4.ConfigurationTarget.Workspace;
} else if (typeof detail.globalValue !== "undefined") {
return vscode4.ConfigurationTarget.Global;
}
return void 0;
}
async function changeSetting(settingName, newValue, configurationTarget, logger2) {
logger2?.writeDebug(
`Changing '${settingName}' at scope '${configurationTarget}' to '${newValue}'.`
);
try {
const configuration = vscode4.workspace.getConfiguration(
utils.PowerShellLanguageId
);
await configuration.update(settingName, newValue, configurationTarget);
} catch (err) {
logger2?.writeError(`Failed to change setting: ${err}`);
}
}
var hasChosen = false;
var chosenWorkspace = void 0;
async function getChosenWorkspace(logger2) {
if (hasChosen) {
return chosenWorkspace;
}
if (vscode4.workspace.workspaceFolders === void 0 || vscode4.workspace.workspaceFolders.length === 0) {
chosenWorkspace = void 0;
} else if (vscode4.workspace.workspaceFolders.length === 1) {
chosenWorkspace = vscode4.workspace.workspaceFolders[0];
} else if (vscode4.workspace.workspaceFolders.length > 1) {
const options = {
placeHolder: "Select a workspace folder to use for the PowerShell Extension."
};
chosenWorkspace = await vscode4.window.showWorkspaceFolderPick(options);
logger2?.writeDebug(
`User selected workspace: '${chosenWorkspace?.name}'`
);
if (chosenWorkspace === void 0) {
chosenWorkspace = vscode4.workspace.workspaceFolders[0];
} else {
const response = await vscode4.window.showInformationMessage(
`Would you like to save this choice by setting this workspace's 'powershell.cwd' value to '${chosenWorkspace.name}'?`,
"Yes",
"No"
);
if (response === "Yes") {
await changeSetting(
"cwd",
chosenWorkspace.name,
vscode4.ConfigurationTarget.Workspace,
logger2
);
}
}
}
hasChosen = true;
return chosenWorkspace;
}
async function validateCwdSetting(logger2) {
let cwd = utils.stripQuotePair(
vscode4.workspace.getConfiguration(utils.PowerShellLanguageId).get("cwd")
) ?? "";
cwd = (0, import_untildify.default)(cwd);
if (path2.isAbsolute(cwd) && await utils.checkIfDirectoryExists(cwd)) {
return cwd;
}
if (vscode4.workspace.workspaceFolders) {
for (const workspaceFolder of vscode4.workspace.workspaceFolders) {
if (cwd === workspaceFolder.name) {
hasChosen = true;
chosenWorkspace = workspaceFolder;
cwd = "";
}
}
}
const workspace5 = await getChosenWorkspace(logger2);
if (workspace5 === void 0) {
logger2?.writeDebug("Workspace was undefined, using homedir!");
return os2.homedir();
}
const workspacePath = workspace5.uri.fsPath;
const relativePath = path2.join(workspacePath, cwd);
if (await utils.checkIfDirectoryExists(relativePath)) {
return relativePath;
}
if (await utils.checkIfDirectoryExists(workspacePath)) {
return workspacePath;
}
return os2.homedir();
}
// src/features/Console.ts
var vscode5 = require("vscode");
var EvaluateRequestType = new import_vscode_languageclient.RequestType("evaluate");
var OutputNotificationType = new import_vscode_languageclient.NotificationType("output");
var ShowChoicePromptRequestType = new import_vscode_languageclient.RequestType("powerShell/showChoicePrompt");
var ShowInputPromptRequestType = new import_vscode_languageclient.RequestType("powerShell/showInputPrompt");
function showChoicePrompt(promptDetails) {
let resultThenable;
if (!promptDetails.isMultiChoice) {
let quickPickItems = promptDetails.choices.map(
(choice) => {
return {
label: choice.label,
description: choice.helpMessage
};
}
);
if (promptDetails.defaultChoices.length > 0) {
const defaultChoice = promptDetails.defaultChoices[0];
if (defaultChoice > -1 && defaultChoice < promptDetails.choices.length) {
const defaultChoiceItem = quickPickItems[defaultChoice];
quickPickItems.splice(defaultChoice, 1);
quickPickItems = [defaultChoiceItem].concat(quickPickItems);
}
}
resultThenable = vscode5.window.showQuickPick(quickPickItems, {
placeHolder: promptDetails.message
}).then(onItemSelected);
} else {
const checkboxQuickPickItems = promptDetails.choices.map((choice) => {
return {
label: choice.label,
description: choice.helpMessage,
isSelected: false
};
});
for (const choice of promptDetails.defaultChoices) {
checkboxQuickPickItems[choice].isSelected = true;
}
resultThenable = showCheckboxQuickPick(checkboxQuickPickItems, {
confirmPlaceHolder: promptDetails.message
}).then(onItemsSelected);
}
return resultThenable;
}
async function showInputPrompt(promptDetails) {
const responseText = await vscode5.window.showInputBox({
placeHolder: promptDetails.name + ": "
});
return onInputEntered(responseText);
}
function onItemsSelected(chosenItems) {
if (chosenItems !== void 0) {
return {
promptCancelled: false,
responseText: chosenItems.filter((item) => item.isSelected).map((item) => item.label).join(", ")
};
} else {
return {
promptCancelled: true,
responseText: void 0
};
}
}
function onItemSelected(chosenItem) {
if (chosenItem !== void 0) {
return {
promptCancelled: false,
responseText: chosenItem.label
};
} else {
return {
promptCancelled: true,
responseText: void 0
};
}
}
function onInputEntered(responseText) {
if (responseText !== void 0) {
return {
promptCancelled: false,
responseText
};
} else {
return {
promptCancelled: true,
responseText: void 0
};
}
}
var ConsoleFeature = class extends LanguageClientConsumer {
constructor(logger2) {
super();
this.logger = logger2;
this.commands = [
vscode5.commands.registerCommand(
"PowerShell.RunSelection",
async () => {
if (vscode5.window.activeTerminal && vscode5.window.activeTerminal.name !== "PowerShell Extension") {
this.logger.write(
"PowerShell Extension Terminal is not active! Running in current terminal using 'runSelectedText'."
);
await vscode5.commands.executeCommand(
"workbench.action.terminal.runSelectedText"
);
vscode5.window.activeTerminal.show(
!getSettings().integratedConsole.focusConsoleOnExecute
);
await vscode5.commands.executeCommand(
"workbench.action.terminal.scrollToBottom"
);
return;
}
const editor = vscode5.window.activeTextEditor;
if (editor === void 0) {
return;
}
let selectionRange;
if (!editor.selection.isEmpty) {
selectionRange = new vscode5.Range(
editor.selection.start,
editor.selection.end
);
} else {
selectionRange = editor.document.lineAt(
editor.selection.start.line
).range;
}
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendRequest(EvaluateRequestType, {
expression: editor.document.getText(selectionRange)
});
await vscode5.commands.executeCommand(
"PowerShell.ShowSessionConsole",
true
);
await vscode5.commands.executeCommand(
"workbench.action.terminal.scrollToBottom"
);
}
)
];
}
commands;
handlers = [];
dispose() {
for (const command of this.commands) {
command.dispose();
}
for (const handler of this.handlers) {
handler.dispose();
}
}
onLanguageClientSet(languageClient) {
this.handlers = [
languageClient.onRequest(
ShowChoicePromptRequestType,
(promptDetails) => showChoicePrompt(promptDetails)
),
languageClient.onRequest(
ShowInputPromptRequestType,
(promptDetails) => showInputPrompt(promptDetails)
)
];
}
};
// src/features/DebugSession.ts
var import_path = __toESM(require("path"));
var import_vscode3 = require("vscode");
var import_vscode_languageclient3 = __toESM(require_main4());
var import_node4 = __toESM(require_node3());
// src/platform.ts
var os3 = __toESM(require("os"));
var path3 = __toESM(require("path"));
var process2 = __toESM(require("process"));
var import_untildify2 = __toESM(require_untildify());
var import_vscode_languageserver_protocol = __toESM(require_main3());
init_utils();
var vscode6 = require("vscode");
var WindowsPowerShell64BitLabel = "Windows PowerShell (x64)";
var WindowsPowerShell32BitLabel = "Windows PowerShell (x86)";
var LinuxExePath = "/usr/bin/pwsh";
var LinuxPreviewExePath = "/usr/bin/pwsh-preview";
var SnapExePath = "/snap/bin/pwsh";
var SnapPreviewExePath = "/snap/bin/pwsh-preview";
var MacOSExePath = "/usr/local/bin/pwsh";
var MacOSPreviewExePath = "/usr/local/bin/pwsh-preview";
var MacOSHomebrewExePath = "/opt/homebrew/bin/pwsh";
var MacOSHomebrewLTSExePath = "/opt/homebrew/bin/pwsh-lts";
var MacOSHomebrewPreviewExePath = "/opt/homebrew/bin/pwsh-preview";
var OperatingSystem = /* @__PURE__ */ ((OperatingSystem2) => {
OperatingSystem2[OperatingSystem2["Unknown"] = 0] = "Unknown";
OperatingSystem2[OperatingSystem2["Windows"] = 1] = "Windows";
OperatingSystem2[OperatingSystem2["MacOS"] = 2] = "MacOS";
OperatingSystem2[OperatingSystem2["Linux"] = 3] = "Linux";
return OperatingSystem2;
})(OperatingSystem || {});
function getPlatformDetails() {
let operatingSystem = 0 /* Unknown */;
if (process2.platform === "win32") {
operatingSystem = 1 /* Windows */;
} else if (process2.platform === "darwin") {
operatingSystem = 2 /* MacOS */;
} else if (process2.platform === "linux") {
operatingSystem = 3 /* Linux */;
}
const isProcess64Bit = process2.arch === "x64" || process2.arch === "arm64";
return {
operatingSystem,
isOS64Bit: isProcess64Bit || process2.env.PROCESSOR_ARCHITEW6432 !== void 0,
isProcess64Bit
};
}
var PowerShellExeFinder = class _PowerShellExeFinder {
/**
* Create a new PowerShellFinder object to discover PowerShell installations.
* @param platformDetails Information about the machine we are running on.
* @param additionalPowerShellExes Additional PowerShell installations as configured in the settings.
*/
constructor(platformDetails, additionalPowerShellExes, logger2) {
this.platformDetails = platformDetails;
this.additionalPowerShellExes = additionalPowerShellExes;
this.logger = logger2;
}
// This is required, since parseInt("7-preview") will return 7.
static IntRegex = /^\d+$/;
static PwshMsixRegex = /^Microsoft.PowerShell_.*/;
static PwshPreviewMsixRegex = /^Microsoft.PowerShellPreview_.*/;
winPS;
alternateBitnessWinPS;
/**
* Returns the first available PowerShell executable found in the search order.
*/
async getFirstAvailablePowerShellInstallation() {
for await (const pwsh of this.enumeratePowerShellInstallations()) {
return pwsh;
}
return void 0;
}
/**
* Get an array of all PowerShell executables found when searching for PowerShell installations.
*/
async getAllAvailablePowerShellInstallations() {
const array = [];
for await (const pwsh of this.enumeratePowerShellInstallations()) {
array.push(pwsh);
}
return array;
}
/**
* Fixes PowerShell paths when Windows PowerShell is set to the non-native bitness.
* @param configuredPowerShellPath the PowerShell path configured by the user.
*/
fixWindowsPowerShellPath(configuredPowerShellPath) {
const altWinPS = this.findWinPS({ useAlternateBitness: true });
if (!altWinPS) {
return configuredPowerShellPath;
}
const lowerAltWinPSPath = altWinPS.exePath.toLocaleLowerCase();
const lowerConfiguredPath = configuredPowerShellPath.toLocaleLowerCase();
if (lowerConfiguredPath === lowerAltWinPSPath) {
return this.findWinPS()?.exePath;
}
return configuredPowerShellPath;
}
/**
* Iterates through PowerShell installations on the machine according
* to configuration passed in through the constructor.
* PowerShell items returned by this object are verified
* to exist on the filesystem.
*/
async *enumeratePowerShellInstallations() {
for await (const defaultPwsh of this.enumerateDefaultPowerShellInstallations()) {
if (defaultPwsh && await defaultPwsh.exists()) {
yield defaultPwsh;
}
}
for await (const additionalPwsh of this.enumerateAdditionalPowerShellInstallations()) {
if (await additionalPwsh.exists()) {
yield additionalPwsh;
} else if (!additionalPwsh.suppressWarning) {
const message = `Additional PowerShell '${additionalPwsh.displayName}' not found at '${additionalPwsh.exePath}'!`;
this.logger?.writeWarning(message);
if (!getSettings().suppressAdditionalExeNotFoundWarning) {
const selection = await vscode6.window.showWarningMessage(
message,
"Don't Show Again"
);
if (selection !== void 0) {
await changeSetting(
"suppressAdditionalExeNotFoundWarning",
true,
true,
this.logger
);
}
}
}
}
}
/**
* Iterates through all the possible well-known PowerShell installations on a machine.
* Returned values may not exist, but come with an .exists property
* which will check whether the executable exists.
* TODO: We really need to define the order in which we search for stable/LTS/preview/daily
*/
async *enumerateDefaultPowerShellInstallations() {
yield this.findPSCoreStable();
switch (this.platformDetails.operatingSystem) {
case 3 /* Linux */:
yield this.findPSCoreStableSnap();
break;
case 1 /* Windows */:
yield this.findPSCoreWindowsInstallation({
useAlternateBitness: true
});
yield await this.findPSCoreMsix();
break;
case 2 /* MacOS */:
yield this.findPSCoreHomebrewStable();
yield this.findPSCoreHomebrewLTS();
break;
}
yield this.findPSCoreDotnetGlobalTool();
yield this.findPSCorePreview();
switch (this.platformDetails.operatingSystem) {
// On Linux, there might be a preview snap
case 3 /* Linux */:
yield this.findPSCorePreviewSnap();
break;
case 1 /* Windows */:
yield this.findPSCoreMsix({ findPreview: true });
yield this.findPSCoreWindowsInstallation({
useAlternateBitness: true,
findPreview: true
});
yield this.findWinPS();
yield this.findWinPS({ useAlternateBitness: true });
break;
case 2 /* MacOS */:
yield this.findPSCoreHomebrewPreview();
break;
}
yield this.findPSCoreDaily();
}
/**
* Iterates through the configured additional PowerShell executable locations,
* without checking for their existence.
*/
async *enumerateAdditionalPowerShellInstallations() {
for (const versionName in this.additionalPowerShellExes) {
if (Object.prototype.hasOwnProperty.call(
this.additionalPowerShellExes,
versionName
)) {
let exePath = stripQuotePair(
this.additionalPowerShellExes[versionName]
);
if (!exePath) {
continue;
}
exePath = (0, import_untildify2.default)(exePath);
const args = (
// Must be a tuple type and is suppressing the warning
[versionName, void 0, true, true]
);
let pwsh = new PossiblePowerShellExe(exePath, ...args);
if (await pwsh.exists()) {
yield pwsh;
continue;
}
if (this.platformDetails.operatingSystem === 1 /* Windows */) {
if (!exePath.endsWith("pwsh.exe") && !exePath.endsWith("powershell.exe")) {
if (exePath.endsWith("pwsh") || exePath.endsWith("powershell")) {
pwsh = new PossiblePowerShellExe(
exePath + ".exe",
...args
);
if (await pwsh.exists()) {
yield pwsh;
continue;
}
}
pwsh = new PossiblePowerShellExe(
path3.join(exePath, "pwsh.exe"),
...args
);
if (await pwsh.exists()) {
yield pwsh;
continue;
}
pwsh = new PossiblePowerShellExe(
path3.join(exePath, "powershell.exe"),
...args
);
if (await pwsh.exists()) {
yield pwsh;
continue;
}
}
} else if (!exePath.endsWith("pwsh")) {
pwsh = new PossiblePowerShellExe(
path3.join(exePath, "pwsh"),
...args
);
if (await pwsh.exists()) {
yield pwsh;
continue;
}
}
yield new PossiblePowerShellExe(
exePath,
versionName,
false,
void 0,
false
);
}
}
}
async findPSCoreStable() {
switch (this.platformDetails.operatingSystem) {
case 3 /* Linux */:
return new PossiblePowerShellExe(LinuxExePath, "PowerShell");
case 2 /* MacOS */:
return new PossiblePowerShellExe(MacOSExePath, "PowerShell");
case 1 /* Windows */:
return await this.findPSCoreWindowsInstallation();
case 0 /* Unknown */:
return void 0;
}
}
async findPSCorePreview() {
switch (this.platformDetails.operatingSystem) {
case 3 /* Linux */:
return new PossiblePowerShellExe(
LinuxPreviewExePath,
"PowerShell Preview"
);
case 2 /* MacOS */:
return new PossiblePowerShellExe(
MacOSPreviewExePath,
"PowerShell Preview"
);
case 1 /* Windows */:
return await this.findPSCoreWindowsInstallation({
findPreview: true
});
case 0 /* Unknown */:
return void 0;
}
}
/**
* If the daily was installed via 'https://aka.ms/install-powershell.ps1', then
* this is the default installation location:
*
* if ($IsWinEnv) {
* $Destination = "$env:LOCALAPPDATA\Microsoft\powershell"
* } else {
* $Destination = "~/.powershell"
* }
*
* if ($Daily) {
* $Destination = "${Destination}-daily"
* }
*
* TODO: Remove this after the daily is officially no longer supported.
*/
findPSCoreDaily() {
switch (this.platformDetails.operatingSystem) {
case 3 /* Linux */:
case 2 /* MacOS */: {
const exePath = path3.join(
os3.homedir(),
".powershell-daily",
"pwsh"
);
return new PossiblePowerShellExe(exePath, "PowerShell Daily");
}
case 1 /* Windows */: {
if (!process2.env.LOCALAPPDATA) {
return void 0;
}
const exePath = path3.join(
process2.env.LOCALAPPDATA,
"Microsoft",
"powershell-daily",
"pwsh.exe"
);
return new PossiblePowerShellExe(exePath, "PowerShell Daily");
}
case 0 /* Unknown */:
return void 0;
}
}
// The Homebrew installations of PowerShell on Apple Silicon are no longer in the default PATH.
findPSCoreHomebrewStable() {
return new PossiblePowerShellExe(
MacOSHomebrewExePath,
"PowerShell (Homebrew)"
);
}
findPSCoreHomebrewLTS() {
return new PossiblePowerShellExe(
MacOSHomebrewLTSExePath,
"PowerShell LTS (Homebrew)"
);
}
findPSCoreHomebrewPreview() {
return new PossiblePowerShellExe(
MacOSHomebrewPreviewExePath,
"PowerShell Preview (Homebrew)"
);
}
findPSCoreDotnetGlobalTool() {
const exeName = this.platformDetails.operatingSystem === 1 /* Windows */ ? "pwsh.exe" : "pwsh";
const dotnetGlobalToolExePath = path3.join(
os3.homedir(),
".dotnet",
"tools",
exeName
);
return new PossiblePowerShellExe(
dotnetGlobalToolExePath,
".NET Core PowerShell Global Tool",
void 0,
false
);
}
async findPSCoreMsix({
findPreview
} = {}) {
if (!process2.env.LOCALAPPDATA) {
return void 0;
}
const msixAppDir = path3.join(
process2.env.LOCALAPPDATA,
"Microsoft",
"WindowsApps"
);
if (!await checkIfDirectoryExists(msixAppDir)) {
return void 0;
}
const { pwshMsixDirRegex, pwshMsixName } = findPreview ? {
pwshMsixDirRegex: _PowerShellExeFinder.PwshPreviewMsixRegex,
pwshMsixName: "PowerShell Preview (Store)"
} : {
pwshMsixDirRegex: _PowerShellExeFinder.PwshMsixRegex,
pwshMsixName: "PowerShell (Store)"
};
for (const name of await readDirectory(msixAppDir)) {
if (pwshMsixDirRegex.test(name)) {
return new PossiblePowerShellExe(
path3.join(msixAppDir, name, "pwsh.exe"),
pwshMsixName
);
}
}
return void 0;
}
// TODO: Are snaps still a thing?
findPSCoreStableSnap() {
return new PossiblePowerShellExe(SnapExePath, "PowerShell Snap");
}
findPSCorePreviewSnap() {
return new PossiblePowerShellExe(
SnapPreviewExePath,
"PowerShell Preview Snap"
);
}
async findPSCoreWindowsInstallation({
useAlternateBitness = false,
findPreview = false
} = {}) {
const programFilesPath = this.getProgramFilesPath({
useAlternateBitness
});
if (!programFilesPath) {
return void 0;
}
const powerShellInstallBaseDir = path3.join(
programFilesPath,
"PowerShell"
);
if (!await checkIfDirectoryExists(powerShellInstallBaseDir)) {
return void 0;
}
let highestSeenVersion = -1;
let pwshExePath;
for (const item of await readDirectory(
powerShellInstallBaseDir
)) {
let currentVersion = -1;
if (findPreview) {
const dashIndex = item.indexOf("-");
if (dashIndex < 0) {
continue;
}
const intPart = item.substring(0, dashIndex);
if (!_PowerShellExeFinder.IntRegex.test(intPart)) {
continue;
}
if (item.substring(dashIndex + 1) !== "preview") {
continue;
}
currentVersion = parseInt(intPart, 10);
} else {
if (!_PowerShellExeFinder.IntRegex.test(item)) {
continue;
}
currentVersion = parseInt(item, 10);
}
if (currentVersion <= highestSeenVersion) {
continue;
}
const exePath = path3.join(
powerShellInstallBaseDir,
item,
"pwsh.exe"
);
if (!await checkIfFileExists(exePath)) {
continue;
}
pwshExePath = exePath;
highestSeenVersion = currentVersion;
}
if (!pwshExePath) {
return void 0;
}
const bitness = programFilesPath.includes("x86") ? "(x86)" : "(x64)";
const preview = findPreview ? " Preview" : "";
return new PossiblePowerShellExe(
pwshExePath,
`PowerShell${preview} ${bitness}`
);
}
findWinPS({
useAlternateBitness = false
} = {}) {
if (!this.platformDetails.isOS64Bit && useAlternateBitness) {
return void 0;
}
let winPS = useAlternateBitness ? this.alternateBitnessWinPS : this.winPS;
if (winPS === void 0) {
const systemFolderPath = this.getSystem32Path({
useAlternateBitness
});
if (!systemFolderPath) {
return void 0;
}
const winPSPath = path3.join(
systemFolderPath,
"WindowsPowerShell",
"v1.0",
"powershell.exe"
);
let displayName;
if (this.platformDetails.isProcess64Bit) {
displayName = useAlternateBitness ? WindowsPowerShell32BitLabel : WindowsPowerShell64BitLabel;
} else if (this.platformDetails.isOS64Bit) {
displayName = useAlternateBitness ? WindowsPowerShell64BitLabel : WindowsPowerShell32BitLabel;
} else {
displayName = WindowsPowerShell32BitLabel;
}
winPS = new PossiblePowerShellExe(winPSPath, displayName, true);
if (useAlternateBitness) {
this.alternateBitnessWinPS = winPS;
} else {
this.winPS = winPS;
}
}
return winPS;
}
getProgramFilesPath({
useAlternateBitness = false
} = {}) {
if (!useAlternateBitness) {
return process2.env.ProgramFiles;
}
if (this.platformDetails.isProcess64Bit) {
return process2.env["ProgramFiles(x86)"];
}
if (this.platformDetails.isOS64Bit) {
return process2.env.ProgramW6432;
}
return void 0;
}
getSystem32Path({
useAlternateBitness = false
} = {}) {
const windir = process2.env.windir;
if (!windir) {
return void 0;
}
if (!useAlternateBitness) {
return path3.join(windir, "System32");
}
if (this.platformDetails.isProcess64Bit) {
return path3.join(windir, "SysWOW64");
}
if (this.platformDetails.isOS64Bit) {
return path3.join(windir, "Sysnative");
}
return void 0;
}
};
var PossiblePowerShellExe = class {
constructor(exePath, displayName, knownToExist, supportsProperArguments = true, suppressWarning = false) {
this.exePath = exePath;
this.displayName = displayName;
this.knownToExist = knownToExist;
this.supportsProperArguments = supportsProperArguments;
this.suppressWarning = suppressWarning;
}
async exists() {
this.knownToExist ??= await checkIfFileExists(this.exePath);
return this.knownToExist ?? false;
}
};
// src/process.ts
var import_util = require("util");
var cp = require("child_process");
var path4 = require("path");
var vscode7 = require("vscode");
var utils2 = (init_utils(), __toCommonJS(utils_exports));
var PowerShellProcess = class _PowerShellProcess {
constructor(exePath, bundledModulesPath, isTemp, shellIntegrationEnabled, logger2, logDirectoryPath, startPsesArgs, sessionFilePath, sessionSettings, devMode = false) {
this.exePath = exePath;
this.bundledModulesPath = bundledModulesPath;
this.isTemp = isTemp;
this.shellIntegrationEnabled = shellIntegrationEnabled;
this.logger = logger2;
this.logDirectoryPath = logDirectoryPath;
this.startPsesArgs = startPsesArgs;
this.sessionFilePath = sessionFilePath;
this.sessionSettings = sessionSettings;
this.devMode = devMode;
this.onExitedEmitter = new vscode7.EventEmitter();
this.onExited = this.onExitedEmitter.event;
this.pidUpdateEmitter = new vscode7.EventEmitter();
}
static title = "PowerShell Extension";
onExited;
onExitedEmitter;
consoleTerminal;
consoleCloseSubscription;
pid;
pidUpdateEmitter;
async start(cancellationToken) {
const psesModulePath = path4.resolve(
__dirname,
this.bundledModulesPath,
"PowerShellEditorServices/PowerShellEditorServices.psd1"
);
const featureFlags = this.sessionSettings.developer.featureFlags.length > 0 ? this.sessionSettings.developer.featureFlags.map((f) => `'${f}'`).join(", ") : "";
this.startPsesArgs += `-LogPath '${utils2.escapeSingleQuotes(this.logDirectoryPath.fsPath)}' -SessionDetailsPath '${utils2.escapeSingleQuotes(this.sessionFilePath.fsPath)}' -FeatureFlags @(${featureFlags}) `;
if (this.sessionSettings.integratedConsole.useLegacyReadLine) {
this.startPsesArgs += "-UseLegacyReadLine";
}
const powerShellArgs = [];
const useLoginShell = utils2.isMacOS && this.sessionSettings.startAsLoginShell.osx || utils2.isLinux && this.sessionSettings.startAsLoginShell.linux;
if (useLoginShell && this.isLoginShell(this.exePath)) {
powerShellArgs.push("-Login");
}
powerShellArgs.push("-NoProfile");
if (utils2.isWindows && this.sessionSettings.developer.setExecutionPolicy) {
powerShellArgs.push("-ExecutionPolicy", "Bypass");
}
const startEditorServices = "Import-Module '" + utils2.escapeSingleQuotes(psesModulePath) + "'; Start-EditorServices " + this.startPsesArgs;
if (utils2.isWindows) {
powerShellArgs.push("-Command", startEditorServices);
} else {
this.logger.writeDebug(
"Using Base64 -EncodedCommand but logging as -Command equivalent."
);
powerShellArgs.push(
"-EncodedCommand",
Buffer.from(startEditorServices, "utf16le").toString("base64")
);
}
this.logger.writeDebug(
`Starting process: ${this.exePath} ${powerShellArgs.slice(0, -2).join(" ")} -Command ${startEditorServices}`
);
await this.deleteSessionFile(this.sessionFilePath);
let envMixin = {};
if (this.shellIntegrationEnabled) {
envMixin = {
VSCODE_INJECTION: "1",
// There is no great way to check if we are running stable VS
// Code. Since this is used to disable experimental features, we
// default to stable unless we're definitely running Insiders.
VSCODE_STABLE: vscode7.env.appName.includes("Insiders") ? "0" : "1"
// Maybe one day we can set VSCODE_NONCE...
};
}
if (this.devMode) {
envMixin.COMPLUS_FORCEENC = "1";
}
const terminalOptions = {
name: this.isTemp ? `${_PowerShellProcess.title} (TEMP)` : _PowerShellProcess.title,
shellPath: this.exePath,
shellArgs: powerShellArgs,
cwd: await validateCwdSetting(this.logger),
env: envMixin,
iconPath: new vscode7.ThemeIcon("terminal-powershell"),
isTransient: true,
hideFromUser: this.sessionSettings.integratedConsole.startInBackground,
location: vscode7.TerminalLocation[this.sessionSettings.integratedConsole.startLocation]
};
this.consoleCloseSubscription = vscode7.window.onDidCloseTerminal(
(terminal) => {
this.onTerminalClose(terminal);
}
);
this.consoleTerminal = vscode7.window.createTerminal(terminalOptions);
this.pid = await this.getPid();
this.logger.write(`PowerShell process started with PID: ${this.pid}`);
this.pidUpdateEmitter?.fire(this.pid);
if (this.sessionSettings.integratedConsole.showOnStartup && !this.sessionSettings.integratedConsole.startInBackground) {
this.consoleTerminal.show(true);
}
return await this.waitForSessionFile(cancellationToken);
}
// This function is used to clean-up stale PowerShell Extension terminals,
// which can happen with `restartExtensionHost` is called because we are
// unable to finish diposing before we're gone.
static cleanUpTerminals() {
for (const terminal of vscode7.window.terminals) {
if (terminal.name.startsWith(_PowerShellProcess.title)) {
terminal.dispose();
}
}
}
// This function should only be used after a failure has occurred because it is slow!
async getVersionCli() {
const exec = (0, import_util.promisify)(cp.execFile);
const { stdout } = await exec(this.exePath, [
"-NoProfile",
"-NoLogo",
"-Command",
"$PSVersionTable.PSVersion.ToString()"
]);
return stdout.trim();
}
// Returns the process Id of the consoleTerminal
async getPid() {
return await this.consoleTerminal?.processId;
}
showTerminal(preserveFocus) {
this.consoleTerminal?.show(preserveFocus);
}
dispose() {
this.logger.writeDebug(
`Disposing PowerShell process with PID: ${this.pid}`
);
void this.deleteSessionFile(this.sessionFilePath);
this.onExitedEmitter?.fire();
this.onExitedEmitter = void 0;
this.consoleTerminal?.dispose();
this.consoleTerminal = void 0;
this.consoleCloseSubscription?.dispose();
this.consoleCloseSubscription = void 0;
this.pidUpdateEmitter?.dispose();
this.pidUpdateEmitter = void 0;
}
sendKeyPress() {
this.consoleTerminal?.sendText("p", false);
}
isLoginShell(pwshPath) {
try {
cp.execFileSync(pwshPath, [
"-Login",
"-NoProfile",
"-NoLogo",
"-Command",
"exit 0"
]);
} catch {
return false;
}
return true;
}
async readSessionFile(sessionFilePath) {
const fileContents = await vscode7.workspace.fs.readFile(sessionFilePath);
return JSON.parse(fileContents.toString());
}
async deleteSessionFile(sessionFilePath) {
try {
await vscode7.workspace.fs.delete(sessionFilePath);
} catch {
}
}
async waitForSessionFile(cancellationToken) {
const numOfTries = (
// We sleep for 1/5 of a second each try
5 * this.sessionSettings.developer.waitForSessionFileTimeoutSeconds
);
const warnAt = numOfTries - 5 * 30;
this.logger.writeDebug(
`Waiting for session file: ${this.sessionFilePath}`
);
for (let i = numOfTries; i > 0; i--) {
if (cancellationToken.isCancellationRequested) {
this.logger.writeWarning(
"Canceled while waiting for session file."
);
return void 0;
}
if (this.consoleTerminal === void 0) {
this.logger.writeError("Extension Terminal is undefined.");
return void 0;
}
if (await utils2.checkIfFileExists(this.sessionFilePath)) {
this.logger.writeDebug("Session file found.");
return await this.readSessionFile(this.sessionFilePath);
}
if (warnAt === i) {
void this.logger.writeAndShowWarning(
"Loading the PowerShell extension is taking longer than expected. If you're using privilege enforcement software, this can affect start up performance."
);
}
await utils2.sleep(200);
}
this.logger.writeError("Timed out waiting for session file!");
return void 0;
}
onTerminalClose(terminal) {
if (terminal !== this.consoleTerminal) {
return;
}
this.logger.writeWarning(
`PowerShell process terminated or Extension Terminal was closed, PID: ${this.pid}`
);
this.dispose();
}
};
// src/session.ts
var import_vscode_jsonrpc = __toESM(require_main());
// src/logging.ts
var import_vscode2 = require("vscode");
var Logger = class {
// Log output channel handles all the verbosity management so we don't have to.
logChannel;
get logLevel() {
return this.logChannel.logLevel;
}
constructor(logChannel) {
this.logChannel = logChannel ?? import_vscode2.window.createOutputChannel("PowerShell", { log: true });
}
dispose() {
this.logChannel.dispose();
}
writeAtLevel(logLevel, message, ...additionalMessages) {
if (logLevel >= this.logLevel) {
void this.writeLine(message, logLevel);
for (const additionalMessage of additionalMessages) {
void this.writeLine(additionalMessage, logLevel);
}
}
}
write(message, ...additionalMessages) {
this.writeAtLevel(import_vscode2.LogLevel.Info, message, ...additionalMessages);
}
async writeAndShowInformation(message, ...additionalMessages) {
this.write(message, ...additionalMessages);
const selection = await import_vscode2.window.showInformationMessage(
message,
"Show Logs",
"Okay"
);
if (selection === "Show Logs") {
this.showLogPanel();
}
}
writeTrace(message, ...additionalMessages) {
this.writeAtLevel(import_vscode2.LogLevel.Trace, message, ...additionalMessages);
}
writeDebug(message, ...additionalMessages) {
this.writeAtLevel(import_vscode2.LogLevel.Debug, message, ...additionalMessages);
}
writeWarning(message, ...additionalMessages) {
this.writeAtLevel(import_vscode2.LogLevel.Warning, message, ...additionalMessages);
}
async writeAndShowWarning(message, ...additionalMessages) {
this.writeWarning(message, ...additionalMessages);
const selection = await import_vscode2.window.showWarningMessage(message, "Show Logs");
if (selection !== void 0) {
this.showLogPanel();
}
}
writeError(message, ...additionalMessages) {
this.writeAtLevel(import_vscode2.LogLevel.Error, message, ...additionalMessages);
}
async writeAndShowError(message, ...additionalMessages) {
this.writeError(message, ...additionalMessages);
const choice = await import_vscode2.window.showErrorMessage(message, "Show Logs");
if (choice !== void 0) {
this.showLogPanel();
}
}
async writeAndShowErrorWithActions(message, actions) {
this.writeError(message);
const fullActions = [
...actions,
{
prompt: "Show Logs",
action: () => {
this.showLogPanel();
}
}
];
const actionKeys = fullActions.map((action) => action.prompt);
const choice = await import_vscode2.window.showErrorMessage(message, ...actionKeys);
if (choice) {
for (const action of fullActions) {
if (choice === action.prompt && action.action !== void 0) {
await action.action();
return;
}
}
}
}
showLogPanel() {
this.logChannel.show();
}
async writeLine(message, level = import_vscode2.LogLevel.Info) {
return new Promise((resolve3) => {
switch (level) {
case import_vscode2.LogLevel.Off:
break;
case import_vscode2.LogLevel.Trace:
this.logChannel.trace(message);
break;
case import_vscode2.LogLevel.Debug:
this.logChannel.debug(message);
break;
case import_vscode2.LogLevel.Info:
this.logChannel.info(message);
break;
case import_vscode2.LogLevel.Warning:
this.logChannel.warn(message);
break;
case import_vscode2.LogLevel.Error:
this.logChannel.error(message);
break;
default:
this.logChannel.appendLine(message);
break;
}
resolve3();
});
}
};
var LanguageClientOutputChannelAdapter = class _LanguageClientOutputChannelAdapter {
/**
* Creates an instance of the logging class.
*
* @param channelName - The name of the output channel.
* @param parser - A function that parses a log message and returns a tuple containing the parsed message and its log level, or undefined if the log should be filtered.
*/
constructor(channelName, parser = _LanguageClientOutputChannelAdapter.omnisharpLspParser.bind(
this
)) {
this.channelName = channelName;
this.parser = parser;
}
_channel;
get channel() {
this._channel ??= import_vscode2.window.createOutputChannel(this.channelName, {
log: true
});
return this._channel;
}
appendLine(message) {
this.append(message);
}
append(message) {
const parseResult = this.parser(message);
if (parseResult !== void 0) {
this.sendLogMessage(...parseResult);
}
}
/** Converts from Omnisharp logs since middleware for LogMessage does not currently exist **/
static omnisharpLspParser(message) {
const logLevelMatch = /^\[(?<level>Trace|Debug|Info|Warn|Error) +- \d+:\d+:\d+ [AP]M\] (?<message>.+)/.exec(
message
);
const logLevel = logLevelMatch?.groups?.level ? import_vscode2.LogLevel[logLevelMatch.groups.level] : import_vscode2.LogLevel.Info;
const logMessage = logLevelMatch?.groups?.message ?? message;
return [logMessage, logLevel];
}
sendLogMessage(message, level) {
switch (level) {
case import_vscode2.LogLevel.Trace:
this.channel.trace(message);
break;
case import_vscode2.LogLevel.Debug:
this.channel.debug(message);
break;
case import_vscode2.LogLevel.Info:
this.channel.info(message);
break;
case import_vscode2.LogLevel.Warning:
this.channel.warn(message);
break;
case import_vscode2.LogLevel.Error:
this.channel.error(message);
break;
default:
this.channel.error("!UNKNOWN LOG LEVEL!: " + message);
break;
}
}
// #region Passthru Implementation
get name() {
return this.channelName;
}
get logLevel() {
return this.channel.logLevel;
}
replace(value) {
this.channel.replace(value);
}
show(_column, preserveFocus) {
this.channel.show(preserveFocus);
}
get onDidChangeLogLevel() {
return this.channel.onDidChangeLogLevel;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
trace(message, ...args) {
this.channel.trace(message, ...args);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
debug(message, ...args) {
this.channel.debug(message, ...args);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
info(message, ...args) {
this.channel.info(message, ...args);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
warn(message, ...args) {
this.channel.warn(message, ...args);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
error(message, ...args) {
this.channel.error(message, ...args);
}
clear() {
this.channel.clear();
}
hide() {
this.channel.hide();
}
dispose() {
this.channel.dispose();
}
// #endregion
};
function PsesParser(message) {
const logLevelMatch = /^<(?<level>Trace|Debug|Info|Warning|Error)>(?<message>.+)/.exec(
message
);
const logLevel = logLevelMatch?.groups?.level ? import_vscode2.LogLevel[logLevelMatch.groups.level] : import_vscode2.LogLevel.Info;
const logMessage = logLevelMatch?.groups?.message ?? message;
return ["[PSES] " + logMessage, logLevel];
}
function LspTraceParser(message) {
let [parsedMessage, level] = LanguageClientOutputChannelAdapter.omnisharpLspParser(message);
if (parsedMessage.startsWith("Sending ")) {
parsedMessage = parsedMessage.replace("Sending", "\u27A1\uFE0F");
level = import_vscode2.LogLevel.Debug;
}
if (parsedMessage.startsWith("Received ")) {
parsedMessage = parsedMessage.replace("Received", "\u2B05\uFE0F");
level = import_vscode2.LogLevel.Debug;
}
if (parsedMessage.startsWith("Params:") || parsedMessage.startsWith("Result:")) {
level = import_vscode2.LogLevel.Trace;
}
if (parsedMessage.startsWith("\u2B05\uFE0F notification 'window/logMessage'")) {
level = import_vscode2.LogLevel.Trace;
}
return [parsedMessage.trimEnd(), level];
}
// src/session.ts
var import_vscode_languageclient2 = __toESM(require_main4());
var import_node3 = __toESM(require_node3());
var import_semver2 = __toESM(require_semver2());
// src/features/UpdatePowerShell.ts
var import_semver = __toESM(require_semver2());
var vscode8 = require("vscode");
var UpdatePowerShell = class _UpdatePowerShell {
constructor(sessionSettings, logger2, versionDetails) {
this.sessionSettings = sessionSettings;
this.logger = logger2;
this.localVersion = new import_semver.SemVer(versionDetails.commit);
}
static LTSBuildInfoURL = "https://aka.ms/pwsh-buildinfo-lts";
static StableBuildInfoURL = "https://aka.ms/pwsh-buildinfo-stable";
static PreviewBuildInfoURL = "https://aka.ms/pwsh-buildinfo-preview";
static GitHubWebReleaseURL = "https://github.com/PowerShell/PowerShell/releases/tag/";
static promptOptions = [
{
id: 0,
title: "Yes"
},
{
id: 1,
title: "Not Now"
},
{
id: 2,
title: "Don't Show Again"
}
];
localVersion;
shouldCheckForUpdate() {
if (!this.sessionSettings.promptToUpdatePowerShell) {
this.logger.writeDebug(
"Setting 'promptToUpdatePowerShell' was false."
);
return false;
}
if (process.env.POWERSHELL_UPDATECHECK?.toLowerCase() === "off") {
this.logger.writeDebug(
"Environment variable 'POWERSHELL_UPDATECHECK' was 'Off'."
);
return false;
}
if (this.localVersion.compare("6.0.0") === -1) {
this.logger.writeDebug(
"Not prompting to update Windows PowerShell."
);
return false;
}
if (this.localVersion.prerelease.length > 1) {
const daily = this.localVersion.prerelease[0].toString();
const commit = this.localVersion.prerelease[1].toString();
if (commit.length >= 40) {
this.logger.writeDebug(
"Not prompting to update development build."
);
return false;
}
if (daily.toLowerCase().startsWith("daily")) {
this.logger.writeDebug("Not prompting to update daily build.");
return false;
}
}
return true;
}
async getRemoteVersion(url) {
const response = await fetch(url);
if (!response.ok) {
return void 0;
}
const data = await response.json();
this.logger.writeDebug(
`Received from '${url}':
${JSON.stringify(data, void 0, 2)}`
);
return data.ReleaseTag;
}
async maybeGetNewRelease() {
if (!this.shouldCheckForUpdate()) {
return void 0;
}
this.logger.writeDebug("Checking for PowerShell update...");
const tags = [];
if (process.env.POWERSHELL_UPDATECHECK?.toLowerCase() === "lts") {
this.logger.writeDebug("Checking for LTS update...");
const tag = await this.getRemoteVersion(
_UpdatePowerShell.LTSBuildInfoURL
);
if (tag != void 0) {
tags.push(tag);
}
} else {
this.logger.writeDebug("Checking for stable update...");
const tag = await this.getRemoteVersion(
_UpdatePowerShell.StableBuildInfoURL
);
if (tag != void 0) {
tags.push(tag);
}
if (this.localVersion.prerelease.length > 0) {
this.logger.writeDebug("Checking for preview update...");
const tag2 = await this.getRemoteVersion(
_UpdatePowerShell.PreviewBuildInfoURL
);
if (tag2 != void 0) {
tags.push(tag2);
}
}
}
for (const tag of tags) {
if (this.localVersion.compare(tag) === -1) {
return tag;
}
}
this.logger.write("PowerShell is up-to-date.");
return void 0;
}
async checkForUpdate() {
try {
const tag = await this.maybeGetNewRelease();
if (tag) {
await this.promptToUpdate(tag);
return;
}
} catch (err) {
this.logger.writeWarning(
err instanceof Error ? err.message : "unknown"
);
}
}
async openReleaseInBrowser(tag) {
const url = vscode8.Uri.parse(
_UpdatePowerShell.GitHubWebReleaseURL + tag
);
await vscode8.env.openExternal(url);
}
async promptToUpdate(tag) {
const releaseVersion = new import_semver.SemVer(tag);
this.logger.write(
`Prompting to update PowerShell v${this.localVersion.version} to v${releaseVersion.version}.`
);
const result = await vscode8.window.showInformationMessage(
`PowerShell v${this.localVersion.version} is out-of-date.
The latest version is v${releaseVersion.version}.
Would you like to open the GitHub release in your browser?`,
..._UpdatePowerShell.promptOptions
);
if (!result) {
this.logger.writeDebug("User canceled PowerShell update prompt.");
return;
}
this.logger.writeDebug(
`User said '${_UpdatePowerShell.promptOptions[result.id].title}'.`
);
switch (result.id) {
// Yes
case 0:
await this.openReleaseInBrowser(tag);
break;
// Not Now
case 1:
break;
// Don't Show Again
case 2:
await changeSetting(
"promptToUpdatePowerShell",
false,
true,
this.logger
);
break;
default:
break;
}
}
};
// src/session.ts
var net = require("net");
var path5 = require("path");
var vscode9 = require("vscode");
var utils3 = (init_utils(), __toCommonJS(utils_exports));
var SendKeyPressNotificationType = new import_vscode_languageclient2.NotificationType(
"powerShell/sendKeyPress"
);
var ExecutionBusyStatusNotificationType = new import_vscode_languageclient2.NotificationType("powerShell/executionBusyStatus");
var PowerShellVersionRequestType = new import_vscode_languageclient2.RequestType0("powerShell/getVersion");
var SessionManager = class {
constructor(extensionContext, sessionSettings, logger2, documentSelector2, hostName, displayName, hostVersion, publisher, telemetryReporter2) {
this.extensionContext = extensionContext;
this.sessionSettings = sessionSettings;
this.logger = logger2;
this.documentSelector = documentSelector2;
this.telemetryReporter = telemetryReporter2;
this.languageStatusItem = this.createStatusBarItem();
this.sessionsFolder = vscode9.Uri.joinPath(
extensionContext.globalStorageUri.with({ scheme: "file" }),
"sessions"
);
this.platformDetails = getPlatformDetails();
this.HostName = hostName;
this.DisplayName = displayName;
this.HostVersion = hostVersion;
this.Publisher = publisher;
const osBitness = this.platformDetails.isOS64Bit ? "64-bit" : "32-bit";
const procBitness = this.platformDetails.isProcess64Bit ? "64-bit" : "32-bit";
this.logger.write(
`Visual Studio Code: v${vscode9.version} ${procBitness} on ${OperatingSystem[this.platformDetails.operatingSystem]} ${osBitness}`,
`${this.DisplayName} Extension: v${this.HostVersion}`
);
this.HostVersion = this.HostVersion.split("-")[0];
this.registerCommands();
}
HostName;
DisplayName;
HostVersion;
Publisher;
PowerShellExeDetails;
ShowSessionMenuCommandName = "PowerShell.ShowSessionMenu";
debugEventHandler;
debugSessionProcess;
languageClient;
languageClientConsumers = [];
languageServerProcess;
languageStatusItem;
platformDetails;
registeredCommands = [];
registeredHandlers = [];
sessionDetails;
sessionsFolder;
sessionStatus = "Not Started" /* NotStarted */;
shellIntegrationEnabled = false;
startCancellationTokenSource;
suppressRestartPrompt = false;
versionDetails;
traceLogLevelHandler;
async dispose() {
await this.stop();
this.languageStatusItem.dispose();
for (const handler of this.registeredHandlers) {
handler.dispose();
}
for (const command of this.registeredCommands) {
command.dispose();
}
}
// The `exeNameOverride` is used by `restartSession` to override ANY other setting.
// We've made this function idempotent, so it can used to ensure the session has started.
async start() {
switch (this.sessionStatus) {
case "Not Started" /* NotStarted */:
break;
case "Starting" /* Starting */:
this.logger.writeWarning("Re-entered 'start' so waiting...");
await this.waitWhileStarting();
return;
case "Running" /* Running */:
this.logger.writeDebug("Already started.");
return;
case "Busy" /* Busy */:
this.logger.write(
"The Extension Terminal is currently busy, please wait for your task to finish!"
);
return;
case "Stopping" /* Stopping */:
this.logger.writeDebug("Still stopping.");
await this.waitWhileStopping();
break;
case "Failed" /* Failed */:
this.logger.writeDebug("Previously failed, starting again.");
break;
}
this.setSessionStatus("Starting...", "Starting" /* Starting */);
this.startCancellationTokenSource = new vscode9.CancellationTokenSource();
const cancellationToken = this.startCancellationTokenSource.token;
await vscode9.workspace.fs.createDirectory(this.sessionsFolder);
await this.migrateWhitespaceAroundPipeSetting();
this.shellIntegrationEnabled = vscode9.workspace.getConfiguration("terminal.integrated.shellIntegration").get("enabled") ?? false;
this.PowerShellExeDetails = await this.findPowerShell();
if (this.PowerShellExeDetails === void 0) {
const message = "Unable to find PowerShell! Do you have it installed? You can also configure custom installations with the 'powershell.powerShellAdditionalExePaths' setting.";
void this.setSessionFailedGetPowerShell(message);
return;
}
this.refreshSessionStatus();
this.logger.write(
`Starting '${this.PowerShellExeDetails.displayName}' at: ${this.PowerShellExeDetails.exePath}`
);
this.languageServerProcess = await this.startLanguageServerProcess(
this.PowerShellExeDetails,
cancellationToken
);
if (this.sessionDetails === void 0 || !this.sessionStarted(this.sessionDetails)) {
if (!cancellationToken.isCancellationRequested) {
await this.handleFailedProcess(this.languageServerProcess);
}
this.languageServerProcess.dispose();
this.languageServerProcess = void 0;
return;
}
this.languageClient = await this.startLanguageClient(
this.sessionDetails
);
if (this.languageClient.isRunning()) {
this.versionDetails = await this.getVersionDetails();
if (this.versionDetails === void 0) {
void this.setSessionFailedOpenBug(
"Unable to get version details!"
);
return;
}
this.logger.write(
`Started PowerShell v${this.versionDetails.version}.`
);
this.setSessionRunningStatus();
await this.writePidIfInDevMode(this.languageServerProcess);
const updater = new UpdatePowerShell(
this.sessionSettings,
this.logger,
this.versionDetails
);
void updater.checkForUpdate();
} else {
void this.setSessionFailedOpenBug("Never finished startup!");
}
}
async stop() {
this.setSessionStatus("Stopping...", "Stopping" /* Stopping */);
this.startCancellationTokenSource?.cancel();
try {
await this.languageClient?.stop(2e3);
await this.languageClient?.dispose();
} catch (err) {
this.logger.writeError(
`Error occurred while stopping language client:
${err}`
);
}
this.languageClient = void 0;
this.debugSessionProcess?.dispose();
this.debugSessionProcess = void 0;
this.debugEventHandler?.dispose();
this.debugEventHandler = void 0;
this.languageServerProcess?.dispose();
this.languageServerProcess = void 0;
this.startCancellationTokenSource?.dispose();
this.startCancellationTokenSource = void 0;
this.sessionDetails = void 0;
this.traceLogLevelHandler?.dispose();
this.traceLogLevelHandler = void 0;
this.setSessionStatus("Not Started", "Not Started" /* NotStarted */);
}
async restartSession(exeNameOverride) {
this.logger.write("Restarting session...");
await this.stop();
this.sessionSettings = getSettings();
if (exeNameOverride) {
this.logger.writeDebug(
`Starting with executable overriden to: ${exeNameOverride}`
);
this.sessionSettings.powerShellDefaultVersion = exeNameOverride;
this.versionDetails = void 0;
this.PowerShellExeDetails = void 0;
}
await this.start();
}
/** In Development mode, write the PID to a file where the parent session can find it, to attach the dotnet debugger. */
async writePidIfInDevMode(pwshProcess) {
if (this.extensionContext.extensionMode !== vscode9.ExtensionMode.Development) {
return;
}
const parentSessionId = process.env.VSCODE_PARENT_SESSION_ID;
const pidFilePath = vscode9.Uri.joinPath(
this.sessionsFolder,
`PSES-${parentSessionId}.pid`
);
if (parentSessionId === void 0) {
return;
}
const fs = vscode9.workspace.fs;
const pid = (await pwshProcess.getPid()).toString();
await fs.writeFile(pidFilePath, Buffer.from(pid));
const deletePidOnExit = pwshProcess.onExited(() => {
deletePidOnExit.dispose();
fs.delete(pidFilePath, { useTrash: false });
console.log(`Deleted PID file: ${pidFilePath}`);
});
this.registeredCommands.push(deletePidOnExit);
this.extensionContext.subscriptions.push(deletePidOnExit);
}
getSessionDetails() {
if (this.sessionDetails === void 0) {
void this.logger.writeAndShowError(
"PowerShell session unavailable for debugging!"
);
}
return this.sessionDetails;
}
async getLanguageServerPid() {
if (this.languageServerProcess === void 0) {
void this.logger.writeAndShowError(
"PowerShell Extension Terminal unavailable!"
);
}
return this.languageServerProcess?.getPid();
}
getPowerShellVersionDetails() {
return this.versionDetails;
}
getNewSessionFilePath() {
const uniqueId = Math.floor(1e5 + Math.random() * 9e5);
return vscode9.Uri.joinPath(
this.sessionsFolder,
`PSES-VSCode-${process.env.VSCODE_PID}-${uniqueId}.json`
);
}
setLanguageClientConsumers(languageClientConsumers2) {
this.languageClientConsumers = languageClientConsumers2;
}
async createDebugSessionProcess(settings, powershellExeName) {
this.debugSessionProcess?.dispose();
this.debugEventHandler?.dispose();
if (this.PowerShellExeDetails === void 0) {
return Promise.reject(
new Error("Required PowerShellExeDetails undefined!")
);
}
const debugPowerShellExeDetails = powershellExeName === void 0 ? this.PowerShellExeDetails : await this.findPowerShell(powershellExeName) ?? this.PowerShellExeDetails;
this.sessionSettings = settings;
const bundledModulesPath = await this.getBundledModulesPath();
this.debugSessionProcess = new PowerShellProcess(
debugPowerShellExeDetails.exePath,
bundledModulesPath,
true,
false,
this.logger,
this.extensionContext.logUri,
this.getEditorServicesArgs(
bundledModulesPath,
this.PowerShellExeDetails
) + "-DebugServiceOnly ",
this.getNewSessionFilePath(),
this.sessionSettings
);
this.debugEventHandler = vscode9.debug.onDidReceiveDebugSessionCustomEvent((e) => {
if (e.event === "powerShell/sendKeyPress") {
this.debugSessionProcess?.sendKeyPress();
}
});
return this.debugSessionProcess;
}
async waitUntilStarted() {
while (this.sessionStatus !== "Running" /* Running */) {
await utils3.sleep(200);
}
}
// TODO: Is this used by the magic of "Middleware" in the client library?
resolveCodeLens(codeLens, token, next) {
const resolvedCodeLens = next(codeLens, token);
const resolveFunc = (codeLensToFix) => {
if (codeLensToFix.command?.command === "editor.action.showReferences") {
const oldArgs = codeLensToFix.command.arguments;
if (oldArgs === void 0 || oldArgs.length < 3) {
this.logger.writeError(
"Code Lens arguments were malformed!"
);
return codeLensToFix;
}
codeLensToFix.command.arguments = [
vscode9.Uri.parse(oldArgs[0]),
new vscode9.Position(oldArgs[1].line, oldArgs[1].character),
oldArgs[2].map(
(position) => {
return new vscode9.Location(
vscode9.Uri.parse(position.uri),
new vscode9.Range(
position.range.start.line,
position.range.start.character,
position.range.end.line,
position.range.end.character
)
);
}
)
];
}
return codeLensToFix;
};
if (resolvedCodeLens.then) {
return resolvedCodeLens.then(
resolveFunc
);
} else if (resolvedCodeLens) {
return resolveFunc(resolvedCodeLens);
}
return resolvedCodeLens;
}
// TODO: Remove this migration code. Move old setting
// codeFormatting.whitespaceAroundPipe to new setting
// codeFormatting.addWhitespaceAroundPipe.
async migrateWhitespaceAroundPipeSetting() {
const configuration = vscode9.workspace.getConfiguration(
utils3.PowerShellLanguageId
);
const deprecatedSetting = "codeFormatting.whitespaceAroundPipe";
const newSetting = "codeFormatting.addWhitespaceAroundPipe";
const configurationTargetOfNewSetting = getEffectiveConfigurationTarget(newSetting);
const configurationTargetOfOldSetting = getEffectiveConfigurationTarget(deprecatedSetting);
if (configurationTargetOfOldSetting !== void 0 && configurationTargetOfNewSetting === void 0) {
this.logger.writeWarning(
"Deprecated setting: whitespaceAroundPipe"
);
const value = configuration.get(
deprecatedSetting,
configurationTargetOfOldSetting
);
await changeSetting(
newSetting,
value,
configurationTargetOfOldSetting,
this.logger
);
await changeSetting(
deprecatedSetting,
void 0,
configurationTargetOfOldSetting,
this.logger
);
}
}
/** There are some changes we cannot "hot" set, so these require a restart of the session */
async restartOnCriticalConfigChange(changeEvent) {
if (this.suppressRestartPrompt) {
return;
}
if (this.sessionStatus !== "Running" /* Running */) {
return;
}
const settings = getSettings();
if (changeEvent.affectsConfiguration(
"terminal.integrated.shellIntegration.enabled"
)) {
const shellIntegrationEnabled = vscode9.workspace.getConfiguration("terminal.integrated.shellIntegration").get("enabled") ?? false;
if (shellIntegrationEnabled && !settings.integratedConsole.startInBackground) {
return this.restartWithPrompt();
}
}
if (!changeEvent.affectsConfiguration("powershell")) {
return;
}
const coldRestartSettingNames = [
"developer.traceLsp",
"developer.traceDap",
"developer.editorServicesLogLevel"
];
for (const settingName of coldRestartSettingNames) {
if (changeEvent.affectsConfiguration(
"powershell." + settingName
)) {
return this.restartWithPrompt();
}
}
if (settings.cwd !== this.sessionSettings.cwd || settings.powerShellDefaultVersion !== this.sessionSettings.powerShellDefaultVersion || settings.developer.bundledModulesPath !== this.sessionSettings.developer.bundledModulesPath || settings.developer.editorServicesWaitForDebugger !== this.sessionSettings.developer.editorServicesWaitForDebugger || settings.developer.setExecutionPolicy !== this.sessionSettings.developer.setExecutionPolicy || settings.integratedConsole.useLegacyReadLine !== this.sessionSettings.integratedConsole.useLegacyReadLine || settings.integratedConsole.startInBackground !== this.sessionSettings.integratedConsole.startInBackground || settings.integratedConsole.startLocation !== this.sessionSettings.integratedConsole.startLocation) {
return this.restartWithPrompt();
}
}
async restartWithPrompt() {
this.logger.writeDebug("Settings changed, prompting to restart...");
const response = await vscode9.window.showInformationMessage(
"The PowerShell runtime configuration has changed, would you like to start a new session?",
"Yes",
"No"
);
if (response === "Yes") {
await this.restartSession();
}
}
registerCommands() {
this.registeredCommands = [
vscode9.commands.registerCommand(
"PowerShell.RestartSession",
async () => {
await this.restartSession();
}
),
vscode9.commands.registerCommand(
this.ShowSessionMenuCommandName,
async () => {
await this.showSessionMenu();
}
),
vscode9.workspace.onDidChangeConfiguration(
(e) => this.restartOnCriticalConfigChange(e)
),
vscode9.commands.registerCommand(
"PowerShell.ShowSessionConsole",
(isExecute) => {
this.showSessionTerminal(isExecute);
}
)
];
}
async findPowerShell(wantedName) {
this.logger.writeDebug("Finding PowerShell...");
const powershellExeFinder = new PowerShellExeFinder(
this.platformDetails,
this.sessionSettings.powerShellAdditionalExePaths,
this.logger
);
let foundPowerShell;
try {
let defaultPowerShell;
wantedName ??= this.sessionSettings.powerShellDefaultVersion;
if (wantedName !== "") {
for await (const details of powershellExeFinder.enumeratePowerShellInstallations()) {
if (wantedName.localeCompare(
details.displayName,
void 0,
{ sensitivity: "accent" }
) === 0) {
defaultPowerShell = details;
break;
}
}
}
foundPowerShell = defaultPowerShell ?? await powershellExeFinder.getFirstAvailablePowerShellInstallation();
if (wantedName !== "" && defaultPowerShell === void 0 && foundPowerShell !== void 0) {
void this.logger.writeAndShowWarning(
`The 'powerShellDefaultVersion' setting was '${wantedName}' but this was not found! Instead using first available installation '${foundPowerShell.displayName}' at '${foundPowerShell.exePath}'!`
);
}
} catch (err) {
this.logger.writeError(
`Error occurred while searching for a PowerShell executable:
${err}`
);
}
return foundPowerShell;
}
async startLanguageServerProcess(powerShellExeDetails, cancellationToken) {
const bundledModulesPath = await this.getBundledModulesPath();
PowerShellProcess.cleanUpTerminals();
const languageServerProcess = new PowerShellProcess(
powerShellExeDetails.exePath,
bundledModulesPath,
false,
this.shellIntegrationEnabled,
this.logger,
this.extensionContext.logUri,
this.getEditorServicesArgs(
bundledModulesPath,
powerShellExeDetails
),
this.getNewSessionFilePath(),
this.sessionSettings,
this.extensionContext.extensionMode == vscode9.ExtensionMode.Development
);
languageServerProcess.onExited(() => {
LanguageClientConsumer.onLanguageClientExited();
if (this.sessionStatus === "Running" /* Running */ || this.sessionStatus === "Busy" /* Busy */) {
this.setSessionStatus("Session Exited!", "Failed" /* Failed */);
void this.promptForRestart();
}
});
this.sessionDetails = await languageServerProcess.start(cancellationToken);
return languageServerProcess;
}
// The process failed to start, so check for common user errors (generally
// out-of-support versions of PowerShell).
async handleFailedProcess(powerShellProcess) {
const version = await powerShellProcess.getVersionCli();
let shouldUpdate = true;
if ((0, import_semver2.satisfies)(version, "<5.1.0")) {
void this.setSessionFailedGetPowerShell(
`PowerShell v${version} is not supported, please update!`
);
} else if ((0, import_semver2.satisfies)(version, ">=5.1.0 <6.0.0")) {
void this.setSessionFailedGetPowerShell(
"It looks like you're trying to use Windows PowerShell, which is supported on a best-effort basis. Can you try PowerShell 7?"
);
} else if ((0, import_semver2.satisfies)(version, ">=6.0.0 <7.4.0")) {
void this.setSessionFailedGetPowerShell(
`PowerShell v${version} has reached end-of-support, please update!`
);
} else {
shouldUpdate = false;
void this.setSessionFailedOpenBug(
"PowerShell Language Server process didn't start!"
);
}
if (shouldUpdate) {
const versionDetails = {
version,
edition: "",
// Unused by UpdatePowerShell
commit: version,
// Actually used by UpdatePowerShell
architecture: process.arch
// Best guess based off Code's architecture
};
const updater = new UpdatePowerShell(
this.sessionSettings,
this.logger,
versionDetails
);
void updater.checkForUpdate();
}
}
sessionStarted(sessionDetails) {
this.logger.writeDebug(
`Session details: ${JSON.stringify(sessionDetails, void 0, 2)}`
);
if (sessionDetails.status === "started") {
return true;
}
if (sessionDetails.status === "failed") {
if (sessionDetails.reason === "powerShellVersion") {
void this.setSessionFailedGetPowerShell(
`PowerShell ${sessionDetails.powerShellVersion} is not supported, please update!`
);
} else if (sessionDetails.reason === "dotNetVersion") {
void this.setSessionFailedGetDotNet(
".NET Framework is out-of-date, please install at least 4.8!"
);
} else {
void this.setSessionFailedOpenBug(
`PowerShell could not be started for an unknown reason: ${sessionDetails.reason}`
);
}
} else {
void this.setSessionFailedOpenBug(
`PowerShell could not be started with an unknown status: ${sessionDetails.status}, and reason: ${sessionDetails.reason}`
);
}
return false;
}
async startLanguageClient(sessionDetails) {
this.logger.writeDebug("Connecting to language service...");
const connectFunc = () => {
return new Promise((resolve3, _reject) => {
const socket = net.connect(
sessionDetails.languageServicePipeName
);
socket.on("connect", () => {
this.logger.writeDebug("Language service connected.");
resolve3({ writer: socket, reader: socket });
});
});
};
const clientOptions = {
documentSelector: this.documentSelector,
synchronize: {
// TODO: This is deprecated and they should be pulled by the server.
// backend uses "files" and "search" to ignore references.
configurationSection: [
utils3.PowerShellLanguageId,
"files",
"search"
]
// TODO: fileEvents: vscode.workspace.createFileSystemWatcher('**/.eslintrc')
},
// NOTE: Some settings are only applicable on startup, so we send them during initialization.
// When Terminal Shell Integration is enabled, we pass the path to the script that the server should execute.
// Passing an empty string implies integration is disabled.
initializationOptions: {
enableProfileLoading: this.sessionSettings.enableProfileLoading,
initialWorkingDirectory: await validateCwdSetting(this.logger),
shellIntegrationScript: this.shellIntegrationEnabled ? utils3.ShellIntegrationScript : ""
},
errorHandler: {
// Override the default error handler to prevent it from
// closing the LanguageClient incorrectly when the socket
// hangs up (ECONNRESET errors).
error: (_error, _message, _count) => {
this.logger.writeError(
`${_error.name}: ${_error.message} ${_error.cause}`
);
return { action: import_vscode_languageclient2.ErrorAction.Continue };
},
closed: () => {
this.logger.write("Language service connection closed.");
return {
action: import_vscode_languageclient2.CloseAction.DoNotRestart,
message: "Connection to PowerShell Editor Services (the Extension Terminal) was closed. See below prompt to restart!"
};
}
},
middleware: this,
traceOutputChannel: new LanguageClientOutputChannelAdapter(
"PowerShell: Trace LSP",
LspTraceParser
),
// This is named the same as the Client log to merge the logs, but will be handled and disposed separately.
outputChannel: new LanguageClientOutputChannelAdapter(
"PowerShell",
PsesParser
),
revealOutputChannelOn: import_vscode_languageclient2.RevealOutputChannelOn.Never
};
const languageClient = new import_node3.LanguageClient(
"powershell",
"PowerShell Editor Services Client",
connectFunc,
clientOptions
);
languageClient.registerProposedFeatures();
languageClient.onTelemetry((event) => {
const eventName = event.eventName ?? "PSESEvent";
const data = event.data ?? event;
this.sendTelemetryEvent(eventName, data);
});
for (const consumer of this.languageClientConsumers) {
consumer.onLanguageClientSet(languageClient);
}
this.registeredHandlers = [
// NOTE: This fixes a quirk where PSES has a thread stuck on
// Console.ReadKey, since it's not cancellable. On
// "cancellation" the server asks us to send pretend to
// press a key, thus mitigating all the quirk.
languageClient.onNotification(SendKeyPressNotificationType, () => {
this.languageServerProcess?.sendKeyPress();
}),
languageClient.onNotification(
ExecutionBusyStatusNotificationType,
(isBusy) => {
if (isBusy) {
this.setSessionBusyStatus();
} else {
this.setSessionRunningStatus();
}
}
)
];
try {
await languageClient.start();
LanguageClientConsumer.onLanguageClientStarted(languageClient);
} catch (err) {
void this.setSessionFailedOpenBug(
"Language client failed to start: " + (err instanceof Error ? err.message : "unknown")
);
}
return languageClient;
}
async getBundledModulesPath() {
let bundledModulesPath = path5.resolve(__dirname, "../modules");
if (this.extensionContext.extensionMode === vscode9.ExtensionMode.Development) {
const devBundledModulesPath = path5.resolve(
__dirname,
this.sessionSettings.developer.bundledModulesPath
);
if (await utils3.checkIfDirectoryExists(devBundledModulesPath)) {
bundledModulesPath = devBundledModulesPath;
} else {
void this.logger.writeAndShowWarning(
`In development mode but PowerShellEditorServices dev module path cannot be found (or has not been built yet): ${devBundledModulesPath}
`
);
}
}
return bundledModulesPath;
}
getEditorServicesArgs(bundledModulesPath, powerShellExeDetails) {
let editorServicesArgs = `-HostName 'Visual Studio Code Host' -HostProfileId 'Microsoft.VSCode' -HostVersion '${this.HostVersion}' -BundledModulesPath '${utils3.escapeSingleQuotes(bundledModulesPath)}' -EnableConsoleRepl `;
if (this.sessionSettings.integratedConsole.suppressStartupBanner) {
editorServicesArgs += "-StartupBanner '' ";
} else if (utils3.isWindows && !powerShellExeDetails.supportsProperArguments) {
editorServicesArgs += `-StartupBanner '${this.DisplayName} Extension v${this.HostVersion}' `;
} else {
const startupBanner = `${this.DisplayName} Extension v${this.HostVersion}
Copyright (c) Microsoft Corporation.
https://aka.ms/vscode-powershell
Type 'help' to get help.
`;
editorServicesArgs += `-StartupBanner "${startupBanner}" `;
}
if (this.sessionSettings.developer.editorServicesWaitForDebugger && this.extensionContext.extensionMode === vscode9.ExtensionMode.Development) {
editorServicesArgs += "-WaitForDebugger ";
}
const logLevel = vscode9.workspace.getConfiguration("powershell.developer").get("editorServicesLogLevel");
editorServicesArgs += `-LogLevel '${logLevel}' `;
return editorServicesArgs;
}
async getVersionDetails() {
const timeout = new vscode9.CancellationTokenSource();
setTimeout(() => {
timeout.cancel();
}, 60 * 1e3);
const versionDetails = await this.languageClient?.sendRequest(
PowerShellVersionRequestType,
timeout.token
);
this.sendTelemetryEvent("powershellVersionCheck", {
powershellVersion: versionDetails?.version ?? "unknown"
});
return versionDetails;
}
async promptForRestart() {
await this.logger.writeAndShowErrorWithActions(
"The PowerShell Extension Terminal has stopped, would you like to restart it? IntelliSense and other features will not work without it!",
[
{
prompt: "Yes",
action: async () => {
await this.restartSession();
}
},
{
prompt: "No",
action: void 0
}
]
);
}
sendTelemetryEvent(eventName, properties, measures) {
if (this.extensionContext.extensionMode === vscode9.ExtensionMode.Production) {
this.telemetryReporter.sendTelemetryEvent(
eventName,
properties,
measures
);
}
}
createStatusBarItem() {
const statusTitle = "Show PowerShell Session Menu";
const languageStatusItem = vscode9.languages.createLanguageStatusItem(
"powershell",
this.documentSelector
);
languageStatusItem.command = {
title: statusTitle,
command: this.ShowSessionMenuCommandName
};
languageStatusItem.text = "$(terminal-powershell)";
languageStatusItem.detail = "PowerShell";
return languageStatusItem;
}
async waitWhileStarting() {
while (this.sessionStatus === "Starting" /* Starting */) {
if (this.startCancellationTokenSource?.token.isCancellationRequested) {
return;
}
await utils3.sleep(200);
}
}
async waitWhileStopping() {
while (this.sessionStatus === "Stopping" /* Stopping */) {
await utils3.sleep(200);
}
}
setSessionStatus(detail, status) {
this.logger.writeDebug(
`Session status changing from '${this.sessionStatus}' to '${status}'.`
);
this.sessionStatus = status;
this.languageStatusItem.text = "$(terminal-powershell)";
this.languageStatusItem.detail = "PowerShell";
if (this.versionDetails !== void 0) {
const semver = new import_semver2.SemVer(this.versionDetails.version);
this.languageStatusItem.text += ` ${semver.major}.${semver.minor}`;
this.languageStatusItem.detail += ` ${this.versionDetails.commit} (${this.versionDetails.architecture.toLowerCase()})`;
} else if (this.PowerShellExeDetails?.displayName) {
this.languageStatusItem.text += ` ${this.PowerShellExeDetails.displayName}`;
this.languageStatusItem.detail += ` at '${this.PowerShellExeDetails.exePath}'`;
} else if (this.sessionSettings.powerShellDefaultVersion) {
this.languageStatusItem.text += ` ${this.sessionSettings.powerShellDefaultVersion}`;
this.languageStatusItem.detail = `Looking for '${this.sessionSettings.powerShellDefaultVersion}'...`;
}
if (detail) {
this.languageStatusItem.detail += ": " + detail;
}
switch (status) {
case "Running" /* Running */:
case "Not Started" /* NotStarted */:
this.languageStatusItem.busy = false;
this.languageStatusItem.severity = vscode9.LanguageStatusSeverity.Information;
break;
case "Busy" /* Busy */:
this.languageStatusItem.busy = true;
this.languageStatusItem.severity = vscode9.LanguageStatusSeverity.Information;
break;
case "Starting" /* Starting */:
case "Stopping" /* Stopping */:
this.languageStatusItem.busy = true;
this.languageStatusItem.severity = vscode9.LanguageStatusSeverity.Warning;
break;
case "Failed" /* Failed */:
this.languageStatusItem.busy = false;
this.languageStatusItem.severity = vscode9.LanguageStatusSeverity.Error;
break;
}
}
// Refreshes the Language Status Item details with ehe same status.
refreshSessionStatus() {
this.setSessionStatus("", this.sessionStatus);
}
setSessionRunningStatus() {
this.setSessionStatus("", "Running" /* Running */);
}
setSessionBusyStatus() {
this.setSessionStatus("Executing...", "Busy" /* Busy */);
}
async setSessionFailedOpenBug(message) {
this.setSessionStatus("Startup Error!", "Failed" /* Failed */);
await this.logger.writeAndShowErrorWithActions(message, [
{
prompt: "Open an Issue",
action: async () => {
await vscode9.commands.executeCommand(
"PowerShell.GenerateBugReport"
);
}
}
]);
}
async setSessionFailedGetPowerShell(message) {
this.setSessionStatus("Startup Error!", "Failed" /* Failed */);
await this.logger.writeAndShowErrorWithActions(message, [
{
prompt: "Open PowerShell Install Documentation",
action: async () => {
await vscode9.env.openExternal(
vscode9.Uri.parse(
"https://aka.ms/get-powershell-vscode"
)
);
}
}
]);
}
async setSessionFailedGetDotNet(message) {
this.setSessionStatus("Startup Error!", "Failed" /* Failed */);
await this.logger.writeAndShowErrorWithActions(message, [
{
prompt: "Open .NET Framework Documentation",
action: async () => {
await vscode9.env.openExternal(
vscode9.Uri.parse(
"https://dotnet.microsoft.com/en-us/download/dotnet-framework"
)
);
}
}
]);
}
async changePowerShellDefaultVersion(exePath) {
this.suppressRestartPrompt = true;
try {
await changeSetting(
"powerShellDefaultVersion",
exePath.displayName,
true,
this.logger
);
} finally {
this.suppressRestartPrompt = false;
}
await this.restartSession(exePath.displayName);
}
// Shows the temp debug terminal if it exists, otherwise the session terminal.
showDebugTerminal(isExecute) {
if (this.debugSessionProcess) {
this.debugSessionProcess.showTerminal(
isExecute && !this.sessionSettings.integratedConsole.focusConsoleOnExecute
);
} else {
this.languageServerProcess?.showTerminal(
isExecute && !this.sessionSettings.integratedConsole.focusConsoleOnExecute
);
}
}
// Always shows the session terminal.
showSessionTerminal(isExecute) {
this.languageServerProcess?.showTerminal(
isExecute && !this.sessionSettings.integratedConsole.focusConsoleOnExecute
);
}
async showSessionMenu() {
const powershellExeFinder = new PowerShellExeFinder(
this.platformDetails,
// We don't pull from session settings because we want them fresh!
getSettings().powerShellAdditionalExePaths,
this.logger
);
const availablePowerShellExes = await powershellExeFinder.getAllAvailablePowerShellInstallations();
const powerShellItems = availablePowerShellExes.filter(
(item) => item.displayName !== this.PowerShellExeDetails?.displayName
).map((item) => {
return new SessionMenuItem(
`Switch to: ${item.displayName}`,
async () => {
await this.changePowerShellDefaultVersion(item);
}
);
});
const menuItems = [
new SessionMenuItem(
`Current session: ${this.PowerShellExeDetails?.displayName ?? "Unknown"} (click to show logs)`,
async () => {
await vscode9.commands.executeCommand("PowerShell.ShowLogs");
}
),
// Add all of the different PowerShell options
...powerShellItems,
new SessionMenuItem("Restart current session", async () => {
if (this.PowerShellExeDetails) {
await this.restartSession(
this.PowerShellExeDetails.displayName
);
} else {
await this.restartSession();
}
}),
new SessionMenuItem("Open session logs folder", async () => {
await vscode9.commands.executeCommand(
"PowerShell.OpenLogFolder"
);
}),
new SessionMenuItem(
"Modify list of additional PowerShell locations",
async () => {
await vscode9.commands.executeCommand(
"workbench.action.openSettings",
"powerShellAdditionalExePaths"
);
}
)
];
const selectedItem = await vscode9.window.showQuickPick(menuItems);
await selectedItem?.callback();
}
};
var SessionMenuItem = class {
constructor(label, callback = async () => {
}) {
this.label = label;
this.callback = callback;
}
description;
};
// src/features/DebugSession.ts
init_utils();
var StartDebuggerNotificationType = new import_vscode_languageclient3.NotificationType(
"powerShell/startDebugger"
);
var StopDebuggerNotificationType = new import_vscode_languageclient3.NotificationType(
"powerShell/stopDebugger"
);
var PREVENT_DEBUG_START = void 0;
var PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG = null;
var DebugConfigurations = {
[0 /* LaunchCurrentFile */]: {
name: "PowerShell: Launch Current File",
type: "PowerShell",
request: "launch",
script: "${file}",
args: []
},
[1 /* LaunchScript */]: {
name: "PowerShell: Launch Script",
type: "PowerShell",
request: "launch",
script: 'Enter path or command to execute, for example: "${workspaceFolder}/src/foo.ps1" or "Invoke-Pester"',
args: []
},
[2 /* InteractiveSession */]: {
name: "PowerShell: Interactive Session",
type: "PowerShell",
request: "launch"
},
[3 /* AttachHostProcess */]: {
name: "PowerShell: Attach to PowerShell Host Process",
type: "PowerShell",
request: "attach"
},
[4 /* RunPester */]: {
name: "PowerShell: Run Pester Tests",
type: "PowerShell",
request: "launch",
script: "Invoke-Pester",
createTemporaryIntegratedConsole: true,
attachDotnetDebugger: true
},
[5 /* ModuleInteractiveSession */]: {
name: "PowerShell: Module Interactive Session",
type: "PowerShell",
request: "launch",
script: 'Enter command to import your binary module, for example: "Import-Module -Force ${workspaceFolder}/path/to/module.psd1|dll"'
},
[6 /* BinaryModule */]: {
name: "PowerShell: Binary Module Interactive",
type: "PowerShell",
request: "launch",
script: 'Enter command to import your binary module, for example: "Import-Module -Force ${workspaceFolder}/path/to/module.psd1|dll"',
createTemporaryIntegratedConsole: true,
attachDotnetDebugger: true
},
[7 /* BinaryModulePester */]: {
name: "PowerShell: Binary Module Pester Tests",
type: "PowerShell",
request: "launch",
script: "Invoke-Pester",
createTemporaryIntegratedConsole: true,
attachDotnetDebugger: true
},
[8 /* WindowsPowerShell */]: {
name: "PowerShell: Windows PowerShell",
type: "PowerShell",
request: "launch",
sessionName: "Windows PowerShell (x64)"
}
};
var DebugSessionFeature = class extends LanguageClientConsumer {
constructor(context, sessionManager2, logger2) {
super();
this.sessionManager = sessionManager2;
this.logger = logger2;
this.activateDebugAdaptor(context);
this.commands = [
import_vscode3.commands.registerCommand(
"PowerShell.PickPSHostProcess",
async () => {
const processId = await this.pickPSHostProcess();
return processId?.toString();
}
),
import_vscode3.commands.registerCommand(
"PowerShell.PickRunspace",
async (processId) => {
const runspace = await this.pickRunspace(processId);
return runspace?.toString();
},
this
)
];
}
tempDebugProcess;
tempSessionDetails;
commands = [];
handlers = [];
adapterName = "PowerShell";
dispose() {
for (const command of this.commands) {
command.dispose();
}
for (const handler of this.handlers) {
handler.dispose();
}
}
// This "activates" the debug adapter. You can only do this once.
activateDebugAdaptor(context) {
const triggers = [
import_vscode3.DebugConfigurationProviderTriggerKind.Initial,
import_vscode3.DebugConfigurationProviderTriggerKind.Dynamic
];
for (const triggerKind of triggers) {
context.subscriptions.push(
import_vscode3.debug.registerDebugConfigurationProvider(
this.adapterName,
this,
triggerKind
)
);
}
context.subscriptions.push(
import_vscode3.debug.registerDebugAdapterTrackerFactory(
this.adapterName,
new PowerShellDebugAdapterTrackerFactory(this.adapterName)
),
import_vscode3.debug.registerDebugAdapterDescriptorFactory(this.adapterName, this)
);
}
onLanguageClientSet(languageClient) {
this.handlers = [
languageClient.onNotification(
StartDebuggerNotificationType,
() => void import_vscode3.debug.startDebugging(
void 0,
DebugConfigurations[2 /* InteractiveSession */]
)
),
languageClient.onNotification(
StopDebuggerNotificationType,
() => void import_vscode3.debug.stopDebugging(void 0)
)
];
}
async provideDebugConfigurations(_folder, _token) {
const debugConfigPickItems = [
{
id: 0 /* LaunchCurrentFile */,
label: "Launch Current File",
description: "Launch and debug the file in the currently active editor window"
},
{
id: 1 /* LaunchScript */,
label: "Launch Script",
description: "Launch and debug the specified file or command"
},
{
id: 2 /* InteractiveSession */,
label: "Interactive Session",
description: "Debug commands executed from the PowerShell Extension Terminal"
},
{
id: 3 /* AttachHostProcess */,
label: "Attach",
description: "Attach the debugger to a running PowerShell Host Process"
},
{
id: 4 /* RunPester */,
label: "Run Pester Tests",
description: "Debug Pester Tests detected in your current directory (runs Invoke-Pester)"
},
{
id: 5 /* ModuleInteractiveSession */,
label: "Interactive Session (Module)",
description: "Debug commands executed from the PowerShell Extension Terminal after auto-loading your module"
},
{
id: 6 /* BinaryModule */,
label: "Interactive Session (Binary Module)",
description: "Debug a .NET binary or hybrid module loaded into a PowerShell session. Breakpoints you set in your .NET (C#/F#/VB/etc.) code will be hit upon command execution. You may want to add a compile or watch action as a pre-launch task to this configuration."
},
{
id: 7 /* BinaryModulePester */,
label: "Run Pester Tests (Binary Module)",
description: "Debug a .NET binary or hybrid module by running Pester tests. Breakpoints you set in your .NET (C#/F#/VB/etc.) code will be hit upon command execution. You may want to add a compile or watch action as a pre-launch task to this configuration."
}
];
const platformDetails = getPlatformDetails();
if (platformDetails.operatingSystem === 1 /* Windows */) {
debugConfigPickItems.push({
id: 8 /* WindowsPowerShell */,
label: "Windows PowerShell",
description: "Launch Windows PowerShell in a temporary integrated console for debugging"
});
}
const launchSelection = await import_vscode3.window.showQuickPick(
debugConfigPickItems,
{ placeHolder: "Select a PowerShell debug configuration" }
);
if (launchSelection) {
return [DebugConfigurations[launchSelection.id]];
}
return [DebugConfigurations[0 /* LaunchCurrentFile */]];
}
// We don't use await here but we are returning a promise and the return syntax is easier in an async function
// eslint-disable-next-line @typescript-eslint/require-await
async resolveDebugConfiguration(_folder, config, _token) {
if (!config.request) {
const LaunchCurrentFileConfig = DebugConfigurations[0 /* LaunchCurrentFile */];
config = { ...config, ...LaunchCurrentFileConfig };
config.current_document = true;
}
if (config.script === "${file}" || config.script === "${relativeFile}") {
if (import_vscode3.window.activeTextEditor === void 0) {
void this.logger.writeAndShowError(
"To debug the 'Current File', you must first open a PowerShell script file in the editor."
);
return PREVENT_DEBUG_START;
}
config.current_document = true;
const currentDocument = import_vscode3.window.activeTextEditor.document;
if (currentDocument.isUntitled) {
config.untitled_document = true;
config.script = currentDocument.uri.toString();
}
}
return config;
}
async resolveDebugConfigurationWithSubstitutedVariables(_folder, config, _token) {
let resolvedConfig;
config.internalConsoleOptions = "neverOpen";
const settings = getSettings();
config.createTemporaryIntegratedConsole ??= settings.debugging.createTemporaryIntegratedConsole;
config.executeMode ??= settings.debugging.executeMode;
if (config.request === "attach") {
resolvedConfig = await this.resolveAttachDebugConfiguration(config);
} else if (config.request === "launch") {
resolvedConfig = await this.resolveLaunchDebugConfiguration(config);
} else {
void this.logger.writeAndShowError(
`PowerShell debug configuration's request type was invalid: '${config.request}'.`
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
return resolvedConfig;
}
// This is our factory entrypoint hook to when a debug session starts, and
// where we will lazy initialize everything needed to do the debugging such
// as a temporary console if required.
//
// NOTE: A Promise meets the shape of a ProviderResult, which allows us to
// make this method async.
async createDebugAdapterDescriptor(session, _executable) {
await this.sessionManager.start();
const sessionDetails = session.configuration.createTemporaryIntegratedConsole ? await this.createTemporaryIntegratedConsole(session) : this.sessionManager.getSessionDetails();
if (sessionDetails === void 0) {
return void 0;
}
this.sessionManager.showDebugTerminal(true);
this.logger.writeDebug(
`Connecting to pipe: ${sessionDetails.debugServicePipeName}`
);
this.logger.writeDebug(
`Debug configuration: ${JSON.stringify(session.configuration, void 0, 2)}`
);
return new import_vscode3.DebugAdapterNamedPipeServer(
sessionDetails.debugServicePipeName
);
}
async resolveLaunchDebugConfiguration(config) {
if (config.current_document) {
const currentDocument = import_vscode3.window.activeTextEditor?.document;
if (currentDocument?.languageId !== "powershell") {
void this.logger.writeAndShowError(
`PowerShell does not support debugging this language mode: '${currentDocument?.languageId}'.`
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
if (await checkIfFileExists(config.script)) {
const ext = import_path.default.extname(config.script).toLowerCase();
if (!(ext === ".ps1" || ext === ".psm1")) {
void this.logger.writeAndShowError(
`PowerShell does not support debugging this file type: '${import_path.default.basename(config.script)}'.`
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
}
}
if (config.untitled_document && config.createTemporaryIntegratedConsole) {
void this.logger.writeAndShowError(
"PowerShell does not support debugging untitled files in a temporary console."
);
return PREVENT_DEBUG_START;
}
if (!config.createTemporaryIntegratedConsole && config.attachDotnetDebugger) {
void this.logger.writeAndShowError(
"dotnet debugging without using a temporary console is currently not supported. Please updated your launch config to include createTemporaryIntegratedConsole: true."
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
if (config.sessionName) {
config.createTemporaryIntegratedConsole = true;
}
if (config.attachDotnetDebugger) {
return this.resolveAttachDotnetDebugConfiguration(config);
}
config.temporaryConsoleWindowActionOnDebugEnd ??= "keep";
return config;
}
resolveAttachDotnetDebugConfiguration(config) {
if (!import_vscode3.extensions.getExtension("ms-dotnettools.csharp")) {
void this.logger.writeAndShowError(
"You specified attachDotnetDebugger in your PowerShell Launch configuration but the C# extension is not installed. Please install the C# extension and try again."
);
return PREVENT_DEBUG_START;
}
const dotnetDebuggerConfig = this.getDotnetNamedConfigOrDefault(
config.dotnetDebuggerConfigName
);
if (dotnetDebuggerConfig === void 0) {
void this.logger.writeAndShowError(
`You specified dotnetDebuggerConfigName in your PowerShell Launch configuration but a matching launch config was not found. Please ensure you have a coreclr attach config with the name ${config.dotnetDebuggerConfigName} in your launch.json file or remove dotnetDebuggerConfigName from your PowerShell Launch configuration to use the defaults`
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
config.dotnetAttachConfig = dotnetDebuggerConfig;
return config;
}
async createTemporaryIntegratedConsole(session) {
const settings = getSettings();
const previousActiveTerminal = import_vscode3.window.activeTerminal;
this.tempDebugProcess = await this.sessionManager.createDebugSessionProcess(
settings,
session.configuration.sessionName
);
const cancellationTokenSource = new import_vscode3.CancellationTokenSource();
this.tempSessionDetails = await this.tempDebugProcess.start(
cancellationTokenSource.token
);
if (session.configuration.attachDotnetDebugger) {
const dotnetAttachConfig = session.configuration.dotnetAttachConfig;
const pid = await this.tempDebugProcess.getPid();
if (pid === void 0) {
void this.logger.writeAndShowError(
"Attach Dotnet Debugger was specified but the PowerShell temporary debug session failed to start. This is probably a bug."
);
return PREVENT_DEBUG_START;
}
dotnetAttachConfig.processId = pid;
let tempConsoleDotnetAttachSession;
const startDebugEvent = import_vscode3.debug.onDidStartDebugSession(
(dotnetAttachSession) => {
if (dotnetAttachSession.configuration.name != dotnetAttachConfig.name) {
return;
}
startDebugEvent.dispose();
this.logger.writeDebug(
`Debugger session detected: ${dotnetAttachSession.name} (${dotnetAttachSession.id})`
);
tempConsoleDotnetAttachSession = dotnetAttachSession;
const stopDebugEvent = import_vscode3.debug.onDidTerminateDebugSession(
async (tempConsoleSession) => {
if (tempConsoleDotnetAttachSession.parentSession?.id !== tempConsoleSession.id) {
return;
}
stopDebugEvent.dispose();
this.logger.writeDebug(
`Debugger session terminated: ${tempConsoleSession.name} (${tempConsoleSession.id})`
);
const disconnectRequest = {
command: "disconnect",
seq: 0,
type: "request",
arguments: {
restart: false,
terminateDebuggee: false,
suspendDebuggee: false
}
};
try {
await dotnetAttachSession.customRequest(
disconnectRequest.command,
disconnectRequest.arguments
);
} catch (err) {
this.logger.writeWarning(
`Disconnect request to dotnet debugger failed: ${err}`
);
}
}
);
}
);
await import_vscode3.debug.startDebugging(void 0, dotnetAttachConfig, session);
this.logger.writeDebug(
`Dotnet attach debug configuration: ${JSON.stringify(dotnetAttachConfig, void 0, 2)}`
);
this.logger.writeDebug(
`Attached dotnet debugger to process: ${pid}`
);
}
if (session.configuration.temporaryConsoleWindowActionOnDebugEnd !== "keep") {
const closeDebugEvent = import_vscode3.debug.onDidTerminateDebugSession(
(terminatedSession) => {
closeDebugEvent.dispose();
if (terminatedSession.id !== session.id) {
return;
}
if (terminatedSession.configuration.temporaryConsoleWindowActionOnDebugEnd === "close") {
this.tempDebugProcess?.dispose();
} else if (terminatedSession.configuration.temporaryConsoleWindowActionOnDebugEnd === "hide" && previousActiveTerminal && import_vscode3.window.terminals.includes(previousActiveTerminal)) {
previousActiveTerminal.show();
}
}
);
}
return this.tempSessionDetails;
}
getDotnetNamedConfigOrDefault(configName) {
if (configName) {
const debugConfigs = this.getLaunchConfigurations();
return debugConfigs.find(
({ type, request, name }) => type === "coreclr" && request === "attach" && name === configName
);
}
return {
name: "Dotnet Debugger: Temporary Extension Terminal",
type: "coreclr",
request: "attach",
processId: void 0,
logging: {
moduleLoad: false
}
};
}
/** Fetches all available vscode launch configurations. This is abstracted out for easier testing. */
getLaunchConfigurations() {
return import_vscode3.workspace.getConfiguration("launch").get("configurations") ?? [];
}
async resolveAttachDebugConfiguration(config) {
const platformDetails = getPlatformDetails();
const versionDetails = this.sessionManager.getPowerShellVersionDetails();
if (versionDetails === void 0) {
void this.logger.writeAndShowError(
`PowerShell session version details were not found for '${config.name}'.`
);
return PREVENT_DEBUG_START;
}
if (versionDetails.version < "7.0.0" && platformDetails.operatingSystem !== 1 /* Windows */) {
void this.logger.writeAndShowError(
`Attaching to a PowerShell Host Process on ${OperatingSystem[platformDetails.operatingSystem]} requires PowerShell 7.0 or higher (Current Version: ${versionDetails.version}).`
);
return PREVENT_DEBUG_START;
}
if (!config.customPipeName && !config.processId) {
config.processId = await this.pickPSHostProcess();
if (!config.processId) {
return PREVENT_DEBUG_START;
}
}
if (typeof config.processId === "string" && config.processId != "current") {
config.processId = parseInt(config.processId);
}
if (config.processId === "current" || config.processId === await this.sessionManager.getLanguageServerPid()) {
void this.logger.writeAndShowError(
"Attaching to the PowerShell Extension terminal is not supported. Please use the 'PowerShell: Interactive Session' debug configuration instead."
);
return PREVENT_DEBUG_START_AND_OPEN_DEBUGCONFIG;
}
if (!config.runspaceId && !config.runspaceName) {
config.runspaceId = await this.pickRunspace(config.processId);
if (!config.runspaceId) {
return PREVENT_DEBUG_START;
}
}
config.temporaryConsoleWindowActionOnDebugEnd ??= "keep";
return config;
}
async pickPSHostProcess() {
const client = await LanguageClientConsumer.getLanguageClient();
const response = await client.sendRequest(
GetPSHostProcessesRequestType,
{}
);
const items = [];
for (const process3 of response) {
let windowTitle = "";
if (process3.mainWindowTitle) {
windowTitle = `, ${process3.mainWindowTitle}`;
}
items.push({
label: process3.processName,
description: `PID: ${process3.processId.toString()}${windowTitle}`,
processId: process3.processId
});
}
if (items.length === 0) {
return Promise.reject(
new Error("There are no PowerShell host processes to attach.")
);
}
const options = {
placeHolder: "Select a PowerShell host process to attach.",
matchOnDescription: true,
matchOnDetail: true
};
const item = await import_vscode3.window.showQuickPick(items, options);
return item?.processId ?? void 0;
}
async pickRunspace(processId) {
const client = await LanguageClientConsumer.getLanguageClient();
const response = await client.sendRequest(GetRunspaceRequestType, {
processId
});
const items = [];
for (const runspace of response) {
items.push({
label: runspace.name,
description: `ID: ${runspace.id} - ${runspace.availability}`,
id: runspace.id
});
}
const options = {
placeHolder: "Select PowerShell runspace to debug",
matchOnDescription: true,
matchOnDetail: true
};
const item = await import_vscode3.window.showQuickPick(items, options);
return item?.id ?? void 0;
}
};
var PowerShellDebugAdapterTrackerFactory = class {
constructor(adapterName = "PowerShell") {
this.adapterName = adapterName;
}
disposables = [];
_log;
/** Lazily creates a {@link LogOutputChannel} for debug tracing, and presents it only when DAP logging is enabled.
*
* We want to use a shared output log for separate debug sessions as usually only one is running at a time and we
* dont need an output window for every debug session. We also want to leave it active so user can copy and paste
* even on run end. When user changes the setting and disables it getter will return undefined, which will result
* in a noop for the logging activities, effectively pausing logging but not disposing the output channel. If the
* user re-enables, then logging resumes.
*/
get log() {
if (import_vscode3.workspace.getConfiguration("powershell.developer").get("traceDap") && this._log === void 0) {
this._log = import_vscode3.window.createOutputChannel(
`${this.adapterName}: Trace DAP`,
{ log: true }
);
this.disposables.push(this._log);
}
return this._log;
}
// This tracker effectively implements the logging for the debug adapter to a LogOutputChannel
createDebugAdapterTracker(session) {
const sessionInfo = `${this.adapterName} Debug Session: ${session.name} [${session.id}]`;
return {
onWillStartSession: () => this.log?.info(
`Starting ${sessionInfo}. Set log level to trace to see DAP messages beyond errors`
),
onWillStopSession: () => this.log?.info(`Stopping ${sessionInfo}`),
onExit: (code) => this.log?.info(`${sessionInfo} exited with code ${code}`),
onWillReceiveMessage: (m) => {
this.log?.debug(`\u27A1\uFE0F${m.seq} ${m.type}: ${m.command}`);
if (m.arguments && (Array.isArray(m.arguments) ? m.arguments.length > 0 : Object.keys(m.arguments).length > 0)) {
this.log?.trace(
`${m.seq}: ` + JSON.stringify(m.arguments, void 0, 2)
);
}
},
onDidSendMessage: (m) => {
const responseSummary = m.request_seq !== void 0 ? `${m.success ? "\u2705" : "\u274C"}${m.request_seq} ${m.type}(${m.seq}): ${m.command}` : `\u2B05\uFE0F${m.seq} ${m.type}: ${m.event ?? m.command}`;
this.log?.debug(responseSummary);
if (m.body && (Array.isArray(m.body) ? m.body.length > 0 : Object.keys(m.body).length > 0)) {
this.log?.trace(
`${m.seq}: ` + JSON.stringify(m.body, void 0, 2)
);
}
},
onError: (e) => this.log?.error(e)
};
}
dispose() {
this.disposables.forEach((d) => d.dispose());
}
};
var SpecifyScriptArgsFeature = class {
command;
context;
constructor(context) {
this.context = context;
this.command = import_vscode3.commands.registerCommand(
"PowerShell.SpecifyScriptArgs",
() => {
return this.specifyScriptArguments();
}
);
}
dispose() {
this.command.dispose();
}
async specifyScriptArguments() {
const powerShellDbgScriptArgsKey = "powerShellDebugScriptArgs";
const options = {
ignoreFocusOut: true,
placeHolder: "Enter script arguments or leave empty to pass no args"
};
const prevArgs = this.context.workspaceState.get(
powerShellDbgScriptArgsKey,
""
);
if (prevArgs.length > 0) {
options.value = prevArgs;
}
const text = await import_vscode3.window.showInputBox(options);
if (text !== void 0) {
await this.context.workspaceState.update(
powerShellDbgScriptArgsKey,
text
);
}
return text;
}
};
var GetPSHostProcessesRequestType = new import_vscode_languageclient3.RequestType("powerShell/getPSHostProcesses");
var GetRunspaceRequestType = new import_vscode_languageclient3.RequestType("powerShell/getRunspace");
// src/features/Examples.ts
var path7 = require("path");
var utils4 = (init_utils(), __toCommonJS(utils_exports));
var vscode10 = require("vscode");
var ExamplesFeature = class {
command;
examplesPath;
constructor() {
this.examplesPath = vscode10.Uri.file(
path7.resolve(__dirname, "../examples")
);
this.command = vscode10.commands.registerCommand(
"PowerShell.OpenExamplesFolder",
async () => {
await vscode10.commands.executeCommand(
"vscode.openFolder",
this.examplesPath,
true
);
return utils4.checkIfFileExists(this.examplesPath);
}
);
}
dispose() {
this.command.dispose();
}
};
// src/features/ExpandAlias.ts
var import_vscode_languageclient4 = __toESM(require_main4());
var vscode11 = require("vscode");
var ExpandAliasRequestType = new import_vscode_languageclient4.RequestType("powerShell/expandAlias");
var ExpandAliasFeature = class extends LanguageClientConsumer {
command;
constructor() {
super();
this.command = vscode11.commands.registerCommand(
"PowerShell.ExpandAlias",
async () => {
const editor = vscode11.window.activeTextEditor;
if (editor === void 0) {
return;
}
const document = editor.document;
const selection = editor.selection;
const sls = selection.start;
const sle = selection.end;
let text;
let range;
if (sls.character === sle.character && sls.line === sle.line) {
text = document.getText();
range = new vscode11.Range(
0,
0,
document.lineCount,
text.length
);
} else {
text = document.getText(selection);
range = new vscode11.Range(
sls.line,
sls.character,
sle.line,
sle.character
);
}
const client = await LanguageClientConsumer.getLanguageClient();
const result = await client.sendRequest(
ExpandAliasRequestType,
{ text }
);
await editor.edit((editBuilder) => {
editBuilder.replace(range, result.text);
});
}
);
}
onLanguageClientSet(_languageClient) {
}
dispose() {
this.command.dispose();
}
};
// src/features/ExtensionCommands.ts
var path8 = __toESM(require("path"));
var vscode12 = __toESM(require("vscode"));
var import_vscode_languageclient5 = __toESM(require_main4());
var import_node5 = __toESM(require_node3());
var InvokeExtensionCommandRequestType = new import_vscode_languageclient5.RequestType("powerShell/invokeExtensionCommand");
var ExtensionCommandAddedNotificationType = new import_vscode_languageclient5.NotificationType(
"powerShell/extensionCommandAdded"
);
function asRange(value) {
return { start: asPosition(value.start), end: asPosition(value.end) };
}
function asPosition(value) {
return { line: value.line, character: value.character };
}
function asCodePosition(value) {
return new vscode12.Position(value.line, value.character);
}
var GetEditorContextRequestType = new import_vscode_languageclient5.RequestType("editor/getEditorContext");
var InsertTextRequestType = new import_vscode_languageclient5.RequestType("editor/insertText");
var SetSelectionRequestType = new import_vscode_languageclient5.RequestType("editor/setSelection");
var OpenFileRequestType = new import_vscode_languageclient5.RequestType("editor/openFile");
var NewFileRequestType = new import_vscode_languageclient5.RequestType("editor/newFile");
var CloseFileRequestType = new import_vscode_languageclient5.RequestType("editor/closeFile");
var SaveFileRequestType = new import_vscode_languageclient5.RequestType("editor/saveFile");
var ShowErrorMessageRequestType = new import_vscode_languageclient5.RequestType("editor/showErrorMessage");
var ShowWarningMessageRequestType = new import_vscode_languageclient5.RequestType("editor/showWarningMessage");
var ShowInformationMessageRequestType = new import_vscode_languageclient5.RequestType("editor/showInformationMessage");
var SetStatusBarMessageRequestType = new import_vscode_languageclient5.RequestType("editor/setStatusBarMessage");
var ClearTerminalNotificationType = new import_vscode_languageclient5.NotificationType0(
"editor/clearTerminal"
);
var ExtensionCommandsFeature = class _ExtensionCommandsFeature extends LanguageClientConsumer {
constructor(logger2) {
super();
this.logger = logger2;
this.commands = [
vscode12.commands.registerCommand(
"PowerShell.ShowAdditionalCommands",
async () => {
await this.showExtensionCommands();
}
),
vscode12.commands.registerCommand(
"PowerShell.InvokeRegisteredEditorCommand",
async (param) => {
const commandToExecute = this.extensionCommands.find(
(x) => x.name === param.commandName
);
if (commandToExecute) {
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendRequest(
InvokeExtensionCommandRequestType,
{
name: commandToExecute.name,
context: this.getEditorContext()
}
);
}
}
),
vscode12.commands.registerCommand(
"PowerShell.ClosePanel",
async () => {
await vscode12.commands.executeCommand(
"workbench.action.togglePanel"
);
}
),
vscode12.commands.registerCommand(
"PowerShell.PositionPanelLeft",
async () => {
await vscode12.commands.executeCommand(
"workbench.action.positionPanelLeft"
);
}
),
vscode12.commands.registerCommand(
"PowerShell.PositionPanelBottom",
async () => {
await vscode12.commands.executeCommand(
"workbench.action.positionPanelBottom"
);
}
),
vscode12.commands.registerCommand(
"PowerShell.Debug.Start",
async () => {
await vscode12.debug.startDebugging(
void 0,
DebugConfigurations[0 /* LaunchCurrentFile */]
);
}
)
];
}
commands;
handlers = [];
statusBarMessages = [];
extensionCommands = [];
onLanguageClientSet(languageClient) {
this.extensionCommands = [];
this.handlers = [
languageClient.onNotification(
ExtensionCommandAddedNotificationType,
(command) => {
this.addExtensionCommand(command);
}
),
languageClient.onRequest(
GetEditorContextRequestType,
(_details) => this.getEditorContext()
),
languageClient.onRequest(
InsertTextRequestType,
(details) => this.insertText(details)
),
languageClient.onRequest(
SetSelectionRequestType,
(details) => this.setSelection(details)
),
languageClient.onRequest(
NewFileRequestType,
(_content) => this.newFile(_content)
),
languageClient.onRequest(
OpenFileRequestType,
(filePath) => this.openFile(filePath)
),
languageClient.onRequest(
CloseFileRequestType,
(filePath) => this.closeFile(filePath)
),
languageClient.onRequest(
SaveFileRequestType,
(saveFileDetails) => this.saveFile(saveFileDetails)
),
languageClient.onRequest(
ShowInformationMessageRequestType,
(message) => this.showInformationMessage(message)
),
languageClient.onRequest(
ShowErrorMessageRequestType,
(message) => this.showErrorMessage(message)
),
languageClient.onRequest(
ShowWarningMessageRequestType,
(message) => this.showWarningMessage(message)
),
languageClient.onRequest(
SetStatusBarMessageRequestType,
(messageDetails) => this.setStatusBarMessage(messageDetails)
),
languageClient.onNotification(ClearTerminalNotificationType, () => {
if (getSettings().integratedConsole.forceClearScrollbackBuffer) {
void vscode12.commands.executeCommand(
"workbench.action.terminal.clear"
);
}
})
];
}
dispose() {
for (const command of this.commands) {
command.dispose();
}
for (const handler of this.handlers) {
handler.dispose();
}
for (const statusBarMessage of this.statusBarMessages) {
statusBarMessage.dispose();
}
}
addExtensionCommand(command) {
this.extensionCommands.push({
name: command.name,
displayName: command.displayName
});
this.extensionCommands.sort(
(a, b) => a.name.localeCompare(b.name)
);
}
async showExtensionCommands() {
if (this.extensionCommands.length === 0) {
void this.logger.writeAndShowInformation(
"No extension commands have been loaded into the current session."
);
return;
}
const quickPickItems = this.extensionCommands.map(
(command) => {
return {
label: command.displayName,
description: command.name,
command
};
}
);
const selectedCommand = await vscode12.window.showQuickPick(
quickPickItems,
{ placeHolder: "Select a command..." }
);
return this.onCommandSelected(selectedCommand);
}
async onCommandSelected(chosenItem) {
if (chosenItem !== void 0) {
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendRequest(InvokeExtensionCommandRequestType, {
name: chosenItem.command.name,
context: this.getEditorContext()
});
}
}
async insertText(details) {
const edit = new vscode12.WorkspaceEdit();
edit.set(vscode12.Uri.parse(details.filePath), [
new vscode12.TextEdit(
new vscode12.Range(
details.insertRange.start.line,
details.insertRange.start.character,
details.insertRange.end.line,
details.insertRange.end.character
),
details.insertText
)
]);
await vscode12.workspace.applyEdit(edit);
return 0 /* Completed */;
}
getEditorContext() {
if (vscode12.window.activeTextEditor === void 0) {
return void 0;
}
return {
currentFileContent: vscode12.window.activeTextEditor.document.getText(),
currentFileLanguage: vscode12.window.activeTextEditor.document.languageId,
currentFilePath: vscode12.window.activeTextEditor.document.uri.toString(),
cursorPosition: asPosition(
vscode12.window.activeTextEditor.selection.active
),
selectionRange: asRange(
new vscode12.Range(
vscode12.window.activeTextEditor.selection.start,
vscode12.window.activeTextEditor.selection.end
)
)
};
}
async newFile(content) {
const doc = await vscode12.workspace.openTextDocument({
language: "powershell",
content
});
await vscode12.window.showTextDocument(doc);
return 0 /* Completed */;
}
async openFile(openFileDetails) {
const filePath = await this.resolveFilePathWithCwd(
openFileDetails.filePath
);
try {
const doc = await vscode12.workspace.openTextDocument(filePath);
await vscode12.window.showTextDocument(doc, {
preview: openFileDetails.preview
});
} catch {
void this.logger.writeAndShowWarning(
`File to open not found: ${filePath}`
);
return 1 /* Failed */;
}
return 0 /* Completed */;
}
async closeFile(filePath) {
filePath = await this.resolveFilePathWithCwd(filePath);
const doc = vscode12.workspace.textDocuments.find(
(x) => x.uri.fsPath === filePath
);
if (doc != void 0 && !doc.isClosed) {
await vscode12.window.showTextDocument(doc);
await vscode12.commands.executeCommand(
"workbench.action.closeActiveEditor"
);
return 0 /* Completed */;
}
void this.logger.writeAndShowWarning(
`File to close not found or already closed: ${filePath}`
);
return 1 /* Failed */;
}
/**
* Save a file, possibly to a new path. If the save is not possible, return a completed response
* @param saveFileDetails the object detailing the path of the file to save and optionally its new path to save to
*/
async saveFile(saveFileDetails) {
let currentFileUri;
if (saveFileDetails.filePath.startsWith("untitled") || saveFileDetails.filePath.startsWith("file")) {
currentFileUri = vscode12.Uri.parse(saveFileDetails.filePath);
} else {
const filePath = await this.resolveFilePathWithCwd(
saveFileDetails.filePath
);
currentFileUri = vscode12.Uri.file(filePath);
}
const doc = vscode12.workspace.textDocuments.find(
(x) => x.uri.fsPath === currentFileUri.fsPath
);
if (doc === void 0) {
void this.logger.writeAndShowWarning(
`File to save not found: ${currentFileUri.fsPath}`
);
return 1 /* Failed */;
}
let newFilePath = saveFileDetails.newPath ?? void 0;
if (currentFileUri.scheme === "file") {
if (newFilePath === void 0) {
if (doc.isDirty) {
await doc.save();
}
return 0 /* Completed */;
}
if (!path8.isAbsolute(newFilePath)) {
newFilePath = path8.join(
path8.dirname(currentFileUri.fsPath),
newFilePath
);
}
} else if (currentFileUri.scheme === "untitled") {
if (newFilePath === void 0) {
void this.logger.writeAndShowWarning(
'Cannot save untitled file! Try SaveAs("path/to/file.ps1") instead.'
);
return 1 /* Failed */;
}
newFilePath = await this.resolveFilePathWithCwd(newFilePath);
} else {
const msg = JSON.stringify(saveFileDetails, void 0, 2);
void this.logger.writeAndShowWarning(
`<${_ExtensionCommandsFeature.name}>: Saving a document with scheme '${currentFileUri.scheme}' is currently unsupported. Message: '${msg}'`
);
return 1 /* Failed */;
}
return await this.saveFileAs(doc, newFilePath);
}
/**
* Take a document available to vscode at the given URI and save it to the given absolute path
* @param documentUri the URI of the vscode document to save
* @param filePath the absolute path to save the document contents to
*/
async saveFileAs(doc, filePath) {
const newFileUri = vscode12.Uri.file(filePath);
try {
await vscode12.workspace.fs.writeFile(
newFileUri,
Buffer.from(doc.getText())
);
} catch (err) {
void this.logger.writeAndShowWarning(
`<${_ExtensionCommandsFeature.name}>: Unable to save file to path '${filePath}': ${err}`
);
return 1 /* Failed */;
}
const newFile = await vscode12.workspace.openTextDocument(newFileUri);
await vscode12.window.showTextDocument(newFile, { preview: true });
return 0 /* Completed */;
}
// Resolve file path against user's CWD setting
async resolveFilePathWithCwd(filePath) {
if (!path8.isAbsolute(filePath)) {
const cwd = await validateCwdSetting(this.logger);
return path8.resolve(cwd, filePath);
}
return filePath;
}
setSelection(details) {
if (vscode12.window.activeTextEditor !== void 0) {
vscode12.window.activeTextEditor.selections = [
new vscode12.Selection(
asCodePosition(details.selectionRange.start),
asCodePosition(details.selectionRange.end)
)
];
return 0 /* Completed */;
}
return 1 /* Failed */;
}
showInformationMessage(message) {
void this.logger.writeAndShowInformation(message);
return 0 /* Completed */;
}
showErrorMessage(message) {
void this.logger.writeAndShowError(message);
return 0 /* Completed */;
}
showWarningMessage(message) {
void this.logger.writeAndShowWarning(message);
return 0 /* Completed */;
}
setStatusBarMessage(messageDetails) {
if (messageDetails.timeout) {
this.statusBarMessages.push(
vscode12.window.setStatusBarMessage(
messageDetails.message,
messageDetails.timeout
)
);
} else {
this.statusBarMessages.push(
vscode12.window.setStatusBarMessage(messageDetails.message)
);
}
return 0 /* Completed */;
}
};
// node_modules/uuid/dist/esm-node/rng.js
var import_crypto = __toESM(require("crypto"));
var rnds8Pool = new Uint8Array(256);
var poolPtr = rnds8Pool.length;
function rng() {
if (poolPtr > rnds8Pool.length - 16) {
import_crypto.default.randomFillSync(rnds8Pool);
poolPtr = 0;
}
return rnds8Pool.slice(poolPtr, poolPtr += 16);
}
// node_modules/uuid/dist/esm-node/stringify.js
var byteToHex = [];
for (let i = 0; i < 256; ++i) {
byteToHex.push((i + 256).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
}
// node_modules/uuid/dist/esm-node/native.js
var import_crypto2 = __toESM(require("crypto"));
var native_default = {
randomUUID: import_crypto2.default.randomUUID
};
// node_modules/uuid/dist/esm-node/v4.js
function v4(options, buf, offset) {
if (native_default.randomUUID && !buf && !options) {
return native_default.randomUUID();
}
options = options || {};
const rnds = options.random || (options.rng || rng)();
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
if (buf) {
offset = offset || 0;
for (let i = 0; i < 16; ++i) {
buf[offset + i] = rnds[i];
}
return buf;
}
return unsafeStringify(rnds);
}
var v4_default = v4;
// src/features/ExternalApi.ts
var vscode13 = __toESM(require("vscode"));
var ExternalApiFeature = class _ExternalApiFeature {
constructor(extensionContext, sessionManager2, logger2) {
this.extensionContext = extensionContext;
this.sessionManager = sessionManager2;
this.logger = logger2;
}
static registeredExternalExtension = /* @__PURE__ */ new Map();
/*
DESCRIPTION:
Registers your extension to allow usage of the external API. The returns
a session UUID that will need to be passed in to subsequent API calls.
USAGE:
powerShellExtensionClient.registerExternalExtension(
"ms-vscode.PesterTestExplorer" // the name of the extension using us
"v1"); // API Version.
RETURNS:
string session uuid
*/
registerExternalExtension(id, apiVersion = "v1") {
this.logger.writeDebug(
`Registering extension '${id}' for use with API version '${apiVersion}'.`
);
for (const [
_name,
externalExtension
] of _ExternalApiFeature.registeredExternalExtension) {
if (externalExtension.id === id) {
const message = `The extension '${id}' is already registered.`;
this.logger.writeWarning(message);
throw new Error(message);
}
}
if (!vscode13.extensions.all.some((ext) => ext.id === id)) {
throw new Error(
`No extension installed with id '${id}'. You must use a valid extension id.`
);
}
if (id === "ms-vscode.powershell" && !(this.extensionContext.extensionMode === vscode13.ExtensionMode.Test)) {
throw new Error(
"You can't use the PowerShell extension's id in this registration."
);
}
const uuid = v4_default();
_ExternalApiFeature.registeredExternalExtension.set(uuid, {
id,
apiVersion
});
return uuid;
}
/*
DESCRIPTION:
Unregisters a session that an extension has. This returns
true if it succeeds or throws if it fails.
USAGE:
powerShellExtensionClient.unregisterExternalExtension(
"uuid"); // the uuid from above for tracking purposes
RETURNS:
true if it worked, otherwise throws an error.
*/
unregisterExternalExtension(uuid = "") {
this.logger.writeDebug(
`Unregistering extension with session UUID: ${uuid}`
);
if (!_ExternalApiFeature.registeredExternalExtension.delete(uuid)) {
throw new Error(
`No extension registered with session UUID: ${uuid}`
);
}
return true;
}
getRegisteredExtension(uuid = "") {
if (!_ExternalApiFeature.registeredExternalExtension.has(uuid)) {
throw new Error(
"UUID provided was invalid, make sure you ran the 'powershellExtensionClient.registerExternalExtension(extensionId)' method and pass in the UUID that it returns to subsequent methods."
);
}
return _ExternalApiFeature.registeredExternalExtension.get(uuid);
}
/*
DESCRIPTION:
This will fetch the version details of the PowerShell used to start
PowerShell Editor Services in the PowerShell extension.
USAGE:
powerShellExtensionClient.getPowerShellVersionDetails(
"uuid"); // the uuid from above for tracking purposes
RETURNS:
An IPowerShellVersionDetails which consists of:
{
version: string;
displayVersion: string;
edition: string;
architecture: string;
}
*/
async getPowerShellVersionDetails(uuid = "") {
const extension = this.getRegisteredExtension(uuid);
this.logger.writeDebug(
`Extension '${extension.id}' called 'getPowerShellVersionDetails'.`
);
await this.sessionManager.waitUntilStarted();
const versionDetails = this.sessionManager.getPowerShellVersionDetails();
return {
exePath: this.sessionManager.PowerShellExeDetails?.exePath ?? "unknown",
version: versionDetails?.version ?? "unknown",
displayName: this.sessionManager.PowerShellExeDetails?.displayName ?? "unknown",
// comes from the Session Menu
architecture: versionDetails?.architecture ?? "unknown"
};
}
/*
DESCRIPTION:
This will wait until the extension's PowerShell session is started.
USAGE:
powerShellExtensionClient.waitUntilStarted(
"uuid"); // the uuid from above for tracking purposes
RETURNS:
A void promise that resolves only once the extension is started.
If the extension is not started by some mechanism
then this will wait indefinitely.
*/
async waitUntilStarted(uuid = "") {
const extension = this.getRegisteredExtension(uuid);
this.logger.writeDebug(
`Extension '${extension.id}' called 'waitUntilStarted'.`
);
await this.sessionManager.waitUntilStarted();
}
getStorageUri() {
return this.extensionContext.globalStorageUri.with({ scheme: "file" });
}
getLogUri() {
return this.extensionContext.logUri.with({ scheme: "file" });
}
dispose() {
}
};
// src/features/GenerateBugReport.ts
var vscode14 = require("vscode");
var child_process = require("child_process");
var issuesUrl = "https://github.com/PowerShell/vscode-powershell/issues/new?";
var GenerateBugReportFeature = class {
constructor(sessionManager2) {
this.sessionManager = sessionManager2;
this.command = vscode14.commands.registerCommand(
"PowerShell.GenerateBugReport",
async () => {
const params = [
"labels=Issue-Bug",
"template=bug-report.yml",
"powershell-version=" + this.getRuntimeInfo(),
"vscode-version=" + vscode14.version + "\n" + process.arch,
"extension-version=" + sessionManager2.Publisher + "." + sessionManager2.HostName + "@" + sessionManager2.HostVersion
];
const url = vscode14.Uri.parse(
issuesUrl + encodeURIComponent(params.join("&"))
);
await vscode14.env.openExternal(url);
}
);
}
command;
dispose() {
this.command.dispose();
}
getRuntimeInfo() {
if (this.sessionManager.PowerShellExeDetails === void 0) {
return "Session's PowerShell details are unknown!";
}
const child = child_process.spawnSync(
this.sessionManager.PowerShellExeDetails.exePath,
[
"-NoProfile",
"-NoLogo",
"-Command",
"$PSVersionTable | Out-String"
]
);
return child.stdout.toString().trim().replace(";", ",");
}
};
// src/features/GetCommands.ts
var vscode15 = __toESM(require("vscode"));
var import_vscode_languageclient6 = __toESM(require_main4());
var import_node6 = __toESM(require_node3());
var GetCommandRequestType = new import_vscode_languageclient6.RequestType0(
"powerShell/getCommand"
);
var GetCommandsFeature = class extends LanguageClientConsumer {
commands;
commandsExplorerProvider;
commandsExplorerTreeView;
constructor() {
super();
this.commands = [
vscode15.commands.registerCommand(
"PowerShell.RefreshCommandsExplorer",
async () => {
await this.CommandExplorerRefresh();
}
),
vscode15.commands.registerCommand(
"PowerShell.InsertCommand",
async (item) => {
await this.InsertCommand(item);
}
)
];
this.commandsExplorerProvider = new CommandsExplorerProvider();
this.commandsExplorerTreeView = vscode15.window.createTreeView(
"PowerShellCommands",
{ treeDataProvider: this.commandsExplorerProvider }
);
this.commandsExplorerTreeView.onDidChangeVisibility(async (e) => {
if (e.visible) {
await this.CommandExplorerRefresh();
}
});
}
dispose() {
for (const command of this.commands) {
command.dispose();
}
}
onLanguageClientSet(_languageClient) {
if (this.commandsExplorerTreeView.visible) {
void vscode15.commands.executeCommand(
"PowerShell.RefreshCommandsExplorer"
);
}
}
async CommandExplorerRefresh() {
const client = await LanguageClientConsumer.getLanguageClient();
const result = await client.sendRequest(GetCommandRequestType);
const exclusions = getSettings().sideBar.CommandExplorerExcludeFilter;
const excludeFilter = exclusions.map(
(filter) => filter.toLowerCase()
);
const filteredResult = result.filter(
(command) => !excludeFilter.includes(command.moduleName.toLowerCase())
);
this.commandsExplorerProvider.powerShellCommands = filteredResult.map(toCommand);
this.commandsExplorerProvider.refresh();
}
async InsertCommand(item) {
const editor = vscode15.window.activeTextEditor;
if (editor === void 0) {
return;
}
const sls = editor.selection.start;
const sle = editor.selection.end;
const range = new vscode15.Range(
sls.line,
sls.character,
sle.line,
sle.character
);
await editor.edit((editBuilder) => {
editBuilder.replace(range, item.Name);
});
}
};
var CommandsExplorerProvider = class {
onDidChangeTreeData;
powerShellCommands = [];
didChangeTreeData = new vscode15.EventEmitter();
constructor() {
this.onDidChangeTreeData = this.didChangeTreeData.event;
}
refresh() {
this.didChangeTreeData.fire(void 0);
}
getTreeItem(element) {
return element;
}
getChildren(_element) {
return Promise.resolve(this.powerShellCommands);
}
};
function toCommand(command) {
return new Command(
command.name,
command.moduleName,
command.defaultParameterSet,
command.parameterSets,
command.parameters
);
}
var Command = class extends vscode15.TreeItem {
constructor(Name, ModuleName, defaultParameterSet, ParameterSets, Parameters, collapsibleState = vscode15.TreeItemCollapsibleState.None) {
super(Name, collapsibleState);
this.Name = Name;
this.ModuleName = ModuleName;
this.defaultParameterSet = defaultParameterSet;
this.ParameterSets = ParameterSets;
this.Parameters = Parameters;
this.collapsibleState = collapsibleState;
}
getTreeItem() {
return {
label: this.label,
collapsibleState: this.collapsibleState
};
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/require-await
async getChildren(_element) {
return [];
}
};
// src/features/HelpCompletion.ts
var import_vscode4 = require("vscode");
var import_vscode_languageclient7 = __toESM(require_main4());
var import_node7 = __toESM(require_node3());
var CommentHelpRequestType = new import_vscode_languageclient7.RequestType("powerShell/getCommentHelp");
var HelpCompletionFeature = class extends LanguageClientConsumer {
helpCompletionProvider;
disposable;
settings;
constructor() {
super();
this.settings = getSettings();
if (this.settings.helpCompletion !== "Disabled" /* Disabled */) {
this.helpCompletionProvider = new HelpCompletionProvider();
this.disposable = import_vscode4.workspace.onDidChangeTextDocument(async (e) => {
await this.onEvent(e);
});
}
}
dispose() {
this.disposable?.dispose();
}
onLanguageClientSet(languageClient) {
this.helpCompletionProvider?.onLanguageClientSet(languageClient);
}
async onEvent(changeEvent) {
if (changeEvent.document.languageId !== "powershell") {
return;
}
if (changeEvent.contentChanges.length > 0) {
this.helpCompletionProvider?.updateState(
changeEvent.document,
changeEvent.contentChanges[0].text,
changeEvent.contentChanges[0].range
);
if (this.helpCompletionProvider?.triggerFound) {
await this.helpCompletionProvider.complete();
this.helpCompletionProvider.reset();
}
}
}
};
var TriggerFinder = class {
constructor(triggerCharacters) {
this.triggerCharacters = triggerCharacters;
this.state = 0 /* Searching */;
this.count = 0;
}
state;
document;
count;
get found() {
return this.state === 2 /* Found */;
}
updateState(document, changeText) {
switch (this.state) {
case 0 /* Searching */:
if (changeText.length === 1 && // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
changeText[0] === this.triggerCharacters[this.count]) {
this.state = 1 /* Locked */;
this.document = document;
this.count++;
}
break;
case 1 /* Locked */:
if (document === this.document && changeText.length === 1 && // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
changeText[0] === this.triggerCharacters[this.count]) {
this.count++;
if (this.count === this.triggerCharacters.length) {
this.state = 2 /* Found */;
}
} else {
this.reset();
}
break;
default:
this.reset();
break;
}
}
reset() {
this.state = 0 /* Searching */;
this.count = 0;
}
};
var HelpCompletionProvider = class extends LanguageClientConsumer {
triggerFinderHelpComment;
lastChangeRange;
lastDocument;
settings;
constructor() {
super();
this.triggerFinderHelpComment = new TriggerFinder("##");
this.settings = getSettings();
}
get triggerFound() {
return this.triggerFinderHelpComment.found;
}
onLanguageClientSet(_languageClient) {
}
updateState(document, changeText, changeRange) {
this.lastDocument = document;
this.lastChangeRange = changeRange;
this.triggerFinderHelpComment.updateState(document, changeText);
}
reset() {
this.triggerFinderHelpComment.reset();
}
async complete() {
if (this.lastChangeRange === void 0 || this.lastDocument === void 0) {
return;
}
const triggerStartPos = this.lastChangeRange.start;
const doc = this.lastDocument;
const client = await LanguageClientConsumer.getLanguageClient();
const result = await client.sendRequest(CommentHelpRequestType, {
documentUri: doc.uri.toString(),
triggerPosition: triggerStartPos,
blockComment: this.settings.helpCompletion === "BlockComment" /* BlockComment */
});
if (result.content.length === 0) {
return;
}
const replaceRange = new import_vscode4.Range(
triggerStartPos.translate(0, -1),
triggerStartPos.translate(0, 1)
);
const lines = result.content;
const text = lines.map((x) => x.trimStart()).join(this.getEOL(doc.eol));
const snippetString = new import_vscode4.SnippetString(text);
await import_vscode4.window.activeTextEditor?.insertSnippet(
snippetString,
replaceRange
);
}
getEOL(eol) {
if (eol === import_vscode4.EndOfLine.CRLF) {
return "\r\n";
}
return "\n";
}
};
// src/features/ISECompatibility.ts
var vscode16 = __toESM(require("vscode"));
var ISECompatibilityFeature = class _ISECompatibilityFeature {
// Marking settings as public so we can use it within the tests without needing to duplicate the list of settings.
static settings = [
{ path: "debug", name: "openDebug", value: "neverOpen" },
{ path: "editor", name: "tabCompletion", value: "on" },
{
path: "powershell.integratedConsole",
name: "focusConsoleOnExecute",
value: false
},
{ path: "files", name: "defaultLanguage", value: "powershell" },
{ path: "workbench", name: "colorTheme", value: "PowerShell ISE" },
{
path: "editor",
name: "wordSeparators",
value: "`~!@#%^&*()-=+[{]}\\|;:'\",.<>/?"
},
{
path: "powershell.buttons",
name: "showPanelMovementButtons",
value: true
},
{ path: "powershell.codeFolding", name: "showLastLine", value: false },
{
path: "powershell.sideBar",
name: "CommandExplorerVisibility",
value: true
}
];
commands = [];
iseModeEnabled;
originalSettings = {};
constructor() {
const testSetting = _ISECompatibilityFeature.settings[_ISECompatibilityFeature.settings.length - 1];
this.iseModeEnabled = vscode16.workspace.getConfiguration(testSetting.path).get(testSetting.name) === testSetting.value;
this.commands = [
vscode16.commands.registerCommand(
"PowerShell.EnableISEMode",
async () => {
await this.EnableISEMode();
}
),
vscode16.commands.registerCommand(
"PowerShell.DisableISEMode",
async () => {
await this.DisableISEMode();
}
),
vscode16.commands.registerCommand(
"PowerShell.ToggleISEMode",
async () => {
await this.ToggleISEMode();
}
)
];
}
dispose() {
for (const command of this.commands) {
command.dispose();
}
}
async EnableISEMode() {
this.iseModeEnabled = true;
for (const iseSetting of _ISECompatibilityFeature.settings) {
try {
const config = vscode16.workspace.getConfiguration(
iseSetting.path
);
this.originalSettings[iseSetting.path + iseSetting.name] = config.get(iseSetting.name);
await config.update(iseSetting.name, iseSetting.value, true);
} catch {
}
}
await vscode16.commands.executeCommand(
"workbench.view.extension.PowerShell"
);
}
async DisableISEMode() {
this.iseModeEnabled = false;
for (const iseSetting of _ISECompatibilityFeature.settings) {
const config = vscode16.workspace.getConfiguration(iseSetting.path);
const currently = config.get(iseSetting.name);
if (currently === iseSetting.value) {
await config.update(
iseSetting.name,
this.originalSettings[iseSetting.path + iseSetting.name],
true
);
}
}
}
async ToggleISEMode() {
if (this.iseModeEnabled) {
await this.DisableISEMode();
} else {
await this.EnableISEMode();
}
}
};
// src/features/OpenInISE.ts
var ChildProcess = require("child_process");
var vscode17 = require("vscode");
var OpenInISEFeature = class {
command;
constructor() {
this.command = vscode17.commands.registerCommand(
"PowerShell.OpenInISE",
() => {
const editor = vscode17.window.activeTextEditor;
if (editor === void 0) {
return;
}
const document = editor.document;
const uri = document.uri;
let ISEPath = process.env.windir ?? "C:\\Windows";
if (process.env.PROCESSOR_ARCHITEW6432 !== void 0) {
ISEPath += "\\Sysnative";
} else {
ISEPath += "\\System32";
}
ISEPath += "\\WindowsPowerShell\\v1.0\\powershell_ise.exe";
ChildProcess.exec(`${ISEPath} -File "${uri.fsPath}"`).unref();
}
);
}
dispose() {
this.command.dispose();
}
};
// src/features/PesterTests.ts
var path9 = __toESM(require("path"));
var vscode18 = require("vscode");
var utils5 = (init_utils(), __toCommonJS(utils_exports));
var PesterTestsFeature = class {
constructor(sessionManager2, logger2) {
this.sessionManager = sessionManager2;
this.logger = logger2;
this.invokePesterStubScriptPath = path9.resolve(
__dirname,
"../modules/PowerShellEditorServices/InvokePesterStub.ps1"
);
this.commands = [
// File context-menu command - Run Pester Tests
vscode18.commands.registerCommand(
"PowerShell.RunPesterTestsFromFile",
(fileUri) => {
return this.launchAllTestsInActiveEditor(
1 /* Run */,
fileUri
);
}
),
// File context-menu command - Debug Pester Tests
vscode18.commands.registerCommand(
"PowerShell.DebugPesterTestsFromFile",
(fileUri) => {
return this.launchAllTestsInActiveEditor(
0 /* Debug */,
fileUri
);
}
),
// This command is provided for usage by PowerShellEditorServices (PSES) only
vscode18.commands.registerCommand(
"PowerShell.RunPesterTests",
(uriString, runInDebugger, describeBlockName, describeBlockLineNumber, outputPath) => {
return this.launchTests(
vscode18.Uri.parse(uriString),
runInDebugger,
describeBlockName,
describeBlockLineNumber,
outputPath
);
}
)
];
}
commands;
invokePesterStubScriptPath;
dispose() {
for (const command of this.commands) {
command.dispose();
}
}
async launchAllTestsInActiveEditor(launchType, fileUri) {
fileUri ??= vscode18.window.activeTextEditor?.document.uri;
if (fileUri === void 0) {
return false;
}
const launchConfig = this.createLaunchConfig(fileUri, launchType);
return this.launch(launchConfig);
}
async launchTests(fileUri, runInDebugger, describeBlockName, describeBlockLineNumber, outputPath) {
const launchType = runInDebugger ? 0 /* Debug */ : 1 /* Run */;
const launchConfig = this.createLaunchConfig(
fileUri,
launchType,
describeBlockName,
describeBlockLineNumber,
outputPath
);
return this.launch(launchConfig);
}
createLaunchConfig(fileUri, launchType, testName, lineNum, outputPath) {
const settings = getSettings();
const launchConfig = {
request: "launch",
type: "PowerShell",
name: "PowerShell: Launch Pester Tests",
script: this.invokePesterStubScriptPath,
args: [
"-ScriptPath",
`'${utils5.escapeSingleQuotes(fileUri.fsPath)}'`
],
internalConsoleOptions: "neverOpen",
noDebug: launchType === 1 /* Run */,
createTemporaryIntegratedConsole: settings.debugging.createTemporaryIntegratedConsole
};
if (lineNum) {
launchConfig.args.push("-LineNumber", `${lineNum}`);
} else if (testName) {
launchConfig.args.push(
"-TestName",
`'${utils5.escapeSingleQuotes(testName)}'`
);
} else {
launchConfig.args.push("-All");
}
if (!settings.pester.useLegacyCodeLens) {
launchConfig.args.push("-MinimumVersion5");
}
if (launchType === 0 /* Debug */) {
launchConfig.args.push(
"-Output",
`'${settings.pester.debugOutputVerbosity}'`
);
} else {
launchConfig.args.push(
"-Output",
`'${settings.pester.outputVerbosity}'`
);
}
if (outputPath) {
launchConfig.args.push("-OutputPath", `'${outputPath}'`);
}
return launchConfig;
}
async launch(launchConfig) {
this.sessionManager.showDebugTerminal(true);
return await utils5.checkIfFileExists(this.invokePesterStubScriptPath) && vscode18.debug.startDebugging(
await getChosenWorkspace(this.logger),
launchConfig
);
}
};
// src/features/RemoteFiles.ts
var import_vscode_languageclient8 = __toESM(require_main4());
var os4 = require("os");
var path10 = require("path");
var vscode19 = require("vscode");
var DidSaveTextDocumentNotificationType = new import_vscode_languageclient8.NotificationType("textDocument/didSave");
var RemoteFilesFeature = class extends LanguageClientConsumer {
command;
tempSessionPathPrefix;
constructor() {
super();
this.tempSessionPathPrefix = path10.join(os4.tmpdir(), "PSES-").toLowerCase();
this.closeRemoteFiles();
this.command = vscode19.workspace.onDidSaveTextDocument(async (doc) => {
if (this.isDocumentRemote(doc)) {
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendNotification(
DidSaveTextDocumentNotificationType,
{
textDocument: import_vscode_languageclient8.TextDocumentIdentifier.create(
doc.uri.toString()
)
}
);
}
});
}
onLanguageClientSet(_languageClient) {
}
dispose() {
this.command.dispose();
this.closeRemoteFiles();
}
isDocumentRemote(doc) {
return doc.fileName.toLowerCase().startsWith(this.tempSessionPathPrefix);
}
closeRemoteFiles() {
const remoteDocuments = vscode19.workspace.textDocuments.filter(
(doc) => this.isDocumentRemote(doc)
);
async function innerCloseFiles() {
const doc = remoteDocuments.pop();
if (doc === void 0) {
return;
}
await vscode19.window.showTextDocument(doc);
await vscode19.commands.executeCommand(
"workbench.action.closeActiveEditor"
);
await innerCloseFiles();
}
void innerCloseFiles();
}
};
// src/features/ShowHelp.ts
var import_vscode_languageclient9 = __toESM(require_main4());
var vscode20 = require("vscode");
var ShowHelpNotificationType = new import_vscode_languageclient9.NotificationType("powerShell/showHelp");
var ShowHelpFeature = class extends LanguageClientConsumer {
command;
constructor() {
super();
this.command = vscode20.commands.registerCommand(
"PowerShell.ShowHelp",
async (item) => {
if (!item?.Name) {
const editor = vscode20.window.activeTextEditor;
if (editor === void 0) {
return;
}
const selection = editor.selection;
const doc = editor.document;
const cwr = doc.getWordRangeAtPosition(selection.active);
const text = doc.getText(cwr);
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendNotification(ShowHelpNotificationType, {
text
});
} else {
const client = await LanguageClientConsumer.getLanguageClient();
await client.sendNotification(ShowHelpNotificationType, {
text: item.Name
});
}
}
);
}
onLanguageClientSet(_languageClient) {
}
dispose() {
this.command.dispose();
}
};
// src/extension.ts
init_utils();
var vscode21 = require("vscode");
var TELEMETRY_KEY = "0c6ae279ed8443289764825290e4f9e2-1a736e7c-1324-4338-be46-fc2a58ae4d14-7255";
var languageConfigurationDisposable;
var logger;
var sessionManager;
var languageClientConsumers = [];
var commandRegistrations = [];
var telemetryReporter;
var documentSelector = [
{ language: "powershell", scheme: "file" },
{ language: "powershell", scheme: "untitled" }
];
async function activate(context) {
logger = new Logger();
if (context.extensionMode === vscode21.ExtensionMode.Development) {
restartOnExtensionFileChanges(context);
}
telemetryReporter = new import_extension_telemetry.default(TELEMETRY_KEY);
const settings = getSettings();
logger.writeDebug(
`Loaded settings:
${JSON.stringify(settings, void 0, 2)}`
);
languageConfigurationDisposable = vscode21.languages.setLanguageConfiguration(
PowerShellLanguageId,
{
// TODO: Remove the useless escapes
wordPattern: (
// eslint-disable-next-line no-useless-escape
/(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\'\"\,\.\<\>\/\?\s]+)/g
),
indentationRules: {
// ^(.*\*/)?\s*\}.*$
decreaseIndentPattern: /^(.*\*\/)?\s*\}.*$/,
// ^.*\{[^}"']*$
increaseIndentPattern: /^.*\{[^}"']*$/
},
comments: {
lineComment: "#",
blockComment: ["<#", "#>"]
},
brackets: [
["{", "}"],
["[", "]"],
["(", ")"]
],
onEnterRules: [
{
// e.g. /** | */
// eslint-disable-next-line no-useless-escape
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
afterText: /^\s*\*\/$/,
action: {
indentAction: vscode21.IndentAction.IndentOutdent,
appendText: " * "
}
},
{
// e.g. /** ...|
// eslint-disable-next-line no-useless-escape
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
action: {
indentAction: vscode21.IndentAction.None,
appendText: " * "
}
},
{
// e.g. * ...|
// eslint-disable-next-line no-useless-escape
beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
action: {
indentAction: vscode21.IndentAction.None,
appendText: "* "
}
},
{
// e.g. */|
// eslint-disable-next-line no-useless-escape
beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
action: {
indentAction: vscode21.IndentAction.None,
removeText: 1
}
},
{
// e.g. *-----*/|
// eslint-disable-next-line no-useless-escape
beforeText: /^(\t|(\ \ ))*\ \*[^/]*\*\/\s*$/,
action: {
indentAction: vscode21.IndentAction.None,
removeText: 1
}
}
]
}
);
const packageInfo = context.extension.packageJSON;
sessionManager = new SessionManager(
context,
settings,
logger,
documentSelector,
packageInfo.name,
packageInfo.displayName,
packageInfo.version,
packageInfo.publisher,
telemetryReporter
);
commandRegistrations = [
new ExamplesFeature(),
new GenerateBugReportFeature(sessionManager),
new ISECompatibilityFeature(),
new OpenInISEFeature(),
new PesterTestsFeature(sessionManager, logger),
new CodeActionsFeature(logger),
new SpecifyScriptArgsFeature(context),
vscode21.commands.registerCommand(
"PowerShell.OpenLogFolder",
async () => {
await vscode21.commands.executeCommand(
"vscode.openFolder",
context.logUri,
{ forceNewWindow: true }
);
}
),
vscode21.commands.registerCommand("PowerShell.ShowLogs", () => {
logger.showLogPanel();
}),
vscode21.commands.registerCommand(
"GetVsCodeSessionId",
() => vscode21.env.sessionId
),
// Register a command that waits for the Extension Terminal to be active. Can be used by .NET Attach Tasks.
registerWaitForPsesActivationCommand(context)
];
const externalApi = new ExternalApiFeature(context, sessionManager, logger);
languageClientConsumers = [
new ConsoleFeature(logger),
new ExpandAliasFeature(),
new GetCommandsFeature(),
new ShowHelpFeature(),
new ExtensionCommandsFeature(logger),
new RemoteFilesFeature(),
new DebugSessionFeature(context, sessionManager, logger),
new HelpCompletionFeature()
];
sessionManager.setLanguageClientConsumers(languageClientConsumers);
if (settings.startAutomatically) {
await sessionManager.start();
}
return {
registerExternalExtension: (id, apiVersion = "v1") => externalApi.registerExternalExtension(id, apiVersion),
unregisterExternalExtension: (uuid) => externalApi.unregisterExternalExtension(uuid),
getPowerShellVersionDetails: (uuid) => externalApi.getPowerShellVersionDetails(uuid),
waitUntilStarted: (uuid) => externalApi.waitUntilStarted(uuid),
getStorageUri: () => externalApi.getStorageUri(),
getLogUri: () => externalApi.getLogUri()
};
}
function registerWaitForPsesActivationCommand(context) {
return vscode21.commands.registerCommand(
"PowerShell.WaitForPsesActivationAndReturnProcessId",
async () => {
const pidFileName = `PSES-${vscode21.env.sessionId}.pid`;
const pidFile = vscode21.Uri.joinPath(
context.globalStorageUri,
"sessions",
pidFileName
);
const fs = vscode21.workspace.fs;
while (true) {
try {
const pidContent = await fs.readFile(pidFile);
const pid = parseInt(pidContent.toString(), 10);
try {
const NODE_TEST_PROCESS_EXISTENCE = 0;
process.kill(pid, NODE_TEST_PROCESS_EXISTENCE);
} catch {
await fs.delete(pidFile);
continue;
}
return pidContent.toString();
} catch {
await sleep(200);
}
}
}
);
}
function restartOnExtensionFileChanges(context) {
const watcher = vscode21.workspace.createFileSystemWatcher(
new vscode21.RelativePattern(context.extensionPath, "dist/*.js")
);
context.subscriptions.push(watcher);
watcher.onDidChange(({ fsPath }) => {
vscode21.window.showInformationMessage(
`${fsPath.split(context.extensionPath, 2)[1]} changed. Reloading Extension Host...`
);
vscode21.commands.executeCommand("workbench.action.restartExtensionHost");
});
}
async function deactivate() {
for (const commandRegistration of commandRegistrations) {
commandRegistration.dispose();
}
await sessionManager.dispose();
logger.dispose();
await telemetryReporter.dispose();
languageConfigurationDisposable.dispose();
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
activate,
deactivate
});
/*! Bundled license information:
@microsoft/1ds-core-js/dist/es5/ms.core.js:
(*!
* 1DS JS SDK Core, 4.3.10
* Copyright (c) Microsoft and contributors. All rights reserved.
* (Microsoft Internal Only)
*)
(*! https://github.com/nevware21/ts-utils v0.12.5 *)
(*!
* NevWare21 Solutions LLC - ts-async, 0.5.4
* https://github.com/nevware21/ts-async
* Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.
* Licensed under the MIT license.
*)
@microsoft/1ds-post-js/dist/es5/ms.post.js:
(*!
* 1DS JS SDK POST plugin, 4.3.10
* Copyright (c) Microsoft and contributors. All rights reserved.
* (Microsoft Internal Only)
*)
(*! https://github.com/nevware21/ts-utils v0.12.5 *)
(*!
* NevWare21 Solutions LLC - ts-async, 0.5.4
* https://github.com/nevware21/ts-async
* Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.
* Licensed under the MIT license.
*)
@microsoft/applicationinsights-common/dist/es5/applicationinsights-common.js:
(*!
* Application Insights JavaScript SDK - Common, 3.3.10
* Copyright (c) Microsoft and contributors. All rights reserved.
*)
(*! https://github.com/nevware21/ts-utils v0.12.5 *)
@microsoft/applicationinsights-web-basic/dist/es5/applicationinsights-web-basic.js:
(*!
* Application Insights JavaScript Web SDK - Basic, 3.3.10
* Copyright (c) Microsoft and contributors. All rights reserved.
*)
(*! https://github.com/nevware21/ts-utils v0.12.5 *)
(*!
* NevWare21 Solutions LLC - ts-async, 0.5.4
* https://github.com/nevware21/ts-async
* Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.
* Licensed under the MIT license.
*)
*/
//# sourceMappingURL=extension.js.map