asab_webui_components 25.1.1

package/dist/utils/deepMerge.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepMerge = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+// Function to check if a value is an object but not an array
+var isObject = function isObject(obj) {
+  return obj && (0, _typeof2["default"])(obj) === 'object' && !Array.isArray(obj);
+};
+
+// Util function for deep merging of objects
+var _deepMerge = exports.deepMerge = function deepMerge(target) {
+  for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    sources[_key - 1] = arguments[_key];
+  }
+  // If no sources are provided, return the target object as is
+  if (!sources.length) return target;
+
+  // Iterate through each source object provided
+  for (var _i = 0, _sources = sources; _i < _sources.length; _i++) {
+    var source = _sources[_i];
+    // Ensure both target and source are objects before merging
+    if (isObject(target) && isObject(source)) {
+      // Iterate through each key in the source object
+      for (var key in source) {
+        // If the value of the current key is an object, perform a recursive deep merge
+        if (isObject(source[key])) {
+          // If the key does not exist in the target, initialize it as an empty object
+          if (!target[key]) {
+            target[key] = {};
+          }
+          // Recursively merge the nested objects
+          _deepMerge(target[key], source[key]);
+        } else {
+          // For non-object values, directly assign the value to the target
+          target[key] = source[key];
+        }
+      }
+    }
+  }
+
+  // Return the merged object
+  return target;
+};

package/dist/utils/deepMerge.jsx

@@ -0,0 +1,33 @@
+// Function to check if a value is an object but not an array
+const isObject = (obj) => obj && (typeof obj === 'object') && !Array.isArray(obj);
+
+// Util function for deep merging of objects
+export const deepMerge = (target, ...sources) => {
+	// If no sources are provided, return the target object as is
+	if (!sources.length) return target;
+
+	// Iterate through each source object provided
+	for (const source of sources) {
+		// Ensure both target and source are objects before merging
+		if (isObject(target) && isObject(source)) {
+			// Iterate through each key in the source object
+			for (const key in source) {
+				// If the value of the current key is an object, perform a recursive deep merge
+				if (isObject(source[key])) {
+					// If the key does not exist in the target, initialize it as an empty object
+					if (!target[key]) {
+						target[key] = {};
+					}
+					// Recursively merge the nested objects
+					deepMerge(target[key], source[key]);
+				} else {
+					// For non-object values, directly assign the value to the target
+					target[key] = source[key];
+				}
+			}
+		}
+	}
+
+	// Return the merged object
+	return target;
+};

package/dist/utils/hexToString.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexToString = hexToString;
+/*
+	The hexToString function converts a hexadecimal string into its corresponding ASCII string
+
+	Example of usage:
+
+	const hex = '48656c6c6f20576f726c64'
+	const asciiString = hexToString(hex);
+	
+	console.log(asciiString); // Output: 'Hello World'
+
+*/
+
+// Convert a hex string into ASCII string
+function hexToString(hex) {
+  var str = '';
+  for (var i = 0; i < hex.length; i += 2) {
+    str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+  }
+  return str;
+}
+;

package/dist/utils/isPrivateIP.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPrivateIP = isPrivateIP;
+/* 
+	The isPrivateIP function checks if a given IP address is a private IP address.
+	This function supports both IPv4 and IPv6 formats.
+
+	Example of usage:
+
+	const ip1 = '192.168.1.1';
+	const result1 = isPrivate(ip1);
+	console.log(result1); // Output: true
+*/
+
+// Utility function to check if an IP address is private
+function isPrivateIP(ip) {
+  var privateIPv4Ranges = [/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, /^172\.(1[6-9]|2\d|3[0-1])\.\d{1,3}\.\d{1,3}$/, /^192\.168\.\d{1,3}\.\d{1,3}$/];
+  var privateIPv6Ranges = [/^fc00:/, /^fd00:/];
+
+  // Check if the IP is a private IPv4 address
+  if (privateIPv4Ranges.some(function (range) {
+    return range.test(ip);
+  })) {
+    return true;
+  }
+
+  // Check if the IP is a private IPv6 address
+  if (privateIPv6Ranges.some(function (range) {
+    return range.test(ip);
+  })) {
+    return true;
+  }
+  return false;
+}

package/dist/utils/isValidIP.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidIP = isValidIP;
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/* 
+	The isValidIPAddress function checks if a given IP address is a valid IP address.
+
+	Example of usage:
+
+	const ip1 = '192.168.1.1';
+	const result1 = isValidIP(ip1);
+	console.log(result1); // Output: true
+*/
+
+// Function to check if IP address is valid IPv4 or IPv6 address
+function isValidIP(ip) {
+  if (ip == undefined || typeof ip !== 'string' || ip === '') {
+    // Check  if address is string and not empty
+    return false;
+  }
+  return isValidIPv4(ip) || isValidIPv6(ip);
+}
+
+// Function to validate IPv4 address
+function isValidIPv4(ip) {
+  var octets = ip.split('.'); // Octet is on of the segments of an IP address
+  if (octets.length !== 4) return false; // Check if there are exactly 4 octets
+  var _iterator = _createForOfIteratorHelper(octets),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var octet = _step.value;
+      var num = Number(octet);
+      if (num < 0 || num > 255 || octet !== String(num)) {
+        // Check if is valid number or has leading zeros
+        return false;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return true; // Valid IPv4
+}
+;
+
+//  Function to validate IPv6 address
+function isValidIPv6(ip) {
+  var blocks = ip.split(':');
+  if (blocks.length < 3 || blocks.length > 8) return false; // Check if there are between 3 and 8 blocks
+
+  var doubleColonCount = 0; // Count occurrences of '::'
+  var _iterator2 = _createForOfIteratorHelper(blocks),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var block = _step2.value;
+      if (block === '') {
+        doubleColonCount++;
+        continue; // Skip empty blocks (indicating '::')
+      }
+
+      // Check if the block is a valid hex block
+      if (block.length > 4 || !/^[0-9a-fA-F]{0,4}$/.test(block)) {
+        // Regex check for valid hexadecimal digit (numbers 1-9, letters a-f)
+        return false;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return doubleColonCount <= 1; // Valid if '::' appears only once
+}
+;

package/dist/utils/itemExtensionHandler.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.itemExtensionHandler = itemExtensionHandler;
+/*
+itemExtensionHandler checks if the variable has an extension and returns it
+This function takes 2 arguments:
+	- itemName - string
+	- extension - string, file extension in this format '.json' or '.yaml'
+ */
+function itemExtensionHandler(itemName, extension) {
+  // Get the last five characters of itemName for extension checking
+  var lastFiveChars = itemName.slice(-5);
+  // Check if itemName already has an extension that's not '.io' or '.d'
+  if (lastFiveChars.includes('.') && !itemName.endsWith('.io') && !itemName.endsWith('.d')) {
+    // If itemName has a non-special extension, return the original itemName
+    return itemName;
+  }
+
+  // If itemName has no valid extension, add the new extension
+  return "".concat(itemName).concat(extension);
+}

package/dist/utils/localStorage.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFromLS = getFromLS;
+exports.removeFromLS = removeFromLS;
+exports.saveToLS = saveToLS;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+/*
+	Reusable utils for saving, getting and removing LocalStorage content.
+
+	`params` property is optional
+
+	Example of usage:
+
+	- Save:
+		saveToLS("My Storage key", "My URL params", "filter=abc&size=99");
+		saveToLS("My Other key", "123 abc");
+	- Get:
+		getFromLS("My Storage key");
+	- Remove:
+		removeFromLS("My Storage key");
+*/
+
+// Save pathname and params to localstorage
+function saveToLS(key, entry, params) {
+  if (global.localStorage) {
+    if (params) {
+      // For pathname save to LS
+      global.localStorage.setItem(key.toString(), JSON.stringify((0, _defineProperty2["default"])({}, entry, params)));
+    } else {
+      // For favourite fields save to LS
+      global.localStorage.setItem(key.toString(), JSON.stringify(entry));
+    }
+  }
+}
+
+// Get pathname and params from localstorage
+function getFromLS(key, entry) {
+  var ls = {};
+  if (global.localStorage) {
+    try {
+      ls = JSON.parse(global.localStorage.getItem(key === null || key === void 0 ? void 0 : key.toString())) || {};
+    } catch (e) {
+      /*Ignore*/
+    }
+    if (entry) {
+      ls = ls[entry] ? ls[entry] : {};
+    }
+  }
+  return ls;
+}
+
+// Remove item from localstorage
+function removeFromLS(key) {
+  if (global.localStorage) {
+    try {
+      global.localStorage.removeItem(key.toString());
+    } catch (e) {
+      /*Ignore*/
+    }
+  }
+}

package/dist/utils/lookups/isoCodeCountries.js

@@ -0,0 +1,264 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isoCodeCountries = void 0;
+/*
+	The ISO codes for countries are aligned with the ISO 3166-2,
+	which is an international standard of short alphanumeric codes to represent
+	relevant countries.
+	The list was taken from: https://en.wikipedia.org/wiki/ISO_3166-2
+*/
+
+var isoCodeCountries = exports.isoCodeCountries = {
+  "AD": "Andorra",
+  "AE": "United Arab Emirates",
+  "AF": "Afghanistan",
+  "AG": "Antigua and Barbuda",
+  "AI": "Anguilla",
+  "AL": "Albania",
+  "AM": "Armenia",
+  "AO": "Angola",
+  "AQ": "Antarctica",
+  "AR": "Argentina",
+  "AS": "American Samoa",
+  "AT": "Austria",
+  "AU": "Australia",
+  "AW": "Aruba",
+  "AX": "Åland Islands",
+  "AZ": "Azerbaijan",
+  "BA": "Bosnia and Herzegovina",
+  "BB": "Barbados",
+  "BD": "Bangladesh",
+  "BE": "Belgium",
+  "BF": "Burkina Faso",
+  "BG": "Bulgaria",
+  "BH": "Bahrain",
+  "BI": "Burundi",
+  "BJ": "Benin",
+  "BL": "Saint Barthélemy",
+  "BM": "Bermuda",
+  "BN": "Brunei Darussalam",
+  "BO": "Bolivia, Plurinational State of",
+  "BQ": "Bonaire, Sint Eustatius and Saba",
+  "BR": "Brazil",
+  "BS": "Bahamas",
+  "BT": "Bhutan",
+  "BV": "Bouvet Island",
+  "BW": "Botswana",
+  "BY": "Belarus",
+  "BZ": "Belize",
+  "CA": "Canada",
+  "CC": "Cocos (Keeling) Islands",
+  "CD": "Congo, Democratic Republic of the",
+  "CF": "Central African Republic",
+  "CG": "Congo",
+  "CH": "Switzerland",
+  "CI": "Côte d'Ivoire",
+  "CK": "Cook Islands",
+  "CL": "Chile",
+  "CM": "Cameroon",
+  "CN": "China",
+  "CO": "Colombia",
+  "CR": "Costa Rica",
+  "CU": "Cuba",
+  "CV": "Cape Verde",
+  "CW": "Curaçao",
+  "CX": "Christmas Island",
+  "CY": "Cyprus",
+  "CZ": "Czechia",
+  "DE": "Germany",
+  "DJ": "Djibouti",
+  "DK": "Denmark",
+  "DM": "Dominica",
+  "DO": "Dominican Republic",
+  "DZ": "Algeria",
+  "EC": "Ecuador",
+  "EE": "Estonia",
+  "EG": "Egypt",
+  "EH": "Western Sahara",
+  "ER": "Eritrea",
+  "ES": "Spain",
+  "ET": "Ethiopia",
+  "FI": "Finland",
+  "FJ": "Fiji",
+  "FK": "Falkland Islands (Malvinas)",
+  "FM": "Micronesia, Federated States of",
+  "FO": "Faroe Islands",
+  "FR": "France",
+  "GA": "Gabon",
+  "GB": "United Kingdom of Great Britain and Northern Ireland",
+  "GD": "Grenada",
+  "GE": "Georgia",
+  "GF": "French Guiana",
+  "GG": "Guernsey",
+  "GH": "Ghana",
+  "GI": "Gibraltar",
+  "GL": "Greenland",
+  "GM": "Gambia",
+  "GN": "Guinea",
+  "GP": "Guadeloupe",
+  "GQ": "Equatorial Guinea",
+  "GR": "Greece",
+  "GS": "South Georgia and the South Sandwich Islands",
+  "GT": "Guatemala",
+  "GU": "Guam",
+  "GW": "Guinea-Bissau",
+  "GY": "Guyana",
+  "HK": "Hong Kong",
+  "HM": "Heard Island and Mcdonald Islands",
+  "HN": "Honduras",
+  "HR": "Croatia",
+  "HT": "Haiti",
+  "HU": "Hungary",
+  "ID": "Indonesia",
+  "IE": "Ireland",
+  "IL": "Israel",
+  "IM": "Isle of Man",
+  "IN": "India",
+  "IO": "British Indian Ocean Territory",
+  "IQ": "Iraq",
+  "IR": "Iran, Islamic Republic Of",
+  "IS": "Iceland",
+  "IT": "Italy",
+  "JE": "Jersey",
+  "JM": "Jamaica",
+  "JO": "Jordan",
+  "JP": "Japan",
+  "KE": "Kenya",
+  "KG": "Kyrgyzstan",
+  "KH": "Cambodia",
+  "KI": "Kiribati",
+  "KM": "Comoros",
+  "KN": "Saint Kitts and Nevis",
+  "KP": "Korea, Democratic People's Republic of",
+  "KR": "Korea, Republic of",
+  "KW": "Kuwait",
+  "KY": "Cayman Islands",
+  "KZ": "Kazakhstan",
+  "LA": "Lao People'S Democratic Republic",
+  "LB": "Lebanon",
+  "LC": "Saint Lucia",
+  "LI": "Liechtenstein",
+  "LK": "Sri Lanka",
+  "LR": "Liberia",
+  "LS": "Lesotho",
+  "LT": "Lithuania",
+  "LU": "Luxembourg",
+  "LV": "Latvia",
+  "LY": "Libya",
+  "MA": "Morocco",
+  "MC": "Monaco",
+  "MD": "Moldova, Republic of",
+  "ME": "Montenegro",
+  "MF": "Saint Martin",
+  "MG": "Madagascar",
+  "MH": "Marshall Islands",
+  "MK": "North Macedonia",
+  "ML": "Mali",
+  "MM": "Myanmar",
+  "MN": "Mongolia",
+  "MO": "Macao",
+  "MP": "Northern Mariana Islands",
+  "MQ": "Martinique",
+  "MR": "Mauritania",
+  "MS": "Montserrat",
+  "MT": "Malta",
+  "MU": "Mauritius",
+  "MV": "Maldives",
+  "MW": "Malawi",
+  "MX": "Mexico",
+  "MY": "Malaysia",
+  "MZ": "Mozambique",
+  "NA": "Namibia",
+  "NC": "New Caledonia",
+  "NE": "Niger",
+  "NF": "Norfolk Island",
+  "NG": "Nigeria",
+  "NI": "Nicaragua",
+  "NL": "Netherlands, Kingdom of the",
+  "NO": "Norway",
+  "NP": "Nepal",
+  "NR": "Nauru",
+  "NU": "Niue",
+  "NZ": "New Zealand",
+  "OM": "Oman",
+  "PA": "Panama",
+  "PE": "Peru",
+  "PF": "French Polynesia",
+  "PG": "Papua New Guinea",
+  "PH": "Philippines",
+  "PK": "Pakistan",
+  "PL": "Poland",
+  "PM": "Saint Pierre and Miquelon",
+  "PN": "Pitcairn",
+  "PR": "Puerto Rico",
+  "PS": "Palestine, State of",
+  "PT": "Portugal",
+  "PW": "Palau",
+  "PY": "Paraguay",
+  "QA": "Qatar",
+  "RE": "Reunion",
+  "RO": "Romania",
+  "RS": "Serbia",
+  "RU": "Russian Federation",
+  "RW": "Rwanda",
+  "SA": "Saudi Arabia",
+  "SB": "Solomon Islands",
+  "SC": "Seychelles",
+  "SD": "Sudan",
+  "SE": "Sweden",
+  "SG": "Singapore",
+  "SH": "Saint Helena, Ascension and Tristan da Cunha",
+  "SI": "Slovenia",
+  "SJ": "Svalbard and Jan Mayen",
+  "SK": "Slovakia",
+  "SL": "Sierra Leone",
+  "SM": "San Marino",
+  "SN": "Senegal",
+  "SO": "Somalia",
+  "SR": "Suriname",
+  "SS": "South Sudan",
+  "ST": "Sao Tome and Principe",
+  "SV": "El Salvador",
+  "SX": "Sint Maarten",
+  "SY": "Syrian Arab Republic",
+  "SZ": "Eswatini",
+  "TC": "Turks and Caicos Islands",
+  "TD": "Chad",
+  "TF": "French Southern Territories",
+  "TG": "Togo",
+  "TH": "Thailand",
+  "TJ": "Tajikistan",
+  "TK": "Tokelau",
+  "TL": "Timor-Leste",
+  "TM": "Turkmenistan",
+  "TN": "Tunisia",
+  "TO": "Tonga",
+  "TR": "Türkiye",
+  "TT": "Trinidad and Tobago",
+  "TV": "Tuvalu",
+  "TW": "Taiwan, Province of China",
+  "TZ": "Tanzania, United Republic of",
+  "UA": "Ukraine",
+  "UG": "Uganda",
+  "UM": "United States Minor Outlying Islands",
+  "US": "United States of America",
+  "UY": "Uruguay",
+  "UZ": "Uzbekistan",
+  "VA": "Holy See",
+  "VC": "Saint Vincent and the Grenadines",
+  "VE": "Venezuela, Bolivian Republic of",
+  "VG": "Virgin Islands, British",
+  "VI": "Virgin Islands, U.S.",
+  "VN": "Viet Nam",
+  "VU": "Vanuatu",
+  "WF": "Wallis and Futuna",
+  "WS": "Samoa",
+  "YE": "Yemen",
+  "YT": "Mayotte",
+  "ZA": "South Africa",
+  "ZM": "Zambia",
+  "ZW": "Zimbabwe"
+};

package/dist/utils/monaco/problemMarkers.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.problemMarkers = void 0;
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/*
+	Monaco editor problem markers
+
+	This is to be used only with Monaco editor!
+
+	Example of usage
+
+	```
+		import * as monaco from 'monaco-editor'; // Import monaco
+		...
+
+		const model = editorRef.current.getModel(); // Set model (this is just an example)
+		...
+
+		// Use setProblemMarkers as a method wherever needed to set a problem markers
+		const setProblemMarkers = (problems, model) => {
+			// Use problemMarkers util from asab webui components to get the monaco markers
+			const markers = problemMarkers({problems, model});
+
+			monaco.editor.setModelMarkers(model, 'owner', markers);
+		};
+		...
+	```
+
+*/
+
+var problemMarkers = exports.problemMarkers = function problemMarkers(_ref) {
+  var problems = _ref.problems,
+    model = _ref.model;
+  var markers = [];
+  if (problems) {
+    var _iterator = _createForOfIteratorHelper(problems),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var problem = _step.value;
+        var message = problem.message || problem.problem; // Fallback on problem
+        // Validation on empty lines
+        if (message && !message.endsWith('\n\n')) {
+          // Add a empty line to the end of a message if the message ends with less than 2 newlines
+          if (!message.endsWith('\n')) {
+            message = message + '\n\n';
+          } else {
+            message = message + '\n';
+          }
+        }
+        markers.push({
+          message: message,
+          severity: problem.severity || 8,
+          // 1 = hint, 2 = info, 4 = warning, 8 = error
+          startLineNumber: problem.line_start || problem.line,
+          startColumn: problem.column_start || problem.column,
+          endLineNumber: problem.line_end || problem.line,
+          endColumn: problem.column_end || problem.column_start && (model === null || model === void 0 ? void 0 : model.getLineLength(problem.column_start)) + 1 || problem.line && (model === null || model === void 0 ? void 0 : model.getLineLength(problem.line)) + 1,
+          tags: problem.tags || null,
+          // Example [2] (possible values 2 | 1)
+          code: problem.code || null,
+          // Example { target: 'https://teskalabs.com', value: 'TeskaLabs' }
+          source: problem.source || null // Example 'asab-parser'
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return markers;
+};