@fc-components/monaco-editor 0.1.1

package/dist/monaco-editor.esm.js

@@ -0,0 +1,2164 @@
+import React, { useRef, useEffect } from 'react';
+import MonacoEditor from 'react-monaco-editor';
+import * as monaco from 'monaco-editor';
+import { languages, editor, KeyMod, KeyCode, Range, MarkerSeverity } from 'monaco-editor';
+import { promLanguageDefinition } from 'monaco-promql';
+import { parser, LabelMatchers, VectorSelector, PromQL, FunctionCallBody, StringLiteral, UnquotedLabelMatcher, BinaryExpr, NumberDurationLiteralInDurationContext, MatrixSelector, GroupingLabels, AggregateModifier, AggregateExpr, Identifier, LabelName, MatchOp, EqlSingle, EqlRegex, Neq, NeqRegex } from '@fc-components/lezer-metricsql';
+import { v4 } from 'uuid';
+import { css } from '@emotion/css';
+import UFuzzy from '@leeoniya/ufuzzy';
+
+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;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = !1,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = !0, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), !0), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    if (r) i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n;else {
+      function o(r, n) {
+        _regeneratorDefine(e, r, function (e) {
+          return this._invoke(r, n, e);
+        });
+      }
+      o("next", 0), o("throw", 1), o("return", 2);
+    }
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+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 _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+
+var languageConfiguration = {
+  // the default separators except `@$`
+  wordPattern: /(-?\d*\.\d\w*)|([^`~!#%^&*()\-=+\[{\]}\\|;:'",.<>\/?\s]+)/g,
+  // Not possible to make comments in PromQL syntax
+  comments: {
+    lineComment: '#'
+  },
+  brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+  autoClosingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '(',
+    close: ')'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }],
+  surroundingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '(',
+    close: ')'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }, {
+    open: '<',
+    close: '>'
+  }],
+  folding: {}
+};
+// PromQL Aggregation Operators
+// (https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators)
+var aggregations = ['sum', 'min', 'max', 'avg', 'group', 'stddev', 'stdvar', 'count', 'count_values', 'bottomk', 'topk', 'quantile', 'quantiles', 'distinct', 'geomean', 'histogram', 'mad', 'mode',
+// metricsql aggregations
+'any', 'bottomk_avg', 'bottomk_max', 'bottomk_median', 'bottomk_last', 'bottomk_min', 'topk_avg', 'topk_max', 'topk_median', 'topk_last', 'topk_min', 'outliers_mad', 'outliersk', 'share', 'sum2', 'zscore'];
+// PromQL functions
+// (https://prometheus.io/docs/prometheus/latest/querying/functions/)
+var functions = ['abs', 'absent', 'ceil', 'changes', 'clamp_max', 'clamp_min', 'day_of_month', 'day_of_week', 'days_in_month', 'delta', 'deriv', 'exp', 'floor', 'histogram_quantile', 'histogram_avg', 'histogram_count', 'histogram_sum', 'histogram_fraction', 'histogram_stddev', 'histogram_stdvar', 'holt_winters', 'hour', 'idelta', 'increase', 'irate', 'label_join', 'label_replace', 'ln', 'log2', 'log10', 'minute', 'month', 'predict_linear', 'rate', 'resets', 'round', 'scalar', 'sort', 'sort_desc', 'sqrt', 'time', 'timestamp', 'vector', 'year',
+// metricsql functions
+'aggr_over_time', 'alias', 'ascent_over_time', 'bitmap_and', 'bitmap_or', 'bitmap_xor', 'buckets_limit', 'changes_prometheus', 'count_eq_over_time', 'count_gt_over_time', 'count_le_over_time', 'count_ne_over_time', 'decreases_over_time', 'default_rollup', 'delta_prometheus', 'deriv_fast', 'descent_over_time', 'distinct_over_time', 'drop_common_labels', 'duration_over_time', 'first_over_time', 'geomean_over_time', 'histogram_avg', 'histogram_over_time', 'histogram_quantiles', 'histogram_share', 'hoeffding_bound_lower', 'hoeffding_bound_upper', 'ideriv', 'increase_prometheus', 'increase_pure', 'increases_over_time', 'integrate', 'interpolate', 'keep_last_value', 'keep_next_value', 'label_copy', 'label_del', 'label_graphite_group', 'label_keep', 'label_lowercase', 'label_map', 'label_match', 'label_mismatch', 'label_move', 'label_set', 'label_transform', 'label_uppercase', 'label_value', 'lag', 'lifetime', 'limit_offset', 'mad_over_time', 'median_over_time', 'mode_over_time', 'now', 'prometheus_buckets', 'quantiles_over_time', 'rand', 'rand_exponential', 'rand_normal', 'range_avg', 'range_first', 'range_last', 'range_linear_regression', 'range_mad', 'range_max', 'range_min', 'range_normalize', 'range_over_time', 'range_quantile', 'range_stddev', 'range_stdvar', 'range_sum', 'range_trim_outliers', 'range_trim_spikes', 'range_trim_zscore', 'range_zscore', 'rate_over_sum', 'remove_resets', 'rollup', 'rollup_candlestick', 'rollup_delta', 'rollup_deriv', 'rollup_increase', 'rollup_rate', 'rollup_scrape_interval', 'running_avg', 'running_max', 'running_min', 'running_sum', 'scrape_interval', 'share_eq_over_time', 'share_gt_over_time', 'share_le_over_time', 'smooth_exponential', 'smooth_exponential', 'sort_by_label_desc', 'sort_by_label_numeric', 'sort_by_label_numeric_desc', 'stale_samples_over_time', 'step', 'sum2_over_time', 'tfirst_over_time', 'timestamp_with_name', 'timezone_offset', 'tlast_change_over_time', 'tlast_over_time', 'tmax_over_time', 'tmin_over_time', 'union', 'zscore_over_time', 'avg_daily', 'median_daily', 'avg_weekly', 'median_weekly', 'median_weekly_with_trends'];
+// PromQL specific functions: Aggregations over time
+// (https://prometheus.io/docs/prometheus/latest/querying/functions/#aggregation_over_time)
+var aggregationsOverTime = [];
+for (var _i = 0, aggregations_1 = aggregations; _i < aggregations_1.length; _i++) {
+  var agg = aggregations_1[_i];
+  aggregationsOverTime.push(agg + '_over_time');
+}
+// PromQL vector matching + the by and without clauses
+// (https://prometheus.io/docs/prometheus/latest/querying/operators/#vector-matching)
+var vectorMatching = ['on', 'ignoring', 'group_right', 'group_left', 'by', 'without'];
+// Produce a regex matching elements : (elt1|elt2|...)
+var vectorMatchingRegex = '(' + /*#__PURE__*/vectorMatching.reduce(function (prev, curr) {
+  return prev + '|' + curr;
+}) + ')';
+// PromQL Operators
+// (https://prometheus.io/docs/prometheus/latest/querying/operators/)
+var operators = ['+', '-', '*', '/', '%', '^', '==', '!=', '>', '<', '>=', '<=', 'and', 'or', 'unless'];
+// PromQL offset modifier
+// (https://prometheus.io/docs/prometheus/latest/querying/basics/#offset-modifier)
+var offsetModifier = ['offset'];
+// Merging all the keywords in one list
+var keywords = /*#__PURE__*/aggregations.concat(functions).concat(aggregationsOverTime).concat(vectorMatching).concat(offsetModifier);
+// noinspection JSUnusedGlobalSymbols
+var language = {
+  ignoreCase: false,
+  defaultToken: '',
+  tokenPostfix: '.promql',
+  keywords: keywords,
+  operators: operators,
+  vectorMatching: vectorMatchingRegex,
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+  floatsuffix: /[fFlL]?/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+    // 'by', 'without' and vector matching
+    [/@vectorMatching\s*(?=\()/, 'type', '@clauses'],
+    // labels
+    [/[a-z_]\w*(?=\s*(=|!=|=~|!~))/, 'tag'],
+    // comments
+    [/(^#.*$)/, 'comment'],
+    // all keywords have the same color
+    [/[a-zA-Z_]\w*/, {
+      cases: {
+        '@keywords': 'type',
+        '@default': 'identifier'
+      }
+    }],
+    // strings
+    [/"([^"\\]|\\.)*$/, 'string.invalid'], [/'([^'\\]|\\.)*$/, 'string.invalid'], [/"/, 'string', '@string_double'], [/'/, 'string', '@string_single'], [/`/, 'string', '@string_backtick'],
+    // whitespace
+    {
+      include: '@whitespace'
+    },
+    // delimiters and operators
+    [/[{}()\[\]]/, '@brackets'], [/[<>](?!@symbols)/, '@brackets'], [/@symbols/, {
+      cases: {
+        '@operators': 'delimiter',
+        '@default': ''
+      }
+    }],
+    // numbers
+    [/\d+[smhdwy]/, 'number'], [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'], [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'], [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, 'number.hex'], [/0[0-7']*[0-7](@integersuffix)/, 'number.octal'], [/0[bB][0-1']*[0-1](@integersuffix)/, 'number.binary'], [/\d[\d']*\d(@integersuffix)/, 'number'], [/\d(@integersuffix)/, 'number']],
+    string_double: [[/[^\\"]+/, 'string'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/"/, 'string', '@pop']],
+    string_single: [[/[^\\']+/, 'string'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/'/, 'string', '@pop']],
+    string_backtick: [[/[^\\`$]+/, 'string'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/`/, 'string', '@pop']],
+    clauses: [[/[^(,)]/, 'tag'], [/\)/, 'identifier', '@pop']],
+    whitespace: [[/[ \t\r\n]+/, 'white']]
+  }
+};
+var TRIGONOMETRIC_FUNCTIONS = [{
+  label: 'acos',
+  insertText: 'acos',
+  detail: 'acos(v instant-vector)',
+  documentation: 'calculates the arccosine of all elements in v'
+}, {
+  label: 'acosh',
+  insertText: 'acosh',
+  detail: 'acosh(v instant-vector)',
+  documentation: 'calculates the inverse hyperbolic cosine of all elements in v'
+}, {
+  label: 'asin',
+  insertText: 'asin',
+  detail: 'asin(v instant-vector)',
+  documentation: 'calculates the arcsine of all elements in v'
+}, {
+  label: 'asinh',
+  insertText: 'asinh',
+  detail: 'asinh(v instant-vector)',
+  documentation: 'calculates the inverse hyperbolic sine of all elements in v'
+}, {
+  label: 'atan',
+  insertText: 'atan',
+  detail: 'atan(v instant-vector)',
+  documentation: 'calculates the arctangent of all elements in v'
+}, {
+  label: 'atanh',
+  insertText: 'atanh',
+  detail: 'atanh(v instant-vector)',
+  documentation: 'calculates the inverse hyperbolic tangent of all elements in v'
+}, {
+  label: 'cos',
+  insertText: 'cos',
+  detail: 'cos(v instant-vector)',
+  documentation: 'calculates the cosine of all elements in v'
+}, {
+  label: 'cosh',
+  insertText: 'cosh',
+  detail: 'cosh(v instant-vector)',
+  documentation: 'calculates the hyperbolic cosine of all elements in v'
+}, {
+  label: 'sin',
+  insertText: 'sin',
+  detail: 'sin(v instant-vector)',
+  documentation: 'calculates the sine of all elements in v'
+}, {
+  label: 'sinh',
+  insertText: 'sinh',
+  detail: 'sinh(v instant-vector)',
+  documentation: 'calculates the hyperbolic sine of all elements in v'
+}, {
+  label: 'tan',
+  insertText: 'tan',
+  detail: 'tan(v instant-vector)',
+  documentation: 'calculates the tangent of all elements in v'
+}, {
+  label: 'tanh',
+  insertText: 'tanh',
+  detail: 'tanh(v instant-vector)',
+  documentation: 'calculates the hyperbolic tangent of all elements in v'
+}];
+var AGGREGATION_OPERATORS = [{
+  label: 'sum',
+  insertText: 'sum',
+  documentation: 'Calculate sum over dimensions'
+}, {
+  label: 'min',
+  insertText: 'min',
+  documentation: 'Select minimum over dimensions'
+}, {
+  label: 'max',
+  insertText: 'max',
+  documentation: 'Select maximum over dimensions'
+}, {
+  label: 'avg',
+  insertText: 'avg',
+  documentation: 'Calculate the average over dimensions'
+}, {
+  label: 'group',
+  insertText: 'group',
+  documentation: 'All values in the resulting vector are 1'
+}, {
+  label: 'stddev',
+  insertText: 'stddev',
+  documentation: 'Calculate population standard deviation over dimensions'
+}, {
+  label: 'stdvar',
+  insertText: 'stdvar',
+  documentation: 'Calculate population standard variance over dimensions'
+}, {
+  label: 'count',
+  insertText: 'count',
+  documentation: 'Count number of elements in the vector'
+}, {
+  label: 'count_values',
+  insertText: 'count_values',
+  documentation: 'Count number of elements with the same value'
+}, {
+  label: 'bottomk',
+  insertText: 'bottomk',
+  documentation: 'Smallest k elements by sample value'
+}, {
+  label: 'topk',
+  insertText: 'topk',
+  documentation: 'Largest k elements by sample value'
+}, {
+  label: 'quantile',
+  insertText: 'quantile',
+  documentation: 'Calculate φ-quantile (0 ≤ φ ≤ 1) over dimensions'
+}];
+var FUNCTIONS = /*#__PURE__*/[].concat(AGGREGATION_OPERATORS, TRIGONOMETRIC_FUNCTIONS, [{
+  insertText: 'abs',
+  label: 'abs',
+  detail: 'abs(v instant-vector)',
+  documentation: 'Returns the input vector with all sample values converted to their absolute value.'
+}, {
+  insertText: 'absent',
+  label: 'absent',
+  detail: 'absent(v instant-vector)',
+  documentation: 'Returns an empty vector if the vector passed to it has any elements and a 1-element vector with the value 1 if the vector passed to it has no elements. This is useful for alerting on when no time series exist for a given metric name and label combination.'
+}, {
+  insertText: 'absent_over_time',
+  label: 'absent_over_time',
+  detail: 'absent(v range-vector)',
+  documentation: 'Returns an empty vector if the range vector passed to it has any elements and a 1-element vector with the value 1 if the range vector passed to it has no elements.'
+}, {
+  insertText: 'ceil',
+  label: 'ceil',
+  detail: 'ceil(v instant-vector)',
+  documentation: 'Rounds the sample values of all elements in `v` up to the nearest integer.'
+}, {
+  insertText: 'changes',
+  label: 'changes',
+  detail: 'changes(v range-vector)',
+  documentation: 'For each input time series, `changes(v range-vector)` returns the number of times its value has changed within the provided time range as an instant vector.'
+}, {
+  insertText: 'clamp',
+  label: 'clamp',
+  detail: 'clamp(v instant-vector, min scalar, max scalar)',
+  documentation: 'Clamps the sample values of all elements in `v` to have a lower limit of `min` and an upper limit of `max`.'
+}, {
+  insertText: 'clamp_max',
+  label: 'clamp_max',
+  detail: 'clamp_max(v instant-vector, max scalar)',
+  documentation: 'Clamps the sample values of all elements in `v` to have an upper limit of `max`.'
+}, {
+  insertText: 'clamp_min',
+  label: 'clamp_min',
+  detail: 'clamp_min(v instant-vector, min scalar)',
+  documentation: 'Clamps the sample values of all elements in `v` to have a lower limit of `min`.'
+}, {
+  insertText: 'count_scalar',
+  label: 'count_scalar',
+  detail: 'count_scalar(v instant-vector)',
+  documentation: 'Returns the number of elements in a time series vector as a scalar. This is in contrast to the `count()` aggregation operator, which always returns a vector (an empty one if the input vector is empty) and allows grouping by labels via a `by` clause.'
+}, {
+  insertText: 'deg',
+  label: 'deg',
+  detail: 'deg(v instant-vector)',
+  documentation: 'Converts radians to degrees for all elements in v'
+}, {
+  insertText: 'day_of_month',
+  label: 'day_of_month',
+  detail: 'day_of_month(v=vector(time()) instant-vector)',
+  documentation: 'Returns the day of the month for each of the given times in UTC. Returned values are from 1 to 31.'
+}, {
+  insertText: 'day_of_week',
+  label: 'day_of_week',
+  detail: 'day_of_week(v=vector(time()) instant-vector)',
+  documentation: 'Returns the day of the week for each of the given times in UTC. Returned values are from 0 to 6, where 0 means Sunday etc.'
+}, {
+  insertText: 'day_of_year',
+  label: 'day_of_year',
+  detail: 'day_of_year(v=vector(time()) instant-vector)',
+  documentation: 'Returns the day of the year for each of the given times in UTC. Returned values are from 1 to 365 for non-leap years, and 1 to 366 in leap years.'
+}, {
+  insertText: 'days_in_month',
+  label: 'days_in_month',
+  detail: 'days_in_month(v=vector(time()) instant-vector)',
+  documentation: 'Returns number of days in the month for each of the given times in UTC. Returned values are from 28 to 31.'
+}, {
+  insertText: 'delta',
+  label: 'delta',
+  detail: 'delta(v range-vector)',
+  documentation: 'Calculates the difference between the first and last value of each time series element in a range vector `v`, returning an instant vector with the given deltas and equivalent labels. The delta is extrapolated to cover the full time range as specified in the range vector selector, so that it is possible to get a non-integer result even if the sample values are all integers.'
+}, {
+  insertText: 'deriv',
+  label: 'deriv',
+  detail: 'deriv(v range-vector)',
+  documentation: 'Calculates the per-second derivative of the time series in a range vector `v`, using simple linear regression.'
+}, {
+  insertText: 'drop_common_labels',
+  label: 'drop_common_labels',
+  detail: 'drop_common_labels(instant-vector)',
+  documentation: 'Drops all labels that have the same name and value across all series in the input vector.'
+}, {
+  insertText: 'exp',
+  label: 'exp',
+  detail: 'exp(v instant-vector)',
+  documentation: 'Calculates the exponential function for all elements in `v`.\nSpecial cases are:\n* `Exp(+Inf) = +Inf` \n* `Exp(NaN) = NaN`'
+}, {
+  insertText: 'floor',
+  label: 'floor',
+  detail: 'floor(v instant-vector)',
+  documentation: 'Rounds the sample values of all elements in `v` down to the nearest integer.'
+}, {
+  insertText: 'histogram_quantile',
+  label: 'histogram_quantile',
+  detail: 'histogram_quantile(φ float, b instant-vector)',
+  documentation: 'Calculates the φ-quantile (0 ≤ φ ≤ 1) from the buckets `b` of a histogram. The samples in `b` are the counts of observations in each bucket. Each sample must have a label `le` where the label value denotes the inclusive upper bound of the bucket. (Samples without such a label are silently ignored.) The histogram metric type automatically provides time series with the `_bucket` suffix and the appropriate labels.'
+}, {
+  insertText: 'holt_winters',
+  label: 'holt_winters',
+  detail: 'holt_winters(v range-vector, sf scalar, tf scalar)',
+  documentation: 'Produces a smoothed value for time series based on the range in `v`. The lower the smoothing factor `sf`, the more importance is given to old data. The higher the trend factor `tf`, the more trends in the data is considered. Both `sf` and `tf` must be between 0 and 1.'
+}, {
+  insertText: 'hour',
+  label: 'hour',
+  detail: 'hour(v=vector(time()) instant-vector)',
+  documentation: 'Returns the hour of the day for each of the given times in UTC. Returned values are from 0 to 23.'
+}, {
+  insertText: 'idelta',
+  label: 'idelta',
+  detail: 'idelta(v range-vector)',
+  documentation: 'Calculates the difference between the last two samples in the range vector `v`, returning an instant vector with the given deltas and equivalent labels.'
+}, {
+  insertText: 'increase',
+  label: 'increase',
+  detail: 'increase(v range-vector)',
+  documentation: 'Calculates the increase in the time series in the range vector. Breaks in monotonicity (such as counter resets due to target restarts) are automatically adjusted for. The increase is extrapolated to cover the full time range as specified in the range vector selector, so that it is possible to get a non-integer result even if a counter increases only by integer increments.'
+}, {
+  insertText: 'irate',
+  label: 'irate',
+  detail: 'irate(v range-vector)',
+  documentation: 'Calculates the per-second instant rate of increase of the time series in the range vector. This is based on the last two data points. Breaks in monotonicity (such as counter resets due to target restarts) are automatically adjusted for.'
+}, {
+  insertText: 'label_join',
+  label: 'label_join',
+  detail: 'label_join(v instant-vector, dst_label string, separator string, src_label_1 string, src_label_2 string, ...)',
+  documentation: 'For each timeseries in `v`, joins all the values of all the `src_labels` using `separator` and returns the timeseries with the label `dst_label` containing the joined value. There can be any number of `src_labels` in this function.'
+}, {
+  insertText: 'label_replace',
+  label: 'label_replace',
+  detail: 'label_replace(v instant-vector, dst_label string, replacement string, src_label string, regex string)',
+  documentation: "For each timeseries in `v`, `label_replace(v instant-vector, dst_label string, replacement string, src_label string, regex string)`  matches the regular expression `regex` against the label `src_label`.  If it matches, then the timeseries is returned with the label `dst_label` replaced by the expansion of `replacement`. `$1` is replaced with the first matching subgroup, `$2` with the second etc. If the regular expression doesn't match then the timeseries is returned unchanged."
+}, {
+  insertText: 'ln',
+  label: 'ln',
+  detail: 'ln(v instant-vector)',
+  documentation: 'Calculates the natural logarithm for all elements in `v`.\nSpecial cases are:\n * `ln(+Inf) = +Inf`\n * `ln(0) = -Inf`\n * `ln(x < 0) = NaN`\n * `ln(NaN) = NaN`'
+}, {
+  insertText: 'log2',
+  label: 'log2',
+  detail: 'log2(v instant-vector)',
+  documentation: 'Calculates the binary logarithm for all elements in `v`. The special cases are equivalent to those in `ln`.'
+}, {
+  insertText: 'log10',
+  label: 'log10',
+  detail: 'log10(v instant-vector)',
+  documentation: 'Calculates the decimal logarithm for all elements in `v`. The special cases are equivalent to those in `ln`.'
+}, {
+  insertText: 'minute',
+  label: 'minute',
+  detail: 'minute(v=vector(time()) instant-vector)',
+  documentation: 'Returns the minute of the hour for each of the given times in UTC. Returned values are from 0 to 59.'
+}, {
+  insertText: 'month',
+  label: 'month',
+  detail: 'month(v=vector(time()) instant-vector)',
+  documentation: 'Returns the month of the year for each of the given times in UTC. Returned values are from 1 to 12, where 1 means January etc.'
+}, {
+  insertText: 'pi',
+  label: 'pi',
+  detail: 'pi()',
+  documentation: 'Returns pi'
+}, {
+  insertText: 'predict_linear',
+  label: 'predict_linear',
+  detail: 'predict_linear(v range-vector, t scalar)',
+  documentation: 'Predicts the value of time series `t` seconds from now, based on the range vector `v`, using simple linear regression.'
+}, {
+  insertText: 'rad',
+  label: 'rad',
+  detail: 'rad(v instant-vector)',
+  documentation: 'Converts degrees to radians for all elements in v'
+}, {
+  insertText: 'rate',
+  label: 'rate',
+  detail: 'rate(v range-vector)',
+  documentation: "Calculates the per-second average rate of increase of the time series in the range vector. Breaks in monotonicity (such as counter resets due to target restarts) are automatically adjusted for. Also, the calculation extrapolates to the ends of the time range, allowing for missed scrapes or imperfect alignment of scrape cycles with the range's time period."
+}, {
+  insertText: 'resets',
+  label: 'resets',
+  detail: 'resets(v range-vector)',
+  documentation: 'For each input time series, `resets(v range-vector)` returns the number of counter resets within the provided time range as an instant vector. Any decrease in the value between two consecutive samples is interpreted as a counter reset.'
+}, {
+  insertText: 'round',
+  label: 'round',
+  detail: 'round(v instant-vector, to_nearest=1 scalar)',
+  documentation: 'Rounds the sample values of all elements in `v` to the nearest integer. Ties are resolved by rounding up. The optional `to_nearest` argument allows specifying the nearest multiple to which the sample values should be rounded. This multiple may also be a fraction.'
+}, {
+  insertText: 'scalar',
+  label: 'scalar',
+  detail: 'scalar(v instant-vector)',
+  documentation: 'Given a single-element input vector, `scalar(v instant-vector)` returns the sample value of that single element as a scalar. If the input vector does not have exactly one element, `scalar` will return `NaN`.'
+}, {
+  insertText: 'sgn',
+  label: 'sgn',
+  detail: 'sgn(v instant-vector)',
+  documentation: 'Returns a vector with all sample values converted to their sign, defined as this: 1 if v is positive, -1 if v is negative and 0 if v is equal to zero.'
+}, {
+  insertText: 'sort',
+  label: 'sort',
+  detail: 'sort(v instant-vector)',
+  documentation: 'Returns vector elements sorted by their sample values, in ascending order.'
+}, {
+  insertText: 'sort_desc',
+  label: 'sort_desc',
+  detail: 'sort_desc(v instant-vector)',
+  documentation: 'Returns vector elements sorted by their sample values, in descending order.'
+}, {
+  insertText: 'sqrt',
+  label: 'sqrt',
+  detail: 'sqrt(v instant-vector)',
+  documentation: 'Calculates the square root of all elements in `v`.'
+}, {
+  insertText: 'time',
+  label: 'time',
+  detail: 'time()',
+  documentation: 'Returns the number of seconds since January 1, 1970 UTC. Note that this does not actually return the current time, but the time at which the expression is to be evaluated.'
+}, {
+  insertText: 'timestamp',
+  label: 'timestamp',
+  detail: 'timestamp(v instant-vector)',
+  documentation: 'Returns the timestamp of each of the samples of the given vector as the number of seconds since January 1, 1970 UTC.'
+}, {
+  insertText: 'vector',
+  label: 'vector',
+  detail: 'vector(s scalar)',
+  documentation: 'Returns the scalar `s` as a vector with no labels.'
+}, {
+  insertText: 'year',
+  label: 'year',
+  detail: 'year(v=vector(time()) instant-vector)',
+  documentation: 'Returns the year for each of the given times in UTC.'
+}, {
+  insertText: 'avg_over_time',
+  label: 'avg_over_time',
+  detail: 'avg_over_time(range-vector)',
+  documentation: 'The average value of all points in the specified interval.'
+}, {
+  insertText: 'min_over_time',
+  label: 'min_over_time',
+  detail: 'min_over_time(range-vector)',
+  documentation: 'The minimum value of all points in the specified interval.'
+}, {
+  insertText: 'max_over_time',
+  label: 'max_over_time',
+  detail: 'max_over_time(range-vector)',
+  documentation: 'The maximum value of all points in the specified interval.'
+}, {
+  insertText: 'sum_over_time',
+  label: 'sum_over_time',
+  detail: 'sum_over_time(range-vector)',
+  documentation: 'The sum of all values in the specified interval.'
+}, {
+  insertText: 'count_over_time',
+  label: 'count_over_time',
+  detail: 'count_over_time(range-vector)',
+  documentation: 'The count of all values in the specified interval.'
+}, {
+  insertText: 'quantile_over_time',
+  label: 'quantile_over_time',
+  detail: 'quantile_over_time(scalar, range-vector)',
+  documentation: 'The φ-quantile (0 ≤ φ ≤ 1) of the values in the specified interval.'
+}, {
+  insertText: 'stddev_over_time',
+  label: 'stddev_over_time',
+  detail: 'stddev_over_time(range-vector)',
+  documentation: 'The population standard deviation of the values in the specified interval.'
+}, {
+  insertText: 'stdvar_over_time',
+  label: 'stdvar_over_time',
+  detail: 'stdvar_over_time(range-vector)',
+  documentation: 'The population standard variance of the values in the specified interval.'
+}, {
+  insertText: 'last_over_time',
+  label: 'last_over_time',
+  detail: 'last_over_time(range-vector)',
+  documentation: 'The most recent point value in specified interval.'
+}, {
+  insertText: 'present_over_time',
+  label: 'present_over_time',
+  detail: 'present_over_time(range-vector)',
+  documentation: 'The value 1 for any series in the specified interval.'
+}, {
+  insertText: 'histogram_avg',
+  label: 'histogram_avg',
+  detail: 'histogram_avg(v instant-vector)',
+  documentation: 'Returns the arithmetic average of observed values stored in a native histogram. Samples that are not native histograms are ignored and do not show up in the returned vector.'
+}, {
+  insertText: 'histogram_count',
+  label: 'histogram_count',
+  detail: 'histogram_count(v instant-vector)',
+  documentation: 'Returns the count of observations stored in a native histogram.'
+}, {
+  insertText: 'histogram_sum',
+  label: 'histogram_sum',
+  detail: 'histogram_sum(v instant-vector)',
+  documentation: 'Returns the sum of observations stored in a native histogram.'
+}, {
+  insertText: 'histogram_fraction',
+  label: 'histogram_fraction',
+  detail: 'histogram_fraction(lower scalar, upper scalar, v instant-vector)',
+  documentation: 'Returns the estimated fraction of observations between the provided lower and upper values.'
+}, {
+  insertText: 'histogram_stddev',
+  label: 'histogram_stddev',
+  detail: 'histogram_stddev(v instant-vector)',
+  documentation: 'Returns the estimated standard deviation of observations in a native histogram, based on the geometric mean of the buckets where the observations lie.'
+}, {
+  insertText: 'histogram_stdvar',
+  label: 'histogram_stdvar',
+  detail: 'histogram_stdvar(v instant-vector)',
+  documentation: 'Returns the estimated standard variance of observations in a native histogram.'
+}]);
+
+var NeverCaseError = /*#__PURE__*/function (_Error) {
+  function NeverCaseError(_value) {
+    return _Error.call(this, 'should never happen') || this;
+  }
+  _inheritsLoose(NeverCaseError, _Error);
+  return NeverCaseError;
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+// based on the openmetrics-documentation, the 3 symbols we have to handle are:
+// - \n ... the newline character
+// - \  ... the backslash character
+// - "  ... the double-quote character
+function escapeLabelValueInExactSelector(labelValue) {
+  return labelValue.replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/"/g, '\\"');
+}
+function makeSelector(metricName, labels, labelName) {
+  if (!labels || labels.length === 0) {
+    return metricName;
+  }
+  var allLabels = [].concat(labels).filter(function (label) {
+    return label.name !== labelName && label.value !== '';
+  });
+  var allLabelTexts = allLabels.map(function (label) {
+    return "" + label.name + label.op + "\"" + escapeLabelValueInExactSelector(label.value) + "\"";
+  });
+  return "{" + allLabelTexts.join(',') + "}";
+}
+
+var DEFAULT_SERIES_LIMIT = '40000';
+var badRequest = 400;
+var unprocessableEntity = 422;
+var serviceUnavailable = 503;
+var CODE_MODE_SUGGESTIONS_INCOMPLETE_EVENT = 'codeModeSuggestionsIncomplete';
+var DataProvider = /*#__PURE__*/function () {
+  function DataProvider(params) {
+    var _this = this;
+    this.lookbackInterval = 60 * 60 * 1000 * 12; // 12 hours
+    this.variablesNames = [];
+    this.httpMethod = 'GET';
+    this.apiPrefix = '/api/v1';
+    this.customRequest = function (input, init) {
+      return fetch(input, init);
+    };
+    this.fetchSeries = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(selector, withLimit) {
+        var end, start, url, urlParams, request;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              end = new Date();
+              start = new Date(end.getTime() - _this.lookbackInterval);
+              url = _this.apiPrefix + "/series";
+              urlParams = {
+                start: start.toISOString(),
+                end: end.toISOString()
+              };
+              if (selector) {
+                urlParams['match[]'] = selector;
+              }
+              if (withLimit !== 'none') {
+                urlParams = _extends({}, urlParams, {
+                  limit: withLimit != null ? withLimit : DEFAULT_SERIES_LIMIT
+                });
+              }
+              request = _this.buildRequest(url, new URLSearchParams(urlParams));
+              _context.n = 1;
+              return _this.request(request.uri, {
+                method: _this.httpMethod,
+                body: request.body
+              })["catch"](function () {
+                return [];
+              });
+            case 1:
+              return _context.a(2, _context.v);
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    this.fetchLabels = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(selector) {
+        var end, start, url, urlParams, request;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              end = new Date();
+              start = new Date(end.getTime() - _this.lookbackInterval);
+              url = _this.apiPrefix + "/labels";
+              urlParams = {
+                start: start.toISOString(),
+                end: end.toISOString()
+              };
+              if (selector) {
+                urlParams['match[]'] = selector;
+              }
+              request = _this.buildRequest(url, new URLSearchParams(urlParams));
+              _context2.n = 1;
+              return _this.request(request.uri, {
+                method: _this.httpMethod,
+                body: request.body
+              }).then(function (res) {
+                _this.labelKeys = res;
+                return res;
+              })["catch"](function () {
+                return [];
+              });
+            case 1:
+              return _context2.a(2, _context2.v);
+          }
+        }, _callee2);
+      }));
+      return function (_x3) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    this.fetchLabelValues = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(labelName, selector) {
+        var end, start, url, urlParams, request;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              end = new Date();
+              start = new Date(end.getTime() - _this.lookbackInterval);
+              url = _this.apiPrefix + "/label/" + labelName + "/values";
+              urlParams = {
+                start: start.toISOString(),
+                end: end.toISOString()
+              };
+              if (selector) {
+                urlParams['match[]'] = selector;
+              }
+              request = _this.buildRequest(url, new URLSearchParams(urlParams));
+              _context3.n = 1;
+              return _this.request(request.uri, {
+                method: _this.httpMethod,
+                body: request.body
+              })["catch"](function () {
+                return [];
+              });
+            case 1:
+              return _context3.a(2, _context3.v);
+          }
+        }, _callee3);
+      }));
+      return function (_x4, _x5) {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+    this.start = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+      var _t;
+      return _regenerator().w(function (_context4) {
+        while (1) switch (_context4.n) {
+          case 0:
+            _context4.n = 1;
+            return _this.fetchLabelValues('__name__', makeSelector('', [], '__name__'));
+          case 1:
+            _t = _context4.v;
+            if (_t) {
+              _context4.n = 2;
+              break;
+            }
+            _t = [];
+          case 2:
+            _this.metrics = _t;
+            return _context4.a(2, Promise.all([_this.loadMetricsMetadata()]));
+        }
+      }, _callee4);
+    }));
+    this.inputInRange = '';
+    this.metricNamesSuggestionLimit = 1000;
+    this.suggestionsIncomplete = false;
+    this.url = params.url ? params.url : '';
+    this.errorHandler = params.httpErrorHandler;
+    if (params.lookbackInterval) {
+      this.lookbackInterval = params.lookbackInterval;
+    }
+    if (params.variablesNames) {
+      this.variablesNames = [].concat(params.variablesNames);
+    }
+    if (params.request) {
+      this.customRequest = params.request;
+    }
+    if (params.httpMethod) {
+      this.httpMethod = params.httpMethod;
+    }
+    if (params.apiPrefix) {
+      this.apiPrefix = params.apiPrefix;
+    }
+    this.metrics = [];
+    this.labelKeys = [];
+  }
+  var _proto = DataProvider.prototype;
+  _proto.getVariablesNames = function getVariablesNames() {
+    return this.variablesNames;
+  };
+  _proto.setVariablesNames = function setVariablesNames(variablesNames) {
+    this.variablesNames = [].concat(variablesNames);
+  };
+  _proto.buildRequest = function buildRequest(endpoint, params) {
+    var uri = endpoint;
+    var body = params;
+    if (this.httpMethod === 'GET') {
+      uri = uri + "?" + params;
+      body = null;
+    }
+    return {
+      uri: uri,
+      body: body
+    };
+  };
+  _proto.request = function request(resource, init) {
+    var _this2 = this;
+    return this.customRequest(this.url + resource, init).then(function (res) {
+      if (!res.ok && ![badRequest, unprocessableEntity, serviceUnavailable].includes(res.status)) {
+        throw new Error(res.statusText);
+      }
+      return res;
+    }).then(function (res) {
+      return res.json();
+    }).then(function (apiRes) {
+      if (apiRes.status === 'error') {
+        var error = new Error(apiRes.error !== undefined ? apiRes.error : 'missing "error" field in response JSON');
+        if (_this2.errorHandler) {
+          _this2.errorHandler(error);
+        }
+        throw error;
+      }
+      if (apiRes.data === undefined) {
+        var _error = new Error(apiRes.error !== undefined ? apiRes.error : 'missing "data" field in response JSON');
+        if (_this2.errorHandler) {
+          _this2.errorHandler(_error);
+        }
+        throw _error;
+      }
+      return apiRes.data;
+    })["catch"](function (error) {
+      if (_this2.errorHandler) {
+        _this2.errorHandler(error);
+      }
+      throw error;
+    });
+  };
+  _proto.getAllMetricNames = function getAllMetricNames() {
+    return this.metrics;
+  };
+  _proto.loadMetricsMetadata = /*#__PURE__*/function () {
+    var _loadMetricsMetadata = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+      var request;
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            request = this.buildRequest(this.apiPrefix + "/metadata", new URLSearchParams({}));
+            _context5.n = 1;
+            return this.request(request.uri, {
+              method: this.httpMethod,
+              body: request.body
+            })["catch"](function () {
+              return {};
+            });
+          case 1:
+            this.metricsMetadata = _context5.v;
+          case 2:
+            return _context5.a(2);
+        }
+      }, _callee5, this);
+    }));
+    function loadMetricsMetadata() {
+      return _loadMetricsMetadata.apply(this, arguments);
+    }
+    return loadMetricsMetadata;
+  }();
+  _proto.metricNamesToMetrics = function metricNamesToMetrics(metricNames) {
+    var _this3 = this;
+    var result = metricNames.map(function (m) {
+      var _this3$metricsMetadat, _metaItem$help, _metaItem$type;
+      var metaItem = (_this3$metricsMetadat = _this3.metricsMetadata) == null ? void 0 : _this3$metricsMetadat[m];
+      return {
+        name: m,
+        help: (_metaItem$help = metaItem == null ? void 0 : metaItem.help) != null ? _metaItem$help : '',
+        type: (_metaItem$type = metaItem == null ? void 0 : metaItem.type) != null ? _metaItem$type : ''
+      };
+    });
+    return result;
+  };
+  _proto.setInputInRange = function setInputInRange(textInput) {
+    this.inputInRange = textInput;
+  };
+  _proto.enableAutocompleteSuggestionsUpdate = function enableAutocompleteSuggestionsUpdate() {
+    this.suggestionsIncomplete = true;
+    dispatchEvent(new CustomEvent(CODE_MODE_SUGGESTIONS_INCOMPLETE_EVENT, {
+      detail: {
+        limit: this.metricNamesSuggestionLimit
+      }
+    }));
+  };
+  return _createClass(DataProvider, [{
+    key: "monacoSettings",
+    get: function get() {
+      return {
+        /**
+         * Enable autocomplete suggestions update on every input change.
+         *
+         * @remarks
+         * If fuzzy search is used in `getCompletions` to trim down results to improve performance,
+         * we need to instruct Monaco to update the completions on every input change, so that the
+         * completions reflect the current input.
+         */
+        enableAutocompleteSuggestionsUpdate: this.enableAutocompleteSuggestionsUpdate.bind(this),
+        inputInRange: this.inputInRange,
+        setInputInRange: this.setInputInRange.bind(this),
+        suggestionsIncomplete: this.suggestionsIncomplete
+      };
+    }
+  }]);
+}();
+
+function move(node, direction) {
+  switch (direction) {
+    case 'parent':
+      return node.parent;
+    case 'firstChild':
+      return node.firstChild;
+    case 'lastChild':
+      return node.lastChild;
+    case 'nextSibling':
+      return node.nextSibling;
+    default:
+      throw new NeverCaseError(direction);
+  }
+}
+function walk(node, path) {
+  var current = node;
+  for (var _iterator = _createForOfIteratorHelperLoose(path), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+      direction = _step$value[0],
+      expectedType = _step$value[1];
+    current = move(current, direction);
+    if (current === null) {
+      // we could not move in the direction, we stop
+      return null;
+    }
+    if (current.type.id !== expectedType) {
+      // the reached node has wrong type, we stop
+      return null;
+    }
+  }
+  return current;
+}
+function getNodeText(node, text) {
+  return text.slice(node.from, node.to);
+}
+function parsePromQLStringLiteral(text) {
+  // if it is a string-literal, it is inside quotes of some kind
+  var inside = text.slice(1, text.length - 1);
+  // FIXME: support https://prometheus.io/docs/prometheus/latest/querying/basics/#string-literals
+  // FIXME: maybe check other promql code, if all is supported or not
+  // for now we do only some very simple un-escaping
+  // we start with double-quotes
+  if (text.startsWith('"') && text.endsWith('"')) {
+    // NOTE: this is not 100% perfect, we only unescape the double-quote,
+    // there might be other characters too
+    return inside.replace(/\\"/, '"');
+  }
+  // then single-quote
+  if (text.startsWith("'") && text.endsWith("'")) {
+    // NOTE: this is not 100% perfect, we only unescape the single-quote,
+    // there might be other characters too
+    return inside.replace(/\\'/, "'");
+  }
+  // then backticks
+  if (text.startsWith('`') && text.endsWith('`')) {
+    return inside;
+  }
+  throw new Error('FIXME: invalid string literal');
+}
+function isPathMatch(resolverPath, cursorPath) {
+  return resolverPath.every(function (item, index) {
+    return item === cursorPath[index];
+  });
+}
+var ERROR_NODE_NAME = 0; // this is used as error-id
+var RESOLVERS = [{
+  path: [LabelMatchers, VectorSelector],
+  fun: resolveLabelKeysWithEquals
+}, {
+  path: [PromQL],
+  fun: resolveTopLevel
+}, {
+  path: [FunctionCallBody],
+  fun: resolveInFunction
+}, {
+  path: [StringLiteral, UnquotedLabelMatcher],
+  fun: resolveLabelMatcher
+}, {
+  path: [ERROR_NODE_NAME, BinaryExpr, PromQL],
+  fun: resolveTopLevel
+}, {
+  path: [ERROR_NODE_NAME, UnquotedLabelMatcher],
+  fun: resolveLabelMatcher
+}, {
+  path: [ERROR_NODE_NAME, NumberDurationLiteralInDurationContext, MatrixSelector],
+  fun: resolveDurations
+}, {
+  path: [GroupingLabels],
+  fun: resolveLabelsForGrouping
+}];
+var LABEL_OP_MAP = /*#__PURE__*/new Map([[EqlSingle, '='], [EqlRegex, '=~'], [Neq, '!='], [NeqRegex, '!~']]);
+function getLabelOp(opNode) {
+  var _LABEL_OP_MAP$get;
+  var opChild = opNode.firstChild;
+  if (opChild === null) {
+    return null;
+  }
+  return (_LABEL_OP_MAP$get = LABEL_OP_MAP.get(opChild.type.id)) != null ? _LABEL_OP_MAP$get : null;
+}
+function getLabel(labelMatcherNode, text) {
+  if (labelMatcherNode.type.id !== UnquotedLabelMatcher) {
+    return null;
+  }
+  var nameNode = walk(labelMatcherNode, [['firstChild', LabelName]]);
+  if (nameNode === null) {
+    return null;
+  }
+  var opNode = walk(nameNode, [['nextSibling', MatchOp]]);
+  if (opNode === null) {
+    return null;
+  }
+  var op = getLabelOp(opNode);
+  if (op === null) {
+    return null;
+  }
+  var valueNode = walk(labelMatcherNode, [['lastChild', StringLiteral]]);
+  if (valueNode === null) {
+    return null;
+  }
+  var name = getNodeText(nameNode, text);
+  var value = parsePromQLStringLiteral(getNodeText(valueNode, text));
+  return {
+    name: name,
+    value: value,
+    op: op
+  };
+}
+function getLabels(labelMatchersNode, text) {
+  if (labelMatchersNode.type.id !== LabelMatchers) {
+    return [];
+  }
+  var labelNodes = labelMatchersNode.getChildren(UnquotedLabelMatcher);
+  return labelNodes.map(function (ln) {
+    return getLabel(ln, text);
+  }).filter(notEmpty);
+}
+function getNodeChildren(node) {
+  var child = node.firstChild;
+  var children = [];
+  while (child !== null) {
+    children.push(child);
+    child = child.nextSibling;
+  }
+  return children;
+}
+function getNodeInSubtree(node, typeId) {
+  // first we try the current node
+  if (node.type.id === typeId) {
+    return node;
+  }
+  // then we try the children
+  var children = getNodeChildren(node);
+  for (var _iterator2 = _createForOfIteratorHelperLoose(children), _step2; !(_step2 = _iterator2()).done;) {
+    var child = _step2.value;
+    var n = getNodeInSubtree(child, typeId);
+    if (n !== null) {
+      return n;
+    }
+  }
+  return null;
+}
+function resolveLabelsForGrouping(node, text, _pos) {
+  var aggrExpNode = walk(node, [['parent', AggregateModifier], ['parent', AggregateExpr]]);
+  if (aggrExpNode === null) {
+    return null;
+  }
+  var bodyNode = aggrExpNode.getChild(FunctionCallBody);
+  if (bodyNode === null) {
+    return null;
+  }
+  var metricIdNode = getNodeInSubtree(bodyNode, Identifier);
+  if (metricIdNode === null) {
+    return null;
+  }
+  var metricName = getNodeText(metricIdNode, text);
+  return {
+    type: 'IN_GROUPING',
+    metricName: metricName,
+    otherLabels: []
+  };
+}
+function resolveLabelMatcher(node, text, _pos) {
+  // we can arrive here in two situation. `node` is either:
+  // - a StringNode (like in `{job="^"}`)
+  // - or an error node (like in `{job=^}`)
+  var inStringNode = !node.type.isError;
+  var parent = walk(node, [['parent', UnquotedLabelMatcher]]);
+  if (parent === null) {
+    return null;
+  }
+  var labelNameNode = walk(parent, [['firstChild', LabelName]]);
+  if (labelNameNode === null) {
+    return null;
+  }
+  var labelName = getNodeText(labelNameNode, text);
+  var labelMatchersNode = walk(parent, [['parent', LabelMatchers]]);
+  if (labelMatchersNode === null) {
+    return null;
+  }
+  // now we need to find the other names
+  var allLabels = getLabels(labelMatchersNode, text);
+  // we need to remove "our" label from all-labels, if it is in there
+  var otherLabels = allLabels.filter(function (label) {
+    return label.name !== labelName;
+  });
+  var metricNameNode = walk(labelMatchersNode, [['parent', VectorSelector], ['firstChild', Identifier]]);
+  if (metricNameNode === null) {
+    // we are probably in a situation without a metric name
+    return {
+      type: 'IN_LABEL_SELECTOR_WITH_LABEL_NAME',
+      labelName: labelName,
+      betweenQuotes: inStringNode,
+      otherLabels: otherLabels
+    };
+  }
+  var metricName = getNodeText(metricNameNode, text);
+  return {
+    type: 'IN_LABEL_SELECTOR_WITH_LABEL_NAME',
+    metricName: metricName,
+    labelName: labelName,
+    betweenQuotes: inStringNode,
+    otherLabels: otherLabels
+  };
+}
+function resolveTopLevel() {
+  return {
+    type: 'AT_ROOT'
+  };
+}
+function resolveInFunction() {
+  return {
+    type: 'IN_FUNCTION'
+  };
+}
+function resolveDurations() {
+  return {
+    type: 'IN_DURATION'
+  };
+}
+function resolveLabelKeysWithEquals(node, text, pos) {
+  // next false positive:
+  // `something{a="1"^}`
+  var child = walk(node, [['firstChild', UnquotedLabelMatcher]]);
+  if (child !== null) {
+    // means the label-matching part contains at least one label already.
+    //
+    // in this case, we will need to have a `,` character at the end,
+    // to be able to suggest adding the next label.
+    // the area between the end-of-the-child-node and the cursor-pos
+    // must contain a `,` in this case.
+    var textToCheck = text.slice(child.to, pos);
+    if (!textToCheck.includes(',')) {
+      return null;
+    }
+  }
+  var metricNameNode = walk(node, [['parent', VectorSelector], ['firstChild', Identifier]]);
+  var otherLabels = getLabels(node, text);
+  if (metricNameNode === null) {
+    // we are probably in a situation without a metric name.
+    return {
+      type: 'IN_LABEL_SELECTOR_NO_LABEL_NAME',
+      otherLabels: otherLabels
+    };
+  }
+  var metricName = getNodeText(metricNameNode, text);
+  return {
+    type: 'IN_LABEL_SELECTOR_NO_LABEL_NAME',
+    metricName: metricName,
+    otherLabels: otherLabels
+  };
+}
+// we find the first error-node in the tree that is at the cursor-position.
+// NOTE: this might be too slow, might need to optimize it
+// (ideas: we do not need to go into every subtree, based on from/to)
+// also, only go to places that are in the sub-tree of the node found
+// by default by lezer. problem is, `next()` will go upward too,
+// and we do not want to go higher than our node
+function getErrorNode(tree, pos) {
+  var cur = tree.cursorAt(pos);
+  while (true) {
+    if (cur.from === pos && cur.to === pos) {
+      var node = cur.node;
+      if (node.type.isError) {
+        return node;
+      }
+    }
+    if (!cur.next()) {
+      break;
+    }
+  }
+  return null;
+}
+function getSituation(text, pos) {
+  // there is a special-case when we are at the start of writing text,
+  // so we handle that case first
+  if (text === '') {
+    return {
+      type: 'EMPTY'
+    };
+  }
+  /**
+     PromQL
+     Expr
+     VectorSelector
+     LabelMatchers
+   */
+  var tree = parser.parse(text);
+  // if the tree contains error, it is very probable that
+  // our node is one of those error-nodes.
+  // also, if there are errors, the node lezer finds us,
+  // might not be the best node.
+  // so first we check if there is an error-node at the cursor-position
+  var maybeErrorNode = getErrorNode(tree, pos);
+  var cur = maybeErrorNode != null ? maybeErrorNode.cursor() : tree.cursorAt(pos);
+  var currentNode = cur.node;
+  var ids = [cur.type.id];
+  while (cur.parent()) {
+    ids.push(cur.type.id);
+  }
+  for (var _iterator3 = _createForOfIteratorHelperLoose(RESOLVERS), _step3; !(_step3 = _iterator3()).done;) {
+    var resolver = _step3.value;
+    // i do not use a foreach because i want to stop as soon
+    // as i find something
+    if (isPathMatch(resolver.path, ids)) {
+      return resolver.fun(currentNode, text, pos);
+    }
+  }
+  return null;
+}
+function notEmpty(value) {
+  return value !== null && value !== undefined;
+}
+
+var metricNamesSearchClient = /*#__PURE__*/new UFuzzy({
+  intraMode: 1
+});
+// we order items like: history, functions, metrics
+function getAllMetricNamesCompletions(dataProvider) {
+  var metricNames = dataProvider.getAllMetricNames();
+  if (metricNames.length > dataProvider.metricNamesSuggestionLimit) {
+    var monacoSettings = dataProvider.monacoSettings;
+    monacoSettings.enableAutocompleteSuggestionsUpdate();
+    if (monacoSettings.inputInRange) {
+      var _metricNamesSearchCli, _metricNamesSearchCli2;
+      metricNames = (_metricNamesSearchCli = (_metricNamesSearchCli2 = metricNamesSearchClient.filter(metricNames, monacoSettings.inputInRange)) == null ? void 0 : _metricNamesSearchCli2.slice(0, dataProvider.metricNamesSuggestionLimit).map(function (idx) {
+        return metricNames[idx];
+      })) != null ? _metricNamesSearchCli : [];
+    } else {
+      metricNames = metricNames.slice(0, dataProvider.metricNamesSuggestionLimit);
+    }
+  }
+  return dataProvider.metricNamesToMetrics(metricNames).map(function (metric) {
+    return {
+      type: 'METRIC_NAME',
+      label: metric.name,
+      insertText: metric.name,
+      detail: metric.name + " : " + metric.type,
+      documentation: metric.help
+    };
+  });
+}
+var FUNCTION_COMPLETIONS = /*#__PURE__*/FUNCTIONS.map(function (f) {
+  var _f$insertText;
+  return {
+    type: 'FUNCTION',
+    label: f.label,
+    insertText: (_f$insertText = f.insertText) != null ? _f$insertText : '',
+    detail: f.detail,
+    documentation: f.documentation
+  };
+});
+function getAllFunctionsAndMetricNamesCompletions(_x) {
+  return _getAllFunctionsAndMetricNamesCompletions.apply(this, arguments);
+}
+function _getAllFunctionsAndMetricNamesCompletions() {
+  _getAllFunctionsAndMetricNamesCompletions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(dataProvider) {
+    var metricNames;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          metricNames = getAllMetricNamesCompletions(dataProvider);
+          return _context.a(2, [].concat(FUNCTION_COMPLETIONS, metricNames));
+      }
+    }, _callee);
+  }));
+  return _getAllFunctionsAndMetricNamesCompletions.apply(this, arguments);
+}
+var DURATION_COMPLETIONS = /*#__PURE__*/['$__interval', '$__range', '$__rate_interval', '1m', '5m', '10m', '30m', '1h', '1d'].map(function (text) {
+  return {
+    type: 'DURATION',
+    label: text,
+    insertText: text
+  };
+});
+function getAllHistoryCompletions(_dataProvider) {
+  return [];
+  // function getAllHistoryCompletions(queryHistory: PromHistoryItem[]): Completion[] {
+  // NOTE: the typescript types are wrong. historyItem.query.expr can be undefined
+  // const allHistory = dataProvider.getHistory();
+  // FIXME: find a better history-limit
+  // return allHistory.slice(0, 10).map((expr) => ({
+  //   type: 'HISTORY',
+  //   label: expr,
+  //   insertText: expr,
+  // }));
+}
+function getLabelNames(_x2, _x3, _x4) {
+  return _getLabelNames.apply(this, arguments);
+}
+function _getLabelNames() {
+  _getLabelNames = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(metric, otherLabels, dataProvider) {
+    var selector, _selector, series, labelNames, _iterator, _step, labelSet, _i, _Object$entries, _Object$entries$_i, key;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          if (!(metric === undefined || metric === '')) {
+            _context2.n = 2;
+            break;
+          }
+          selector = makeSelector('', otherLabels);
+          _context2.n = 1;
+          return dataProvider.fetchLabels(selector);
+        case 1:
+          return _context2.a(2, _context2.v);
+        case 2:
+          _selector = makeSelector(metric, otherLabels);
+          _context2.n = 3;
+          return dataProvider.fetchSeries(_selector);
+        case 3:
+          series = _context2.v;
+          labelNames = new Set();
+          _iterator = _createForOfIteratorHelperLoose(series);
+        case 4:
+          if ((_step = _iterator()).done) {
+            _context2.n = 9;
+            break;
+          }
+          labelSet = _step.value;
+          _i = 0, _Object$entries = Object.entries(labelSet);
+        case 5:
+          if (!(_i < _Object$entries.length)) {
+            _context2.n = 8;
+            break;
+          }
+          _Object$entries$_i = _Object$entries[_i], key = _Object$entries$_i[0];
+          if (!(key === '__name__')) {
+            _context2.n = 6;
+            break;
+          }
+          return _context2.a(3, 7);
+        case 6:
+          labelNames.add(key);
+        case 7:
+          _i++;
+          _context2.n = 5;
+          break;
+        case 8:
+          _context2.n = 4;
+          break;
+        case 9:
+          return _context2.a(2, Array.from(labelNames));
+        case 10:
+          return _context2.a(2);
+      }
+    }, _callee2);
+  }));
+  return _getLabelNames.apply(this, arguments);
+}
+function getLabelNamesForCompletions(_x5, _x6, _x7, _x8, _x9) {
+  return _getLabelNamesForCompletions.apply(this, arguments);
+}
+function _getLabelNamesForCompletions() {
+  _getLabelNamesForCompletions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(metric, suffix, triggerOnInsert, otherLabels, dataProvider) {
+    var labelNames;
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 0:
+          _context3.n = 1;
+          return getLabelNames(metric, otherLabels, dataProvider);
+        case 1:
+          labelNames = _context3.v;
+          return _context3.a(2, labelNames.map(function (text) {
+            return {
+              type: 'LABEL_NAME',
+              label: text,
+              insertText: "" + text + suffix,
+              triggerOnInsert: triggerOnInsert
+            };
+          }));
+      }
+    }, _callee3);
+  }));
+  return _getLabelNamesForCompletions.apply(this, arguments);
+}
+function getLabelNamesForSelectorCompletions(_x0, _x1, _x10) {
+  return _getLabelNamesForSelectorCompletions.apply(this, arguments);
+}
+function _getLabelNamesForSelectorCompletions() {
+  _getLabelNamesForSelectorCompletions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(metric, otherLabels, dataProvider) {
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
+        case 0:
+          return _context4.a(2, getLabelNamesForCompletions(metric, '=', true, otherLabels, dataProvider));
+      }
+    }, _callee4);
+  }));
+  return _getLabelNamesForSelectorCompletions.apply(this, arguments);
+}
+function getLabelNamesForByCompletions(_x11, _x12, _x13) {
+  return _getLabelNamesForByCompletions.apply(this, arguments);
+}
+function _getLabelNamesForByCompletions() {
+  _getLabelNamesForByCompletions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(metric, otherLabels, dataProvider) {
+    return _regenerator().w(function (_context5) {
+      while (1) switch (_context5.n) {
+        case 0:
+          return _context5.a(2, getLabelNamesForCompletions(metric, '', false, otherLabels, dataProvider));
+      }
+    }, _callee5);
+  }));
+  return _getLabelNamesForByCompletions.apply(this, arguments);
+}
+function getLabelValues(_x14, _x15, _x16, _x17) {
+  return _getLabelValues.apply(this, arguments);
+}
+function _getLabelValues() {
+  _getLabelValues = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(metric, labelName, otherLabels, dataProvider) {
+    var selector, _selector2, series, labelValues, _iterator2, _step2, labelSet, _i2, _Object$entries2, _Object$entries2$_i, key, value, variablesNames;
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.n) {
+        case 0:
+          if (!(metric === undefined || metric === '')) {
+            _context6.n = 2;
+            break;
+          }
+          selector = makeSelector('', otherLabels);
+          _context6.n = 1;
+          return dataProvider.fetchLabelValues(labelName, selector);
+        case 1:
+          return _context6.a(2, _context6.v);
+        case 2:
+          _selector2 = makeSelector(metric, otherLabels, labelName);
+          _context6.n = 3;
+          return dataProvider.fetchSeries(_selector2);
+        case 3:
+          series = _context6.v;
+          labelValues = new Set();
+          _iterator2 = _createForOfIteratorHelperLoose(series);
+        case 4:
+          if ((_step2 = _iterator2()).done) {
+            _context6.n = 9;
+            break;
+          }
+          labelSet = _step2.value;
+          _i2 = 0, _Object$entries2 = Object.entries(labelSet);
+        case 5:
+          if (!(_i2 < _Object$entries2.length)) {
+            _context6.n = 8;
+            break;
+          }
+          _Object$entries2$_i = _Object$entries2[_i2], key = _Object$entries2$_i[0], value = _Object$entries2$_i[1];
+          if (!(key === '__name__')) {
+            _context6.n = 6;
+            break;
+          }
+          return _context6.a(3, 7);
+        case 6:
+          if (key === labelName) {
+            labelValues.add(value);
+          }
+        case 7:
+          _i2++;
+          _context6.n = 5;
+          break;
+        case 8:
+          _context6.n = 4;
+          break;
+        case 9:
+          variablesNames = dataProvider.getVariablesNames();
+          return _context6.a(2, variablesNames.concat(Array.from(labelValues)));
+        case 10:
+          return _context6.a(2);
+      }
+    }, _callee6);
+  }));
+  return _getLabelValues.apply(this, arguments);
+}
+function getLabelValuesForMetricCompletions(_x18, _x19, _x20, _x21, _x22) {
+  return _getLabelValuesForMetricCompletions.apply(this, arguments);
+}
+function _getLabelValuesForMetricCompletions() {
+  _getLabelValuesForMetricCompletions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(metric, labelName, betweenQuotes, otherLabels, dataProvider) {
+    var values;
+    return _regenerator().w(function (_context7) {
+      while (1) switch (_context7.n) {
+        case 0:
+          _context7.n = 1;
+          return getLabelValues(metric, labelName, otherLabels, dataProvider);
+        case 1:
+          values = _context7.v;
+          return _context7.a(2, values.map(function (text) {
+            return {
+              type: 'LABEL_VALUE',
+              label: text,
+              insertText: betweenQuotes ? text : "\"" + text + "\""
+            };
+          }));
+      }
+    }, _callee7);
+  }));
+  return _getLabelValuesForMetricCompletions.apply(this, arguments);
+}
+function getCompletions(situation, dataProvider) {
+  switch (situation.type) {
+    case 'IN_DURATION':
+      return Promise.resolve(DURATION_COMPLETIONS);
+    case 'IN_FUNCTION':
+      return getAllFunctionsAndMetricNamesCompletions(dataProvider);
+    case 'AT_ROOT':
+      {
+        return getAllFunctionsAndMetricNamesCompletions(dataProvider);
+      }
+    case 'EMPTY':
+      {
+        var metricNames = getAllMetricNamesCompletions(dataProvider);
+        var historyCompletions = getAllHistoryCompletions();
+        return Promise.resolve([].concat(historyCompletions, FUNCTION_COMPLETIONS, metricNames));
+      }
+    case 'IN_LABEL_SELECTOR_NO_LABEL_NAME':
+      return getLabelNamesForSelectorCompletions(situation.metricName, situation.otherLabels, dataProvider);
+    case 'IN_GROUPING':
+      return getLabelNamesForByCompletions(situation.metricName, situation.otherLabels, dataProvider);
+    case 'IN_LABEL_SELECTOR_WITH_LABEL_NAME':
+      return getLabelValuesForMetricCompletions(situation.metricName, situation.labelName, situation.betweenQuotes, situation.otherLabels, dataProvider);
+    default:
+      throw new NeverCaseError(situation);
+  }
+}
+
+function getMonacoCompletionItemKind(type, monaco) {
+  switch (type) {
+    case 'DURATION':
+      return monaco.languages.CompletionItemKind.Unit;
+    case 'FUNCTION':
+      return monaco.languages.CompletionItemKind.Variable;
+    case 'HISTORY':
+      return monaco.languages.CompletionItemKind.Snippet;
+    case 'LABEL_NAME':
+      return monaco.languages.CompletionItemKind.Enum;
+    case 'LABEL_VALUE':
+      return monaco.languages.CompletionItemKind.EnumMember;
+    case 'METRIC_NAME':
+      return monaco.languages.CompletionItemKind.Constructor;
+    default:
+      throw new NeverCaseError(type);
+  }
+}
+function getCompletionProvider(monaco, dataProvider) {
+  var provideCompletionItems = function provideCompletionItems(model, position) {
+    var word = model.getWordAtPosition(position);
+    var range = word != null ? monaco.Range.lift({
+      startLineNumber: position.lineNumber,
+      endLineNumber: position.lineNumber,
+      startColumn: word.startColumn,
+      endColumn: word.endColumn
+    }) : monaco.Range.fromPositions(position);
+    // documentation says `position` will be "adjusted" in `getOffsetAt`
+    // i don't know what that means, to be sure i clone it
+    var positionClone = {
+      column: position.column,
+      lineNumber: position.lineNumber
+    };
+    dataProvider.monacoSettings.setInputInRange(model.getValueInRange(range));
+    // Check to see if the browser supports window.getSelection()
+    if (window.getSelection) {
+      var _window$getSelection;
+      var selectedText = (_window$getSelection = window.getSelection()) == null ? void 0 : _window$getSelection.toString();
+      // If the user has selected text, adjust the cursor position to be at the start of the selection, instead of the end
+      if (selectedText && selectedText.length > 0) {
+        positionClone.column = positionClone.column - selectedText.length;
+      }
+    }
+    var offset = model.getOffsetAt(positionClone);
+    var situation = getSituation(model.getValue(), offset);
+    var completionsPromise = situation != null ? getCompletions(situation, dataProvider) : Promise.resolve([]);
+    return completionsPromise.then(function (items) {
+      // monaco by-default alphabetically orders the items.
+      // to stop it, we use a number-as-string sortkey,
+      // so that monaco keeps the order we use
+      var maxIndexDigits = items.length.toString().length;
+      var suggestions = items.map(function (item, index) {
+        return {
+          kind: getMonacoCompletionItemKind(item.type, monaco),
+          label: item.label,
+          insertText: item.insertText,
+          detail: item.detail,
+          documentation: item.documentation,
+          sortText: index.toString().padStart(maxIndexDigits, '0'),
+          range: range,
+          command: item.triggerOnInsert ? {
+            id: 'editor.action.triggerSuggest',
+            title: ''
+          } : undefined
+        };
+      });
+      return {
+        suggestions: suggestions,
+        incomplete: dataProvider.monacoSettings.suggestionsIncomplete
+      };
+    });
+  };
+  return {
+    triggerCharacters: ['{', ',', '[', '(', '=', '~', ' ', '"'],
+    provideCompletionItems: provideCompletionItems
+  };
+}
+
+var ErrorId = 0;
+function validateQuery(query, interpolatedQuery, queryLines, parser) {
+  if (!query) {
+    return false;
+  }
+  var interpolatedErrors = parseQuery(interpolatedQuery, parser);
+  if (!interpolatedErrors.length) {
+    return false;
+  }
+  var parseErrors = interpolatedErrors;
+  if (query !== interpolatedQuery) {
+    var queryErrors = parseQuery(query, parser);
+    parseErrors = interpolatedErrors.flatMap(function (interpolatedError) {
+      return queryErrors.filter(function (queryError) {
+        return interpolatedError.text === queryError.text;
+      }) || interpolatedError;
+    });
+  }
+  return parseErrors.map(function (parseError) {
+    return findErrorBoundary(query, queryLines, parseError);
+  }).filter(isErrorBoundary);
+}
+function parseQuery(query, parser) {
+  var parseErrors = [];
+  var tree = parser.parse(query);
+  tree.iterate({
+    enter: function enter(nodeRef) {
+      if (nodeRef.type.id === ErrorId) {
+        var node = nodeRef.node;
+        parseErrors.push({
+          node: node,
+          text: query.substring(node.from, node.to)
+        });
+      }
+    }
+  });
+  return parseErrors;
+}
+function findErrorBoundary(query, queryLines, parseError) {
+  if (queryLines.length === 1) {
+    var isEmptyString = parseError.node.from === parseError.node.to;
+    var errorNode = isEmptyString && parseError.node.parent ? parseError.node.parent : parseError.node;
+    var error = isEmptyString ? query.substring(errorNode.from, errorNode.to) : parseError.text;
+    return {
+      startLineNumber: 1,
+      startColumn: errorNode.from + 1,
+      endLineNumber: 1,
+      endColumn: errorNode.to + 1,
+      error: error
+    };
+  }
+  var startPos = 0,
+    endPos = 0;
+  for (var line = 0; line < queryLines.length; line++) {
+    endPos = startPos + queryLines[line].length;
+    if (parseError.node.from > endPos) {
+      startPos += queryLines[line].length + 1;
+      continue;
+    }
+    return {
+      startLineNumber: line + 1,
+      startColumn: parseError.node.from - startPos + 1,
+      endLineNumber: line + 1,
+      endColumn: parseError.node.to - startPos + 1,
+      error: parseError.text
+    };
+  }
+  return null;
+}
+function isErrorBoundary(boundary) {
+  return boundary !== null;
+}
+
+var _excluded = ["error"];
+var PROMQL_LANG_ID = promLanguageDefinition.id;
+var EDITOR_HEIGHT_OFFSET = 2;
+var SIZE_MAP = {
+  small: {
+    className: 'ant-input-sm',
+    top: 1,
+    bottom: 1
+  },
+  middle: {
+    className: 'ant-input-md',
+    top: 1,
+    bottom: 1
+  },
+  large: {
+    className: 'ant-input-lg',
+    top: 3,
+    bottom: 2
+  }
+};
+var themeMap = {
+  light: 'vs-light',
+  dark: 'vs-dark'
+};
+var getStyles = function getStyles(placeholder) {
+  return {
+    placeholder: css({
+      '::after': {
+        content: "'" + placeholder + "'",
+        opacity: 0.6
+      }
+    })
+  };
+};
+function PromQLEditor(props) {
+  var id = v4();
+  var _props$size = props.size,
+    size = _props$size === void 0 ? 'middle' : _props$size,
+    _props$theme = props.theme,
+    theme = _props$theme === void 0 ? 'light' : _props$theme,
+    variablesNames = props.variablesNames,
+    value = props.value,
+    placeholder = props.placeholder,
+    interpolateString = props.interpolateString,
+    onChange = props.onChange,
+    onShiftEnter = props.onShiftEnter,
+    onBlur = props.onBlur;
+  var autocompleteDisposeFun = useRef(null);
+  var containerRef = useRef(null);
+  var dataProviderRef = useRef(null);
+  var styles = getStyles(placeholder);
+  useEffect(function () {
+    // 注册 PromQL 语言
+    var aliases = promLanguageDefinition.aliases,
+      extensions = promLanguageDefinition.extensions,
+      mimetypes = promLanguageDefinition.mimetypes;
+    languages.register({
+      id: PROMQL_LANG_ID,
+      aliases: aliases,
+      extensions: extensions,
+      mimetypes: mimetypes
+    });
+    // 设置语法高亮
+    languages.setMonarchTokensProvider(PROMQL_LANG_ID, language);
+    // 设置语言配置
+    languages.setLanguageConfiguration(PROMQL_LANG_ID, languageConfiguration);
+    return function () {
+      autocompleteDisposeFun.current == null || autocompleteDisposeFun.current();
+    };
+  }, []);
+  var handleEditorDidMount = function handleEditorDidMount(editor$1) {
+    var isEditorFocused = editor$1.createContextKey('isEditorFocused' + id, false);
+    // we setup on-blur
+    editor$1.onDidBlurEditorWidget(function () {
+      isEditorFocused.set(false);
+      onBlur == null || onBlur(editor$1.getValue());
+    });
+    editor$1.onDidFocusEditorText(function () {
+      isEditorFocused.set(true);
+    });
+    var dataProvider = new DataProvider({
+      url: props.url,
+      lookbackInterval: props.lookbackInterval,
+      variablesNames: props.variablesNames,
+      request: props.request,
+      httpMethod: props.httpMethod,
+      apiPrefix: props.apiPrefix,
+      httpErrorHandler: props.httpErrorHandler
+    });
+    dataProviderRef.current = dataProvider;
+    dataProvider.start();
+    var completionProvider = getCompletionProvider(monaco, dataProvider);
+    var filteringCompletionProvider = _extends({}, completionProvider, {
+      provideCompletionItems: function provideCompletionItems(model, position, context, token) {
+        var _editor$getModel;
+        if (((_editor$getModel = editor$1.getModel()) == null ? void 0 : _editor$getModel.id) !== model.id) {
+          return {
+            suggestions: []
+          };
+        }
+        return completionProvider.provideCompletionItems(model, position, context, token);
+      }
+    });
+    var _monaco$languages$reg = languages.registerCompletionItemProvider(PROMQL_LANG_ID, filteringCompletionProvider),
+      dispose = _monaco$languages$reg.dispose;
+    autocompleteDisposeFun.current = dispose;
+    var updateElementHeight = function updateElementHeight() {
+      var containerDiv = containerRef.current;
+      if (containerDiv !== null) {
+        var pixelHeight = editor$1.getContentHeight();
+        containerDiv.style.height = pixelHeight + EDITOR_HEIGHT_OFFSET + "px";
+        containerDiv.style.width = '100%';
+        var pixelWidth = containerDiv.clientWidth;
+        editor$1.layout({
+          width: pixelWidth,
+          height: pixelHeight
+        });
+      }
+    };
+    editor$1.onDidContentSizeChange(updateElementHeight);
+    updateElementHeight();
+    // Fixes Monaco capturing the search key binding and displaying a useless search box within the Editor.
+    editor.addKeybindingRule({
+      keybinding: KeyMod.CtrlCmd | KeyCode.KeyF,
+      command: null
+    });
+    // handle: shift + enter
+    editor$1.addCommand(KeyMod.Shift | KeyCode.Enter, function () {
+      console.log(22222);
+      onShiftEnter == null || onShiftEnter(editor$1.getValue());
+    }, 'isEditorFocused' + id);
+    if (placeholder) {
+      var placeholderDecorators = [{
+        range: new Range(1, 1, 1, 1),
+        options: {
+          className: styles.placeholder,
+          isWholeLine: true
+        }
+      }];
+      var decorators = [];
+      var checkDecorators = function checkDecorators() {
+        var model = editor$1.getModel();
+        if (!model) {
+          return;
+        }
+        var newDecorators = model.getValueLength() === 0 ? placeholderDecorators : [];
+        decorators = model.deltaDecorations(decorators, newDecorators);
+      };
+      checkDecorators();
+      editor$1.onDidChangeModelContent(checkDecorators);
+    }
+    editor$1.onDidChangeModelContent(function () {
+      var model = editor$1.getModel();
+      if (model) {
+        var query = model.getValue();
+        var errors = validateQuery(query, interpolateString ? interpolateString(query) : query, model.getLinesContent(), parser) || [];
+        var markers = errors.map(function (_ref) {
+          var error = _ref.error,
+            boundary = _objectWithoutPropertiesLoose(_ref, _excluded);
+          return _extends({
+            message: (error ? "Error parsing \"" + error + "\"" : 'Parse error') + ". The query appears to be incorrect and could fail to be executed.",
+            severity: MarkerSeverity.Error
+          }, boundary);
+        });
+        editor.setModelMarkers(model, 'owner', markers);
+      }
+    });
+  };
+  useEffect(function () {
+    var dataProvider = dataProviderRef.current;
+    if (dataProvider) {
+      dataProvider.setVariablesNames(variablesNames || []);
+    }
+  }, [JSON.stringify(variablesNames)]);
+  return React.createElement("div", {
+    className: 'ant-input' + (size ? " " + SIZE_MAP[size].className : '')
+  }, React.createElement("div", {
+    ref: containerRef
+  }, React.createElement(MonacoEditor, {
+    width: '100%',
+    height: '100%',
+    language: 'promql',
+    theme: themeMap[theme],
+    value: value,
+    onChange: onChange,
+    editorDidMount: handleEditorDidMount,
+    options: {
+      codeLens: false,
+      contextmenu: false,
+      fixedOverflowWidgets: true,
+      folding: false,
+      fontSize: 12,
+      lineDecorationsWidth: 0,
+      lineNumbers: 'off',
+      minimap: {
+        enabled: false
+      },
+      overviewRulerBorder: false,
+      overviewRulerLanes: 0,
+      padding: {
+        top: SIZE_MAP[size].top,
+        bottom: SIZE_MAP[size].bottom
+      },
+      renderLineHighlight: 'none',
+      scrollbar: {
+        vertical: 'hidden',
+        verticalScrollbarSize: 8,
+        horizontal: 'hidden',
+        horizontalScrollbarSize: 0,
+        alwaysConsumeMouseWheel: false
+      },
+      scrollBeyondLastLine: false,
+      suggest: {
+        showWords: false
+      },
+      suggestFontSize: 12,
+      wordWrap: 'on'
+    }
+  })));
+}
+
+export { PromQLEditor as PromQLMonacoEditor };
+//# sourceMappingURL=monaco-editor.esm.js.map