@kong-ui-public/documentation 0.3.42 → 0.4.0

package/dist/pieDiagram-b0208e96-DhA_SoTh-CfDd9YdA.js

@@ -0,0 +1,501 @@
+import { aL as rt, v as at, x as lt, s as ct, g as ot, b as ht, a as ut, z as yt, d as pt, c as tt, l as et, aM as gt, aK as ft, aN as mt, i as dt, aO as B } from "./index-B-5DuDrq.js";
+import { v as Z } from "./arc-BSRpyMf3-C5dasNo_.js";
+import { h as _t } from "./ordinal-MUacOSdK-B1MUT0BL.js";
+import { t as bt } from "./array-CqVTtuYm-fKLgkG2b.js";
+import { P as R } from "./path-Crsf9Nsj-SiSjwXsf.js";
+function vt(e, h) {
+  return h < e ? -1 : h > e ? 1 : h >= e ? 0 : NaN;
+}
+function xt(e) {
+  return e;
+}
+function kt() {
+  var e = xt, h = vt, p = null, w = R(0), k = R(B), S = R(0);
+  function u(r) {
+    var l, m = (r = bt(r)).length, d, I, T = 0, _ = new Array(m), v = new Array(m), c = +w.apply(this, arguments), A = Math.min(B, Math.max(-B, k.apply(this, arguments) - c)), D, E = Math.min(Math.abs(A) / m, S.apply(this, arguments)), f = E * (A < 0 ? -1 : 1), t;
+    for (l = 0; l < m; ++l)
+      (t = v[_[l] = l] = +e(r[l], l, r)) > 0 && (T += t);
+    for (h != null ? _.sort(function(i, s) {
+      return h(v[i], v[s]);
+    }) : p != null && _.sort(function(i, s) {
+      return p(r[i], r[s]);
+    }), l = 0, I = T ? (A - m * f) / T : 0; l < m; ++l, c = D)
+      d = _[l], t = v[d], D = c + (t > 0 ? t * I : 0) + f, v[d] = {
+        data: r[d],
+        index: l,
+        value: t,
+        startAngle: c,
+        endAngle: D,
+        padAngle: E
+      };
+    return v;
+  }
+  return u.value = function(r) {
+    return arguments.length ? (e = typeof r == "function" ? r : R(+r), u) : e;
+  }, u.sortValues = function(r) {
+    return arguments.length ? (h = r, p = null, u) : h;
+  }, u.sort = function(r) {
+    return arguments.length ? (p = r, h = null, u) : p;
+  }, u.startAngle = function(r) {
+    return arguments.length ? (w = typeof r == "function" ? r : R(+r), u) : w;
+  }, u.endAngle = function(r) {
+    return arguments.length ? (k = typeof r == "function" ? r : R(+r), u) : k;
+  }, u.padAngle = function(r) {
+    return arguments.length ? (S = typeof r == "function" ? r : R(+r), u) : S;
+  }, u;
+}
+var H = function() {
+  var e = function(f, t, i, s) {
+    for (i = i || {}, s = f.length; s--; i[f[s]] = t)
+      ;
+    return i;
+  }, h = [1, 3], p = [1, 4], w = [1, 5], k = [1, 6], S = [1, 10, 12, 14, 16, 18, 19, 20, 21, 22], u = [2, 4], r = [1, 5, 10, 12, 14, 16, 18, 19, 20, 21, 22], l = [20, 21, 22], m = [2, 7], d = [1, 12], I = [1, 13], T = [1, 14], _ = [1, 15], v = [1, 16], c = [1, 17], A = {
+    trace: function() {
+    },
+    yy: {},
+    symbols_: { error: 2, start: 3, eol: 4, PIE: 5, document: 6, showData: 7, line: 8, statement: 9, txt: 10, value: 11, title: 12, title_value: 13, acc_title: 14, acc_title_value: 15, acc_descr: 16, acc_descr_value: 17, acc_descr_multiline_value: 18, section: 19, NEWLINE: 20, ";": 21, EOF: 22, $accept: 0, $end: 1 },
+    terminals_: { 2: "error", 5: "PIE", 7: "showData", 10: "txt", 11: "value", 12: "title", 13: "title_value", 14: "acc_title", 15: "acc_title_value", 16: "acc_descr", 17: "acc_descr_value", 18: "acc_descr_multiline_value", 19: "section", 20: "NEWLINE", 21: ";", 22: "EOF" },
+    productions_: [0, [3, 2], [3, 2], [3, 3], [6, 0], [6, 2], [8, 2], [9, 0], [9, 2], [9, 2], [9, 2], [9, 2], [9, 1], [9, 1], [4, 1], [4, 1], [4, 1]],
+    performAction: function(f, t, i, s, a, n, y) {
+      var x = n.length - 1;
+      switch (a) {
+        case 3:
+          s.setShowData(!0);
+          break;
+        case 6:
+          this.$ = n[x - 1];
+          break;
+        case 8:
+          s.addSection(n[x - 1], s.cleanupValue(n[x]));
+          break;
+        case 9:
+          this.$ = n[x].trim(), s.setDiagramTitle(this.$);
+          break;
+        case 10:
+          this.$ = n[x].trim(), s.setAccTitle(this.$);
+          break;
+        case 11:
+        case 12:
+          this.$ = n[x].trim(), s.setAccDescription(this.$);
+          break;
+        case 13:
+          s.addSection(n[x].substr(8)), this.$ = n[x].substr(8);
+          break;
+      }
+    },
+    table: [{ 3: 1, 4: 2, 5: h, 20: p, 21: w, 22: k }, { 1: [3] }, { 3: 7, 4: 2, 5: h, 20: p, 21: w, 22: k }, e(S, u, { 6: 8, 7: [1, 9] }), e(r, [2, 14]), e(r, [2, 15]), e(r, [2, 16]), { 1: [2, 1] }, e(l, m, { 8: 10, 9: 11, 1: [2, 2], 10: d, 12: I, 14: T, 16: _, 18: v, 19: c }), e(S, u, { 6: 18 }), e(S, [2, 5]), { 4: 19, 20: p, 21: w, 22: k }, { 11: [1, 20] }, { 13: [1, 21] }, { 15: [1, 22] }, { 17: [1, 23] }, e(l, [2, 12]), e(l, [2, 13]), e(l, m, { 8: 10, 9: 11, 1: [2, 3], 10: d, 12: I, 14: T, 16: _, 18: v, 19: c }), e(S, [2, 6]), e(l, [2, 8]), e(l, [2, 9]), e(l, [2, 10]), e(l, [2, 11])],
+    defaultActions: { 7: [2, 1] },
+    parseError: function(f, t) {
+      if (t.recoverable)
+        this.trace(f);
+      else {
+        var i = new Error(f);
+        throw i.hash = t, i;
+      }
+    },
+    parse: function(f) {
+      var t = this, i = [0], s = [], a = [null], n = [], y = this.table, x = "", N = 0, g = 0, V = 2, M = 1, Y = n.slice.call(arguments, 1), o = Object.create(this.lexer), O = { yy: {} };
+      for (var K in this.yy)
+        Object.prototype.hasOwnProperty.call(this.yy, K) && (O.yy[K] = this.yy[K]);
+      o.setInput(f, O.yy), O.yy.lexer = o, O.yy.parser = this, typeof o.yylloc > "u" && (o.yylloc = {});
+      var G = o.yylloc;
+      n.push(G);
+      var nt = o.options && o.options.ranges;
+      typeof O.yy.parseError == "function" ? this.parseError = O.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function st() {
+        var P;
+        return P = s.pop() || o.lex() || M, typeof P != "number" && (P instanceof Array && (s = P, P = s.pop()), P = t.symbols_[P] || P), P;
+      }
+      for (var b, F, $, J, z = {}, j, C, q, L; ; ) {
+        if (F = i[i.length - 1], this.defaultActions[F] ? $ = this.defaultActions[F] : ((b === null || typeof b > "u") && (b = st()), $ = y[F] && y[F][b]), typeof $ > "u" || !$.length || !$[0]) {
+          var X = "";
+          L = [];
+          for (j in y[F])
+            this.terminals_[j] && j > V && L.push("'" + this.terminals_[j] + "'");
+          o.showPosition ? X = "Parse error on line " + (N + 1) + `:
+` + o.showPosition() + `
+Expecting ` + L.join(", ") + ", got '" + (this.terminals_[b] || b) + "'" : X = "Parse error on line " + (N + 1) + ": Unexpected " + (b == M ? "end of input" : "'" + (this.terminals_[b] || b) + "'"), this.parseError(X, {
+            text: o.match,
+            token: this.terminals_[b] || b,
+            line: o.yylineno,
+            loc: G,
+            expected: L
+          });
+        }
+        if ($[0] instanceof Array && $.length > 1)
+          throw new Error("Parse Error: multiple actions possible at state: " + F + ", token: " + b);
+        switch ($[0]) {
+          case 1:
+            i.push(b), a.push(o.yytext), n.push(o.yylloc), i.push($[1]), b = null, g = o.yyleng, x = o.yytext, N = o.yylineno, G = o.yylloc;
+            break;
+          case 2:
+            if (C = this.productions_[$[1]][1], z.$ = a[a.length - C], z._$ = {
+              first_line: n[n.length - (C || 1)].first_line,
+              last_line: n[n.length - 1].last_line,
+              first_column: n[n.length - (C || 1)].first_column,
+              last_column: n[n.length - 1].last_column
+            }, nt && (z._$.range = [
+              n[n.length - (C || 1)].range[0],
+              n[n.length - 1].range[1]
+            ]), J = this.performAction.apply(z, [
+              x,
+              g,
+              N,
+              O.yy,
+              $[1],
+              a,
+              n
+            ].concat(Y)), typeof J < "u")
+              return J;
+            C && (i = i.slice(0, -1 * C * 2), a = a.slice(0, -1 * C), n = n.slice(0, -1 * C)), i.push(this.productions_[$[1]][0]), a.push(z.$), n.push(z._$), q = y[i[i.length - 2]][i[i.length - 1]], i.push(q);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }
+  }, D = /* @__PURE__ */ function() {
+    var f = {
+      EOF: 1,
+      parseError: function(t, i) {
+        if (this.yy.parser)
+          this.yy.parser.parseError(t, i);
+        else
+          throw new Error(t);
+      },
+      // resets the lexer, sets new input
+      setInput: function(t, i) {
+        return this.yy = i || this.yy || {}, this._input = t, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+      },
+      // consumes and returns one char from the input
+      input: function() {
+        var t = this._input[0];
+        this.yytext += t, this.yyleng++, this.offset++, this.match += t, this.matched += t;
+        var i = t.match(/(?:\r\n?|\n).*/g);
+        return i ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), t;
+      },
+      // unshifts one char (or a string) into the input
+      unput: function(t) {
+        var i = t.length, s = t.split(/(?:\r\n?|\n)/g);
+        this._input = t + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - i), this.offset -= i;
+        var a = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), s.length - 1 && (this.yylineno -= s.length - 1);
+        var n = this.yylloc.range;
+        return this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: s ? (s.length === a.length ? this.yylloc.first_column : 0) + a[a.length - s.length].length - s[0].length : this.yylloc.first_column - i
+        }, this.options.ranges && (this.yylloc.range = [n[0], n[0] + this.yyleng - i]), this.yyleng = this.yytext.length, this;
+      },
+      // When called from action, caches matched text and appends it on next action
+      more: function() {
+        return this._more = !0, this;
+      },
+      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+      reject: function() {
+        if (this.options.backtrack_lexer)
+          this._backtrack = !0;
+        else
+          return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        return this;
+      },
+      // retain first n characters of the match
+      less: function(t) {
+        this.unput(this.match.slice(t));
+      },
+      // displays already matched input, i.e. for error messages
+      pastInput: function() {
+        var t = this.matched.substr(0, this.matched.length - this.match.length);
+        return (t.length > 20 ? "..." : "") + t.substr(-20).replace(/\n/g, "");
+      },
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: function() {
+        var t = this.match;
+        return t.length < 20 && (t += this._input.substr(0, 20 - t.length)), (t.substr(0, 20) + (t.length > 20 ? "..." : "")).replace(/\n/g, "");
+      },
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: function() {
+        var t = this.pastInput(), i = new Array(t.length + 1).join("-");
+        return t + this.upcomingInput() + `
+` + i + "^";
+      },
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: function(t, i) {
+        var s, a, n;
+        if (this.options.backtrack_lexer && (n = {
+          yylineno: this.yylineno,
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column
+          },
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+          yy: this.yy,
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        }, this.options.ranges && (n.yylloc.range = this.yylloc.range.slice(0))), a = t[0].match(/(?:\r\n?|\n).*/g), a && (this.yylineno += a.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: a ? a[a.length - 1].length - a[a.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + t[0].length
+        }, this.yytext += t[0], this.match += t[0], this.matches = t, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(t[0].length), this.matched += t[0], s = this.performAction.call(this, this.yy, this, i, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), s)
+          return s;
+        if (this._backtrack) {
+          for (var y in n)
+            this[y] = n[y];
+          return !1;
+        }
+        return !1;
+      },
+      // return next match in input
+      next: function() {
+        if (this.done)
+          return this.EOF;
+        this._input || (this.done = !0);
+        var t, i, s, a;
+        this._more || (this.yytext = "", this.match = "");
+        for (var n = this._currentRules(), y = 0; y < n.length; y++)
+          if (s = this._input.match(this.rules[n[y]]), s && (!i || s[0].length > i[0].length)) {
+            if (i = s, a = y, this.options.backtrack_lexer) {
+              if (t = this.test_match(s, n[y]), t !== !1)
+                return t;
+              if (this._backtrack) {
+                i = !1;
+                continue;
+              } else
+                return !1;
+            } else if (!this.options.flex)
+              break;
+          }
+        return i ? (t = this.test_match(i, n[a]), t !== !1 ? t : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      },
+      // return next match that has a token
+      lex: function() {
+        var t = this.next();
+        return t || this.lex();
+      },
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+      begin: function(t) {
+        this.conditionStack.push(t);
+      },
+      // pop the previously active lexer condition state off the condition stack
+      popState: function() {
+        var t = this.conditionStack.length - 1;
+        return t > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      },
+      // produce the lexer rule set which is active for the currently active lexer condition state
+      _currentRules: function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      },
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+      topState: function(t) {
+        return t = this.conditionStack.length - 1 - Math.abs(t || 0), t >= 0 ? this.conditionStack[t] : "INITIAL";
+      },
+      // alias for begin(condition)
+      pushState: function(t) {
+        this.begin(t);
+      },
+      // return the number of states currently on the stack
+      stateStackSize: function() {
+        return this.conditionStack.length;
+      },
+      options: { "case-insensitive": !0 },
+      performAction: function(t, i, s, a) {
+        switch (s) {
+          case 0:
+            break;
+          case 1:
+            break;
+          case 2:
+            return 20;
+          case 3:
+            break;
+          case 4:
+            break;
+          case 5:
+            return this.begin("title"), 12;
+          case 6:
+            return this.popState(), "title_value";
+          case 7:
+            return this.begin("acc_title"), 14;
+          case 8:
+            return this.popState(), "acc_title_value";
+          case 9:
+            return this.begin("acc_descr"), 16;
+          case 10:
+            return this.popState(), "acc_descr_value";
+          case 11:
+            this.begin("acc_descr_multiline");
+            break;
+          case 12:
+            this.popState();
+            break;
+          case 13:
+            return "acc_descr_multiline_value";
+          case 14:
+            this.begin("string");
+            break;
+          case 15:
+            this.popState();
+            break;
+          case 16:
+            return "txt";
+          case 17:
+            return 5;
+          case 18:
+            return 7;
+          case 19:
+            return "value";
+          case 20:
+            return 22;
+        }
+      },
+      rules: [/^(?:%%(?!\{)[^\n]*)/i, /^(?:[^\}]%%[^\n]*)/i, /^(?:[\n\r]+)/i, /^(?:%%[^\n]*)/i, /^(?:[\s]+)/i, /^(?:title\b)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accTitle\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*\{\s*)/i, /^(?:[\}])/i, /^(?:[^\}]*)/i, /^(?:["])/i, /^(?:["])/i, /^(?:[^"]*)/i, /^(?:pie\b)/i, /^(?:showData\b)/i, /^(?::[\s]*[\d]+(?:\.[\d]+)?)/i, /^(?:$)/i],
+      conditions: { acc_descr_multiline: { rules: [12, 13], inclusive: !1 }, acc_descr: { rules: [10], inclusive: !1 }, acc_title: { rules: [8], inclusive: !1 }, title: { rules: [6], inclusive: !1 }, string: { rules: [15, 16], inclusive: !1 }, INITIAL: { rules: [0, 1, 2, 3, 4, 5, 7, 9, 11, 14, 17, 18, 19, 20], inclusive: !0 } }
+    };
+    return f;
+  }();
+  A.lexer = D;
+  function E() {
+    this.yy = {};
+  }
+  return E.prototype = A, A.Parser = E, new E();
+}();
+H.parser = H;
+const $t = H, it = rt.pie, U = {
+  sections: {},
+  showData: !1,
+  config: it
+};
+let W = U.sections, Q = U.showData;
+const wt = structuredClone(it), St = () => structuredClone(wt), At = () => {
+  W = structuredClone(U.sections), Q = U.showData, yt();
+}, Et = (e, h) => {
+  e = pt(e, tt()), W[e] === void 0 && (W[e] = h, et.debug(`added new section: ${e}, with value: ${h}`));
+}, Tt = () => W, It = (e) => (e.substring(0, 1) === ":" && (e = e.substring(1).trim()), Number(e.trim())), Ot = (e) => {
+  Q = e;
+}, Ct = () => Q, Pt = {
+  getConfig: St,
+  clear: At,
+  setDiagramTitle: at,
+  getDiagramTitle: lt,
+  setAccTitle: ct,
+  getAccTitle: ot,
+  setAccDescription: ht,
+  getAccDescription: ut,
+  addSection: Et,
+  getSections: Tt,
+  cleanupValue: It,
+  setShowData: Ot,
+  getShowData: Ct
+}, Dt = (e) => `
+  .pieCircle{
+    stroke: ${e.pieStrokeColor};
+    stroke-width : ${e.pieStrokeWidth};
+    opacity : ${e.pieOpacity};
+  }
+  .pieOuterCircle{
+    stroke: ${e.pieOuterStrokeColor};
+    stroke-width: ${e.pieOuterStrokeWidth};
+    fill: none;
+  }
+  .pieTitleText {
+    text-anchor: middle;
+    font-size: ${e.pieTitleTextSize};
+    fill: ${e.pieTitleTextColor};
+    font-family: ${e.fontFamily};
+  }
+  .slice {
+    font-family: ${e.fontFamily};
+    fill: ${e.pieSectionTextColor};
+    font-size:${e.pieSectionTextSize};
+    // fill: white;
+  }
+  .legend text {
+    fill: ${e.pieLegendTextColor};
+    font-family: ${e.fontFamily};
+    font-size: ${e.pieLegendTextSize};
+  }
+`, Nt = Dt, Mt = (e) => {
+  const h = Object.entries(e).map((p) => ({
+    label: p[0],
+    value: p[1]
+  })).sort((p, w) => w.value - p.value);
+  return kt().value(
+    (p) => p.value
+  )(h);
+}, Ft = (e, h, p, w) => {
+  et.debug(`rendering pie chart
+` + e);
+  const k = w.db, S = tt(), u = gt(k.getConfig(), S.pie), r = 40, l = 18, m = 4, d = 450, I = d, T = ft(h), _ = T.append("g"), v = k.getSections();
+  _.attr("transform", "translate(" + I / 2 + "," + d / 2 + ")");
+  const { themeVariables: c } = S;
+  let [A] = mt(c.pieOuterStrokeWidth);
+  A ?? (A = 2);
+  const D = u.textPosition, E = Math.min(I, d) / 2 - r, f = Z().innerRadius(0).outerRadius(E), t = Z().innerRadius(E * D).outerRadius(E * D);
+  _.append("circle").attr("cx", 0).attr("cy", 0).attr("r", E + A / 2).attr("class", "pieOuterCircle");
+  const i = Mt(v), s = [
+    c.pie1,
+    c.pie2,
+    c.pie3,
+    c.pie4,
+    c.pie5,
+    c.pie6,
+    c.pie7,
+    c.pie8,
+    c.pie9,
+    c.pie10,
+    c.pie11,
+    c.pie12
+  ], a = _t(s);
+  _.selectAll("mySlices").data(i).enter().append("path").attr("d", f).attr("fill", (g) => a(g.data.label)).attr("class", "pieCircle");
+  let n = 0;
+  Object.keys(v).forEach((g) => {
+    n += v[g];
+  }), _.selectAll("mySlices").data(i).enter().append("text").text((g) => (g.data.value / n * 100).toFixed(0) + "%").attr("transform", (g) => "translate(" + t.centroid(g) + ")").style("text-anchor", "middle").attr("class", "slice"), _.append("text").text(k.getDiagramTitle()).attr("x", 0).attr("y", -(d - 50) / 2).attr("class", "pieTitleText");
+  const y = _.selectAll(".legend").data(a.domain()).enter().append("g").attr("class", "legend").attr("transform", (g, V) => {
+    const M = l + m, Y = M * a.domain().length / 2, o = 12 * l, O = V * M - Y;
+    return "translate(" + o + "," + O + ")";
+  });
+  y.append("rect").attr("width", l).attr("height", l).style("fill", a).style("stroke", a), y.data(i).append("text").attr("x", l + m).attr("y", l - m).text((g) => {
+    const { label: V, value: M } = g.data;
+    return k.getShowData() ? `${V} [${M}]` : V;
+  });
+  const x = Math.max(
+    ...y.selectAll("text").nodes().map((g) => (g == null ? void 0 : g.getBoundingClientRect().width) ?? 0)
+  ), N = I + r + l + m + x;
+  T.attr("viewBox", `0 0 ${N} ${d}`), dt(T, d, N, u.useMaxWidth);
+}, Rt = { draw: Ft }, Wt = {
+  parser: $t,
+  db: Pt,
+  renderer: Rt,
+  styles: Nt
+};
+export {
+  Wt as diagram
+};

package/dist/plsql-8SPzZKaa-8SPzZKaa.js

@@ -0,0 +1,7 @@
+const e = Object.freeze({ displayName: "PL/SQL", fileTypes: ["sql", "ddl", "dml", "pkh", "pks", "pkb", "pck", "pls", "plb"], foldingStartMarker: "(?i)^\\s*(begin|if|loop)\\b", foldingStopMarker: "(?i)^\\s*(end)\\b", name: "plsql", patterns: [{ begin: "/\\*", end: "\\*/", name: "comment.block.oracle" }, { match: "--.*$", name: "comment.line.double-dash.oracle" }, { match: "(?i)(?:^\\s*)rem(?:\\s+.*$)", name: "comment.line.sqlplus.oracle" }, { match: "(?i)(?:^\\s*)prompt(?:\\s+.*$)", name: "comment.line.sqlplus-prompt.oracle" }, { captures: { 1: { name: "keyword.other.oracle" }, 2: { name: "keyword.other.oracle" } }, match: "(?i)^\\s*(create)(\\s+or\\s+replace)?\\s+", name: "meta.create.oracle" }, { captures: { 1: { name: "keyword.other.oracle" }, 2: { name: "keyword.other.oracle" }, 3: { name: "entity.name.type.oracle" } }, match: "(?i)\\b(package)(\\s+body)?\\s+(\\S+)", name: "meta.package.oracle" }, { captures: { 1: { name: "keyword.other.oracle" }, 2: { name: "entity.name.type.oracle" } }, match: '(?i)\\b(type)\\s+"([^"]+)"', name: "meta.type.oracle" }, { captures: { 1: { name: "keyword.other.oracle" }, 2: { name: "entity.name.function.oracle" } }, match: '(?i)^\\s*(function|procedure)\\s+"?([-a-z0-9_]+)"?', name: "meta.procedure.oracle" }, { match: "[!<>:]?=|<>|<|>|\\+|(?<!\\.)\\*|-|(?<!^)/|\\|\\|", name: "keyword.operator.oracle" }, { match: "(?i)\\b(true|false|null|is\\s+(not\\s+)?null)\\b", name: "constant.language.oracle" }, { match: "\\b\\d+(\\.\\d+)?\\b", name: "constant.numeric.oracle" }, { match: "(?i)\\b(if|elsif|else|end\\s+if|loop|end\\s+loop|for|while|case|end\\s+case|continue|return|goto)\\b", name: "keyword.control.oracle" }, { match: "(?i)\\b(or|and|not|like)\\b", name: "keyword.other.oracle" }, { match: "(?i)\\b(%(isopen|found|notfound|rowcount)|commit|rollback|sqlerrm)\\b", name: "support.function.oracle" }, { match: "(?i)\\b(sql|sqlcode)\\b", name: "variable.language.oracle" }, { match: "(?i)\\b(ascii|asciistr|chr|compose|concat|convert|decompose|dump|initcap|instr|instrb|instrc|instr2|instr4|unistr|length|lengthb|lengthc|length2|length4|lower|lpad|ltrim|nchr|replace|rpad|rtrim|soundex|substr|translate|trim|upper|vsize)\\b", name: "support.function.builtin.char.oracle" }, { match: "(?i)\\b(add_months|current_date|current_timestamp|dbtimezone|last_day|localtimestamp|months_between|new_time|next_day|round|sessiontimezone|sysdate|tz_offset|systimestamp)\\b", name: "support.function.builtin.date.oracle" }, { match: "(?i)\\b(avg|count|sum|max|min|median|corr|corr_\\w+|covar_(pop|samp)|cume_dist|dense_rank|first|group_id|grouping|grouping_id|last|percentile_cont|percentile_disc|percent_rank|rank|regr_\\w+|row_number|stats_binomial_test|stats_crosstab|stats_f_test|stats_ks_test|stats_mode|stats_mw_test|stats_one_way_anova|stats_t_test_\\w+|stats_wsr_test|stddev|stddev_pop|stddev_samp|var_pop|var_samp|variance)\\b", name: "support.function.builtin.aggregate.oracle" }, { match: "(?i)\\b(bfilename|cardinality|coalesce|decode|empty_(blob|clob)|lag|lead|listagg|lnnvl|nanvl|nullif|nvl|nvl2|sys_(context|guid|typeid|connect_by_path|extract_utc)|uid|(current\\s+)?user|userenv|cardinality|(bulk\\s+)?collect|powermultiset(_by_cardinality)?|ora_hash|standard_hash|execute\\s+immediate|alter\\s+session)\\b", name: "support.function.builtin.advanced.oracle" }, { match: "(?i)\\b(bin_to_num|cast|chartorowid|from_tz|hextoraw|numtodsinterval|numtoyminterval|rawtohex|rawtonhex|to_char|to_clob|to_date|to_dsinterval|to_lob|to_multi_byte|to_nclob|to_number|to_single_byte|to_timestamp|to_timestamp_tz|to_yminterval|scn_to_timestamp|timestamp_to_scn|rowidtochar|rowidtonchar|to_binary_double|to_binary_float|to_blob|to_nchar|con_dbid_to_id|con_guid_to_id|con_name_to_id|con_uid_to_id)\\b", name: "support.function.builtin.convert.oracle" }, { match: "(?i)\\b(abs|acos|asin|atan|atan2|bit_(and|or|xor)|ceil|cos|cosh|exp|extract|floor|greatest|least|ln|log|mod|power|remainder|round|sign|sin|sinh|sqrt|tan|tanh|trunc)\\b", name: "support.function.builtin.math.oracle" }, { match: "(?i)\\b(\\.(count|delete|exists|extend|first|last|limit|next|prior|trim|reverse))\\b", name: "support.function.builtin.collection.oracle" }, { match: "(?i)\\b(cluster_details|cluster_distance|cluster_id|cluster_probability|cluster_set|feature_details|feature_id|feature_set|feature_value|prediction|prediction_bounds|prediction_cost|prediction_details|prediction_probability|prediction_set)\\b", name: "support.function.builtin.data_mining.oracle" }, { match: "(?i)\\b(appendchildxml|deletexml|depth|extract|existsnode|extractvalue|insertchildxml|insertxmlbefore|xmlcast|xmldiff|xmlelement|xmlexists|xmlisvalid|insertchildxmlafter|insertchildxmlbefore|path|sys_dburigen|sys_xmlagg|sys_xmlgen|updatexml|xmlagg|xmlcdata|xmlcolattval|xmlcomment|xmlconcat|xmlforest|xmlparse|xmlpi|xmlquery|xmlroot|xmlsequence|xmlserialize|xmltable|xmltransform)\\b", name: "support.function.builtin.xml.oracle" }, { match: "(?i)\\b(pragma\\s+(autonomous_transaction|serially_reusable|restrict_references|exception_init|inline))\\b", name: "keyword.other.pragma.oracle" }, { match: "(?i)\\b(p(i|o|io)_[-a-z0-9_]+)\\b", name: "variable.parameter.oracle" }, { match: "(?i)\\b(l_[-a-z0-9_]+)\\b", name: "variable.other.oracle" }, { match: "(?i):\\b(new|old)\\b", name: "variable.trigger.oracle" }, { match: "(?i)\\b(connect\\s+by\\s+(nocycle\\s+)?(prior|level)|connect_by_(root|icycle)|level|start\\s+with)\\b", name: "keyword.hierarchical.sql.oracle" }, { match: "(?i)\\b(language|name|java|c)\\b", name: "keyword.wrapper.oracle" }, { match: "(?i)\\b(end|then|deterministic|exception|when|declare|begin|in|out|nocopy|is|as|exit|open|fetch|into|close|subtype|type|rowtype|default|exclusive|mode|lock|record|index\\s+by|result_cache|constant|comment|\\.(nextval|currval))\\b", name: "keyword.other.oracle" }, { match: "(?i)\\b(grant|revoke|alter|drop|force|add|check|constraint|primary\\s+key|foreign\\s+key|references|unique(\\s+index)?|column|sequence|increment\\s+by|cache|(materialized\\s+)?view|trigger|storage|tablespace|pct(free|used)|(init|max)trans|logging)\\b", name: "keyword.other.ddl.oracle" }, { match: "(?i)\\b(with|select|from|where|order\\s+(siblings\\s+)?by|group\\s+by|rollup|cube|((left|right|cross|natural)\\s+(outer\\s+)?)?join|on|asc|desc|update|set|insert|into|values|delete|distinct|union|minus|intersect|having|limit|table|between|like|of|row|(range|rows)\\s+between|nulls\\s+first|nulls\\s+last|before|after|all|any|exists|rownum|cursor|returning|over|partition\\s+by|merge|using|matched|pivot|unpivot)\\b", name: "keyword.other.sql.oracle" }, { match: "(?i)\\b(define|whenever\\s+sqlerror|exec|timing\\s+start|timing\\s+stop)\\b", name: "keyword.other.sqlplus.oracle" }, { match: "(?i)\\b(access_into_null|case_not_found|collection_is_null|cursor_already_open|dup_val_on_index|invalid_cursor|invalid_number|login_denied|no_data_found|not_logged_on|program_error|rowtype_mismatch|self_is_null|storage_error|subscript_beyond_count|subscript_outside_limit|sys_invalid_rowid|timeout_on_resource|too_many_rows|value_error|zero_divide|others)\\b", name: "support.type.exception.oracle" }, { captures: { 3: { name: "support.class.oracle" } }, match: "(?i)\\b((dbms|utl|owa|apex)_\\w+\\.(\\w+))\\b", name: "support.function.oracle" }, { captures: { 3: { name: "support.class.oracle" } }, match: "(?i)\\b((htf|htp)\\.(\\w+))\\b", name: "support.function.oracle" }, { captures: { 3: { name: "support.class.user-defined.oracle" } }, match: "(?i)\\b((\\w+_pkg|pkg_\\w+)\\.(\\w+))\\b", name: "support.function.user-defined.oracle" }, { match: "(?i)\\b(raise|raise_application_error)\\b", name: "support.function.oracle" }, { begin: "'", end: "'", name: "string.quoted.single.oracle" }, { begin: '"', end: '"', name: "string.quoted.double.oracle" }, { match: "(?i)\\b(char|varchar|varchar2|nchar|nvarchar2|boolean|date|timestamp(\\s+with(\\s+local)?\\s+time\\s+zone)?|interval\\s*day(\\(\\d*\\))?\\s*to\\s*month|interval\\s*year(\\(\\d*\\))?\\s*to\\s*second(\\(\\d*\\))?|xmltype|blob|clob|nclob|bfile|long|long\\s+raw|raw|number|integer|decimal|smallint|float|binary_(float|double|integer)|pls_(float|double|integer)|rowid|urowid|vararray|natural|naturaln|positive|positiven|signtype|simple_(float|double|integer))\\b", name: "storage.type.oracle" }], scopeName: "source.plsql.oracle" });
+var t = [
+  e
+];
+export {
+  t as default
+};

package/dist/postcss-Cz2vjx_4-Cz2vjx_4.js

@@ -0,0 +1,7 @@
+const e = Object.freeze({ displayName: "PostCSS", fileTypes: ["pcss", "postcss"], foldingStartMarker: "/\\*|^#|^\\*|^\\b|^\\.", foldingStopMarker: "\\*/|^\\s*$", name: "postcss", patterns: [{ begin: "/\\*", end: "\\*/", name: "comment.block.postcss", patterns: [{ include: "#comment-tag" }] }, { include: "#double-slash" }, { include: "#double-quoted" }, { include: "#single-quoted" }, { include: "#interpolation" }, { include: "#placeholder-selector" }, { include: "#variable" }, { include: "#variable-root-css" }, { include: "#numeric" }, { include: "#unit" }, { include: "#flag" }, { include: "#dotdotdot" }, { begin: "@include", captures: { 0: { name: "keyword.control.at-rule.css.postcss" } }, end: "(?=\\n|\\(|{|;)", name: "support.function.name.postcss.library" }, { begin: "@mixin|@function", captures: { 0: { name: "keyword.control.at-rule.css.postcss" } }, end: "$\\n?|(?=\\(|{)", name: "support.function.name.postcss.no-completions", patterns: [{ match: "[\\w-]+", name: "entity.name.function" }] }, { match: "(?<=@import)\\s[\\w/.*-]+", name: "string.quoted.double.css.postcss" }, { begin: "@", end: "$\\n?|\\s(?!(all|braille|embossed|handheld|print|projection|screen|speech|tty|tv|if|only|not)(\\s|,))|(?=;)", name: "keyword.control.at-rule.css.postcss" }, { begin: "#", end: "$\\n?|(?=\\s|,|;|\\(|\\)|\\.|\\[|{|>)", name: "entity.other.attribute-name.id.css.postcss", patterns: [{ include: "#interpolation" }, { include: "#pseudo-class" }] }, { begin: "\\.|(?<=&)(-|_)", end: "$\\n?|(?=\\s|,|;|\\(|\\)|\\[|{|>)", name: "entity.other.attribute-name.class.css.postcss", patterns: [{ include: "#interpolation" }, { include: "#pseudo-class" }] }, { begin: "\\[", end: "\\]", name: "entity.other.attribute-selector.postcss", patterns: [{ include: "#double-quoted" }, { include: "#single-quoted" }, { match: "\\^|\\$|\\*|~", name: "keyword.other.regex.postcss" }] }, { match: "(?<=\\]|\\)|not\\(|\\*|>|>\\s):[a-z:-]+|(::|:-)[a-z:-]+", name: "entity.other.attribute-name.pseudo-class.css.postcss" }, { begin: ":", end: "$\\n?|(?=;|\\s\\(|and\\(|{|}|\\),)", name: "meta.property-list.css.postcss", patterns: [{ include: "#double-slash" }, { include: "#double-quoted" }, { include: "#single-quoted" }, { include: "#interpolation" }, { include: "#variable" }, { include: "#rgb-value" }, { include: "#numeric" }, { include: "#unit" }, { include: "#flag" }, { include: "#function" }, { include: "#function-content" }, { include: "#function-content-var" }, { include: "#operator" }, { include: "#parent-selector" }, { include: "#property-value" }] }, { include: "#rgb-value" }, { include: "#function" }, { include: "#function-content" }, { begin: "(?<!\\-|\\()\\b(a|abbr|acronym|address|applet|area|article|aside|audio|b|base|big|blockquote|body|br|button|canvas|caption|cite|code|col|colgroup|datalist|dd|del|details|dfn|dialog|div|dl|dt|em|embed|eventsource|fieldset|figure|figcaption|footer|form|frame|frameset|(h[1-6])|head|header|hgroup|hr|html|i|iframe|img|input|ins|kbd|label|legend|li|link|map|mark|menu|meta|meter|nav|noframes|noscript|object|ol|optgroup|option|output|p|param|picture|pre|progress|q|samp|script|section|select|small|source|span|strike|strong|style|sub|summary|sup|table|tbody|td|textarea|tfoot|th|thead|time|title|tr|tt|ul|var|video|main|svg|rect|ruby|center|circle|ellipse|line|polyline|polygon|path|text|u|x)\\b(?!-|\\)|:\\s)|&", end: "(?=\\s|,|;|\\(|\\)|\\.|\\[|{|>|-|_)", name: "entity.name.tag.css.postcss.symbol", patterns: [{ include: "#interpolation" }, { include: "#pseudo-class" }] }, { include: "#operator" }, { match: "[a-z-]+((?=:|#{))", name: "support.type.property-name.css.postcss" }, { include: "#reserved-words" }, { include: "#property-value" }], repository: { "comment-tag": { begin: "{{", end: "}}", name: "comment.tags.postcss", patterns: [{ match: "[\\w-]+", name: "comment.tag.postcss" }] }, dotdotdot: { match: "\\.{3}", name: "variable.other" }, "double-quoted": { begin: '"', end: '"', name: "string.quoted.double.css.postcss", patterns: [{ include: "#quoted-interpolation" }] }, "double-slash": { begin: "//", end: "$", name: "comment.line.postcss", patterns: [{ include: "#comment-tag" }] }, flag: { match: "!(important|default|optional|global)", name: "keyword.other.important.css.postcss" }, function: { match: "(?<=[\\s|\\(|,|:])(?!url|format|attr)[\\w-][\\w-]*(?=\\()", name: "support.function.name.postcss" }, "function-content": { match: "(?<=url\\(|format\\(|attr\\().+?(?=\\))", name: "string.quoted.double.css.postcss" }, "function-content-var": { match: "(?<=var\\()[\\w-]+(?=\\))", name: "variable.parameter.postcss" }, interpolation: { begin: "#{", end: "}", name: "support.function.interpolation.postcss", patterns: [{ include: "#variable" }, { include: "#numeric" }, { include: "#operator" }, { include: "#unit" }, { include: "#double-quoted" }, { include: "#single-quoted" }] }, numeric: { match: "(-|\\.)?[0-9]+(\\.[0-9]+)?", name: "constant.numeric.css.postcss" }, operator: { match: "\\+|\\s-\\s|\\s-(?=\\$)|(?<=\\()-(?=\\$)|\\s-(?=\\()|\\*|/|%|=|!|<|>|~", name: "keyword.operator.postcss" }, "parent-selector": { match: "&", name: "entity.name.tag.css.postcss" }, "placeholder-selector": { begin: "(?<!\\d)%(?!\\d)", end: "$\\n?|\\s|(?=;|{)", name: "entity.other.attribute-name.placeholder-selector.postcss" }, "property-value": { match: "[\\w-]+", name: "meta.property-value.css.postcss, support.constant.property-value.css.postcss" }, "pseudo-class": { match: ":[a-z:-]+", name: "entity.other.attribute-name.pseudo-class.css.postcss" }, "quoted-interpolation": { begin: "#{", end: "}", name: "support.function.interpolation.postcss", patterns: [{ include: "#variable" }, { include: "#numeric" }, { include: "#operator" }, { include: "#unit" }] }, "reserved-words": { match: "\\b(false|from|in|not|null|through|to|true)\\b", name: "support.type.property-name.css.postcss" }, "rgb-value": { match: "(#)([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\\b", name: "constant.other.color.rgb-value.css.postcss" }, "single-quoted": { begin: "'", end: "'", name: "string.quoted.single.css.postcss", patterns: [{ include: "#quoted-interpolation" }] }, unit: { match: "(?<=[\\d]|})(ch|cm|deg|dpcm|dpi|dppx|em|ex|grad|Hz|in|kHz|mm|ms|pc|pt|px|rad|rem|s|turn|vh|vmax|vmin|vw|%)", name: "keyword.other.unit.css.postcss" }, variable: { match: "\\$[\\w-]+", name: "variable.parameter.postcss" }, "variable-root-css": { match: "(?<!&)--[\\w-]+", name: "variable.parameter.postcss" } }, scopeName: "source.css.postcss" });
+var t = [
+  e
+];
+export {
+  t as default
+};

package/dist/powershell-B0buHCuS-B0buHCuS.js

@@ -0,0 +1,7 @@
+const e = Object.freeze({ displayName: "PowerShell", name: "powershell", patterns: [{ begin: "<#", beginCaptures: { 0: { name: "punctuation.definition.comment.block.begin.powershell" } }, end: "#>", endCaptures: { 0: { name: "punctuation.definition.comment.block.end.powershell" } }, name: "comment.block.powershell", patterns: [{ include: "#commentEmbeddedDocs" }] }, { match: "[2-6]>&1|>>|>|<<|<|>|>\\||[1-6]>|[1-6]>>", name: "keyword.operator.redirection.powershell" }, { include: "#commands" }, { include: "#commentLine" }, { include: "#variable" }, { include: "#subexpression" }, { include: "#function" }, { include: "#attribute" }, { include: "#UsingDirective" }, { include: "#type" }, { include: "#hashtable" }, { include: "#doubleQuotedString" }, { include: "#scriptblock" }, { comment: "Needed to parse stuff correctly in 'argument mode'. (See about_parsing.)", include: "#doubleQuotedStringEscapes" }, { applyEndPatternLast: !0, begin: "['\\x{2018}-\\x{201B}]", beginCaptures: { 0: { name: "punctuation.definition.string.begin.powershell" } }, end: "['\\x{2018}-\\x{201B}]", endCaptures: { 0: { name: "punctuation.definition.string.end.powershell" } }, name: "string.quoted.single.powershell", patterns: [{ match: "['\\x{2018}-\\x{201B}]{2}", name: "constant.character.escape.powershell" }] }, { begin: '(@["\\x{201C}-\\x{201E}])\\s*$', beginCaptures: { 1: { name: "punctuation.definition.string.begin.powershell" } }, end: '^["\\x{201C}-\\x{201E}]@', endCaptures: { 0: { name: "punctuation.definition.string.end.powershell" } }, name: "string.quoted.double.heredoc.powershell", patterns: [{ include: "#variableNoProperty" }, { include: "#doubleQuotedStringEscapes" }, { include: "#interpolation" }] }, { begin: "(@['\\x{2018}-\\x{201B}])\\s*$", beginCaptures: { 1: { name: "punctuation.definition.string.begin.powershell" } }, end: "^['\\x{2018}-\\x{201B}]@", endCaptures: { 0: { name: "punctuation.definition.string.end.powershell" } }, name: "string.quoted.single.heredoc.powershell" }, { include: "#numericConstant" }, { begin: "(@)(\\()", beginCaptures: { 1: { name: "keyword.other.array.begin.powershell" }, 2: { name: "punctuation.section.group.begin.powershell" } }, end: "\\)", endCaptures: { 0: { name: "punctuation.section.group.end.powershell" } }, name: "meta.group.array-expression.powershell", patterns: [{ include: "$self" }] }, { begin: "((\\$))(\\()", beginCaptures: { 1: { name: "keyword.other.substatement.powershell" }, 2: { name: "punctuation.definition.subexpression.powershell" }, 3: { name: "punctuation.section.group.begin.powershell" } }, comment: "TODO: move to repo; make recursive.", end: "\\)", endCaptures: { 0: { name: "punctuation.section.group.end.powershell" } }, name: "meta.group.complex.subexpression.powershell", patterns: [{ include: "$self" }] }, { match: "(\\b(([A-Za-z0-9\\-_\\.]+)\\.(?i:exe|com|cmd|bat))\\b)", name: "support.function.powershell" }, { match: "(?<!\\w|-|\\.)((?i:begin|break|catch|clean|continue|data|default|define|do|dynamicparam|else|elseif|end|exit|finally|for|from|if|in|inlinescript|parallel|param|process|return|sequence|switch|throw|trap|try|until|var|while)|%|\\?)(?!\\w)", name: "keyword.control.powershell" }, { match: "(?<!\\w|-|[^\\)]\\.)((?i:(foreach|where)(?!-object))|%|\\?)(?!\\w)", name: "keyword.control.powershell" }, { begin: "(?<!\\w)(--%)(?!\\w)", beginCaptures: { 1: { name: "keyword.control.powershell" } }, comment: "This should be moved to the repository at some point.", end: "$", patterns: [{ match: ".+", name: "string.unquoted.powershell" }] }, { comment: "This should only be relevant inside a class but will require a rework of how classes are matched. This is a temp fix.", match: "(?<!\\w)((?i:hidden|static))(?!\\w)", name: "storage.modifier.powershell" }, { captures: { 1: { name: "storage.type.powershell" }, 2: { name: "entity.name.function" } }, comment: "capture should be entity.name.type, but it doesn't provide a good color in the default schema.", match: "(?<!\\w|-)((?i:class)|%|\\?)(?:\\s)+((?:\\p{L}|\\d|_|-|)+)\\b" }, { match: "(?<!\\w)-(?i:is(?:not)?|as)\\b", name: "keyword.operator.comparison.powershell" }, { match: "(?<!\\w)-(?i:[ic]?(?:eq|ne|[gl][te]|(?:not)?(?:like|match|contains|in)|replace))(?!\\p{L})", name: "keyword.operator.comparison.powershell" }, { match: "(?<!\\w)-(?i:join|split)(?!\\p{L})|!", name: "keyword.operator.unary.powershell" }, { match: "(?<!\\w)-(?i:and|or|not|xor)(?!\\p{L})|!", name: "keyword.operator.logical.powershell" }, { match: "(?<!\\w)-(?i:band|bor|bnot|bxor|shl|shr)(?!\\p{L})", name: "keyword.operator.bitwise.powershell" }, { match: "(?<!\\w)-(?i:f)(?!\\p{L})", name: "keyword.operator.string-format.powershell" }, { match: "[+%*/-]?=|[+/*%-]", name: "keyword.operator.assignment.powershell" }, { match: "\\|{2}|&{2}|;", name: "punctuation.terminator.statement.powershell" }, { match: "&|(?<!\\w)\\.(?= )|`|,|\\|", name: "keyword.operator.other.powershell" }, { comment: "This is very imprecise, is there a syntax for 'must come after...' ", match: "(?<!\\s|^)\\.\\.(?=\\-?\\d|\\(|\\$)", name: "keyword.operator.range.powershell" }], repository: { RequiresDirective: { begin: "(?<=#)(?i:(requires))\\s", beginCaptures: { 0: { name: "keyword.control.requires.powershell" } }, end: "$", name: "meta.requires.powershell", patterns: [{ match: "\\-(?i:Modules|PSSnapin|RunAsAdministrator|ShellId|Version|Assembly|PSEdition)", name: "keyword.other.powershell" }, { match: "(?<!-)\\b\\p{L}+|\\d+(?:\\.\\d+)*", name: "variable.parameter.powershell" }, { include: "#hashtable" }] }, UsingDirective: { captures: { 1: { name: "keyword.control.using.powershell" }, 2: { name: "keyword.other.powershell" }, 3: { name: "variable.parameter.powershell" } }, match: "(?<!\\w)(?i:(using))\\s+(?i:(namespace|module))\\s+(?i:((?:\\w+(?:\\.)?)+))" }, attribute: { begin: "(\\[)\\s*\\b(?i)(cmdletbinding|alias|outputtype|parameter|validatenotnull|validatenotnullorempty|validatecount|validateset|allownull|allowemptycollection|allowemptystring|validatescript|validaterange|validatepattern|validatelength|supportswildcards)\\b", beginCaptures: { 1: { name: "punctuation.section.bracket.begin.powershell" }, 2: { name: "support.function.attribute.powershell" } }, end: "(\\])", endCaptures: { 1: { name: "punctuation.section.bracket.end.powershell" } }, name: "meta.attribute.powershell", patterns: [{ begin: "\\(", beginCaptures: { 0: { name: "punctuation.section.group.begin.powershell" } }, end: "\\)", endCaptures: { 0: { name: "punctuation.section.group.end.powershell" } }, patterns: [{ include: "$self" }, { captures: { 1: { name: "variable.parameter.attribute.powershell" }, 2: { name: "keyword.operator.assignment.powershell" } }, match: "(?i)\\b(mandatory|valuefrompipeline|valuefrompipelinebypropertyname|valuefromremainingarguments|position|parametersetname|defaultparametersetname|supportsshouldprocess|supportspaging|positionalbinding|helpuri|confirmimpact|helpmessage)\\b(?:\\s+)?(=)?" }] }] }, commands: { patterns: [{ comment: "Verb-Noun pattern:", match: "(?:(\\p{L}|\\d|_|-|\\\\|\\:)*\\\\)?\\b(?i:Add|Approve|Assert|Backup|Block|Build|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Deploy|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Mount|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Write)\\-.+?(?:\\.(?i:exe|cmd|bat|ps1))?\\b", name: "support.function.powershell" }, { comment: "Builtin cmdlets with reserved verbs", match: "(?<!\\w)(?i:foreach-object)(?!\\w)", name: "support.function.powershell" }, { comment: "Builtin cmdlets with reserved verbs", match: "(?<!\\w)(?i:where-object)(?!\\w)", name: "support.function.powershell" }, { comment: "Builtin cmdlets with reserved verbs", match: "(?<!\\w)(?i:sort-object)(?!\\w)", name: "support.function.powershell" }, { comment: "Builtin cmdlets with reserved verbs", match: "(?<!\\w)(?i:tee-object)(?!\\w)", name: "support.function.powershell" }] }, commentEmbeddedDocs: { patterns: [{ captures: { 1: { name: "constant.string.documentation.powershell" }, 2: { name: "keyword.operator.documentation.powershell" } }, comment: "these embedded doc keywords do not support arguments, must be the only thing on the line", match: "(?:^|\\G)(?i:\\s*(\\.)(COMPONENT|DESCRIPTION|EXAMPLE|FUNCTIONALITY|INPUTS|LINK|NOTES|OUTPUTS|ROLE|SYNOPSIS))\\s*$", name: "comment.documentation.embedded.powershell" }, { captures: { 1: { name: "constant.string.documentation.powershell" }, 2: { name: "keyword.operator.documentation.powershell" }, 3: { name: "keyword.operator.documentation.powershell" } }, comment: "these embedded doc keywords require arguments though the type required may be inconsistent, they may not all be able to use the same argument match", match: "(?:^|\\G)(?i:\\s*(\\.)(EXTERNALHELP|FORWARDHELP(?:CATEGORY|TARGETNAME)|PARAMETER|REMOTEHELPRUNSPACE))\\s+(.+?)\\s*$", name: "comment.documentation.embedded.powershell" }] }, commentLine: { begin: "(?<![`\\\\-])(#)#*", captures: { 1: { name: "punctuation.definition.comment.powershell" } }, end: "$\\n?", name: "comment.line.powershell", patterns: [{ include: "#commentEmbeddedDocs" }, { include: "#RequiresDirective" }] }, doubleQuotedString: { applyEndPatternLast: !0, begin: '["\\x{201C}-\\x{201E}]', beginCaptures: { 0: { name: "punctuation.definition.string.begin.powershell" } }, end: '["\\x{201C}-\\x{201E}]', endCaptures: { 0: { name: "punctuation.definition.string.end.powershell" } }, name: "string.quoted.double.powershell", patterns: [{ match: "(?i)\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,64}\\b" }, { include: "#variableNoProperty" }, { include: "#doubleQuotedStringEscapes" }, { match: '["\\x{201C}-\\x{201E}]{2}', name: "constant.character.escape.powershell" }, { include: "#interpolation" }, { match: "`\\s*$", name: "keyword.other.powershell" }] }, doubleQuotedStringEscapes: { patterns: [{ match: "`[`0abefnrtv'\"\\x{2018}-\\x{201E}$]", name: "constant.character.escape.powershell" }, { include: "#unicodeEscape" }] }, function: { begin: "^(?:\\s*+)(?i)(function|filter|configuration|workflow)\\s+(?:(global|local|script|private):)?((?:\\p{L}|\\d|_|-|\\.)+)", beginCaptures: { 0: { name: "meta.function.powershell" }, 1: { name: "storage.type.powershell" }, 2: { name: "storage.modifier.scope.powershell" }, 3: { name: "entity.name.function.powershell" } }, end: "(?=\\{|\\()", patterns: [{ include: "#commentLine" }] }, hashtable: { begin: "(@)(\\{)", beginCaptures: { 1: { name: "keyword.other.hashtable.begin.powershell" }, 2: { name: "punctuation.section.braces.begin.powershell" } }, end: "(\\})", endCaptures: { 1: { name: "punctuation.section.braces.end.powershell" } }, name: "meta.hashtable.powershell", patterns: [{ captures: { 1: { name: "punctuation.definition.string.begin.powershell" }, 2: { name: "variable.other.readwrite.powershell" }, 3: { name: "punctuation.definition.string.end.powershell" }, 4: { name: "keyword.operator.assignment.powershell" } }, match: `\\b((?:\\'|\\")?)(\\w+)((?:\\'|\\")?)(?:\\s+)?(=)(?:\\s+)?`, name: "meta.hashtable.assignment.powershell" }, { include: "#scriptblock" }, { include: "$self" }] }, interpolation: { begin: "(((\\$)))((\\())", beginCaptures: { 1: { name: "keyword.other.substatement.powershell" }, 2: { name: "punctuation.definition.substatement.powershell" }, 3: { name: "punctuation.section.embedded.substatement.begin.powershell" }, 4: { name: "punctuation.section.group.begin.powershell" }, 5: { name: "punctuation.section.embedded.substatement.begin.powershell" } }, contentName: "interpolated.complex.source.powershell", end: "(\\))", endCaptures: { 0: { name: "punctuation.section.group.end.powershell" }, 1: { name: "punctuation.section.embedded.substatement.end.powershell" } }, name: "meta.embedded.substatement.powershell", patterns: [{ include: "$self" }] }, numericConstant: { patterns: [{ captures: { 1: { name: "constant.numeric.hex.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?0(?:x|X)[0-9a-fA-F_]+(?:U|u|L|l|UL|Ul|uL|ul|LU|Lu|lU|lu)?)((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.integer.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?(?:[0-9_]+)?\\.[0-9_]+(?:(?:e|E)[0-9]+)?(?:F|f|D|d|M|m)?)((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.octal.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?0(?:b|B)[01_]+(?:U|u|L|l|UL|Ul|uL|ul|LU|Lu|lU|lu)?)((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.integer.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?[0-9_]+(?:e|E)(?:[0-9_])?+(?:F|f|D|d|M|m)?)((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.integer.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?[0-9_]+\\.(?:e|E)(?:[0-9_])?+(?:F|f|D|d|M|m)?)((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.integer.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?[0-9_]+[\\.]?(?:F|f|D|d|M|m))((?i:[kmgtp]b)?)\\b" }, { captures: { 1: { name: "constant.numeric.integer.powershell" }, 2: { name: "keyword.other.powershell" } }, match: "(?<!\\w)([-+]?[0-9_]+[\\.]?(?:U|u|L|l|UL|Ul|uL|ul|LU|Lu|lU|lu)?)((?i:[kmgtp]b)?)\\b" }] }, scriptblock: { begin: "\\{", beginCaptures: { 0: { name: "punctuation.section.braces.begin.powershell" } }, end: "\\}", endCaptures: { 0: { name: "punctuation.section.braces.end.powershell" } }, name: "meta.scriptblock.powershell", patterns: [{ include: "$self" }] }, subexpression: { begin: "\\(", beginCaptures: { 0: { name: "punctuation.section.group.begin.powershell" } }, end: "\\)", endCaptures: { 0: { name: "punctuation.section.group.end.powershell" } }, name: "meta.group.simple.subexpression.powershell", patterns: [{ include: "$self" }] }, type: { begin: "\\[", beginCaptures: { 0: { name: "punctuation.section.bracket.begin.powershell" } }, end: "\\]", endCaptures: { 0: { name: "punctuation.section.bracket.end.powershell" } }, patterns: [{ match: "(?!\\d+|\\.)(?:\\p{L}|\\p{N}|\\.)+", name: "storage.type.powershell" }, { include: "$self" }] }, unicodeEscape: { comment: "`u{xxxx} added in PowerShell 6.0", patterns: [{ match: "`u\\{(?:(?:10)?([0-9a-fA-F]){1,4}|0?\\g<1>{1,5})}", name: "constant.character.escape.powershell" }, { match: "`u(?:\\{[0-9a-fA-F]{,6}.)?", name: "invalid.character.escape.powershell" }] }, variable: { patterns: [{ captures: { 0: { name: "constant.language.powershell" }, 1: { name: "punctuation.definition.variable.powershell" } }, comment: "These are special constants.", match: "(\\$)(?i:(False|Null|True))\\b" }, { captures: { 0: { name: "support.constant.variable.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "These are the other built-in constants.", match: "(\\$)(?i:(Error|ExecutionContext|Host|Home|PID|PsHome|PsVersionTable|ShellID))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?\\b" }, { captures: { 0: { name: "support.variable.automatic.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "Automatic variables are not constants, but they are read-only. In monokai (default) color schema support.variable doesn't have color, so we use constant.", match: "(\\$)((?:[$^?])|(?i:_|Args|ConsoleFileName|Event|EventArgs|EventSubscriber|ForEach|Input|LastExitCode|Matches|MyInvocation|NestedPromptLevel|Profile|PSBoundParameters|PsCmdlet|PsCulture|PSDebugContext|PSItem|PSCommandPath|PSScriptRoot|PsUICulture|Pwd|Sender|SourceArgs|SourceEventArgs|StackTrace|Switch|This)\\b)((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?" }, { captures: { 0: { name: "variable.language.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "Style preference variables as language variables so that they stand out.", match: "(\\$)(?i:(ConfirmPreference|DebugPreference|ErrorActionPreference|ErrorView|FormatEnumerationLimit|InformationPreference|LogCommandHealthEvent|LogCommandLifecycleEvent|LogEngineHealthEvent|LogEngineLifecycleEvent|LogProviderHealthEvent|LogProviderLifecycleEvent|MaximumAliasCount|MaximumDriveCount|MaximumErrorCount|MaximumFunctionCount|MaximumHistoryCount|MaximumVariableCount|OFS|OutputEncoding|PSCulture|PSDebugContext|PSDefaultParameterValues|PSEmailServer|PSItem|PSModuleAutoLoadingPreference|PSModuleAutoloadingPreference|PSSenderInfo|PSSessionApplicationName|PSSessionConfigurationName|PSSessionOption|ProgressPreference|VerbosePreference|WarningPreference|WhatIfPreference))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?\\b" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "storage.modifier.scope.powershell" }, 4: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$|@)(global|local|private|script|using|workflow):((?:\\p{L}|\\d|_)+))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "punctuation.section.braces.begin.powershell" }, 3: { name: "storage.modifier.scope.powershell" }, 5: { name: "punctuation.section.braces.end.powershell" }, 6: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$)(\\{)(global|local|private|script|using|workflow):([^}]*[^}`])(\\}))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "support.variable.drive.powershell" }, 4: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$|@)((?:\\p{L}|\\d|_)+:)?((?:\\p{L}|\\d|_)+))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "punctuation.section.braces.begin.powershell" }, 3: { name: "support.variable.drive.powershell" }, 5: { name: "punctuation.section.braces.end.powershell" }, 6: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$)(\\{)((?:\\p{L}|\\d|_)+:)?([^}]*[^}`])(\\}))((?:\\.(?:\\p{L}|\\d|_)+)*\\b)?" }] }, variableNoProperty: { patterns: [{ captures: { 0: { name: "constant.language.powershell" }, 1: { name: "punctuation.definition.variable.powershell" } }, comment: "These are special constants.", match: "(\\$)(?i:(False|Null|True))\\b" }, { captures: { 0: { name: "support.constant.variable.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "These are the other built-in constants.", match: "(\\$)(?i:(Error|ExecutionContext|Host|Home|PID|PsHome|PsVersionTable|ShellID))\\b" }, { captures: { 0: { name: "support.variable.automatic.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "Automatic variables are not constants, but they are read-only...", match: "(\\$)((?:[$^?])|(?i:_|Args|ConsoleFileName|Event|EventArgs|EventSubscriber|ForEach|Input|LastExitCode|Matches|MyInvocation|NestedPromptLevel|Profile|PSBoundParameters|PsCmdlet|PsCulture|PSDebugContext|PSItem|PSCommandPath|PSScriptRoot|PsUICulture|Pwd|Sender|SourceArgs|SourceEventArgs|StackTrace|Switch|This)\\b)" }, { captures: { 0: { name: "variable.language.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 3: { name: "variable.other.member.powershell" } }, comment: "Style preference variables as language variables so that they stand out.", match: "(\\$)(?i:(ConfirmPreference|DebugPreference|ErrorActionPreference|ErrorView|FormatEnumerationLimit|InformationPreference|LogCommandHealthEvent|LogCommandLifecycleEvent|LogEngineHealthEvent|LogEngineLifecycleEvent|LogProviderHealthEvent|LogProviderLifecycleEvent|MaximumAliasCount|MaximumDriveCount|MaximumErrorCount|MaximumFunctionCount|MaximumHistoryCount|MaximumVariableCount|OFS|OutputEncoding|PSCulture|PSDebugContext|PSDefaultParameterValues|PSEmailServer|PSItem|PSModuleAutoLoadingPreference|PSModuleAutoloadingPreference|PSSenderInfo|PSSessionApplicationName|PSSessionConfigurationName|PSSessionOption|ProgressPreference|VerbosePreference|WarningPreference|WhatIfPreference))\\b" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "storage.modifier.scope.powershell" }, 4: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$)(global|local|private|script|using|workflow):((?:\\p{L}|\\d|_)+))" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "storage.modifier.scope.powershell" }, 4: { name: "keyword.other.powershell" }, 5: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$)(\\{)(global|local|private|script|using|workflow):([^}]*[^}`])(\\}))" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "support.variable.drive.powershell" }, 4: { name: "variable.other.member.powershell" } }, match: "(?i:(\\$)((?:\\p{L}|\\d|_)+:)?((?:\\p{L}|\\d|_)+))" }, { captures: { 0: { name: "variable.other.readwrite.powershell" }, 1: { name: "punctuation.definition.variable.powershell" }, 2: { name: "punctuation.section.braces.begin" }, 3: { name: "support.variable.drive.powershell" }, 5: { name: "punctuation.section.braces.end" } }, match: "(?i:(\\$)(\\{)((?:\\p{L}|\\d|_)+:)?([^}]*[^}`])(\\}))" }] } }, scopeName: "source.powershell", aliases: ["ps", "ps1"] });
+var t = [
+  e
+];
+export {
+  t as default
+};

package/dist/proto-6YaU_lta-6YaU_lta.js

@@ -0,0 +1,7 @@
+const e = Object.freeze({ displayName: "Protocol Buffer 3", fileTypes: ["proto"], name: "proto", patterns: [{ include: "#comments" }, { include: "#syntax" }, { include: "#package" }, { include: "#import" }, { include: "#optionStmt" }, { include: "#message" }, { include: "#enum" }, { include: "#service" }], repository: { comments: { patterns: [{ begin: "/\\*", end: "\\*/", name: "comment.block.proto" }, { begin: "//", end: "$\\n?", name: "comment.line.double-slash.proto" }] }, constants: { match: "\\b(true|false|max|[A-Z_]+)\\b", name: "constant.language.proto" }, enum: { begin: "(enum)(\\s+)([A-Za-z][A-Za-z0-9_]*)(\\s*)(\\{)?", beginCaptures: { 1: { name: "keyword.other.proto" }, 3: { name: "entity.name.class.proto" } }, end: "\\}", patterns: [{ include: "#reserved" }, { include: "#optionStmt" }, { include: "#comments" }, { begin: "([A-Za-z][A-Za-z0-9_]*)\\s*(=)\\s*(0[xX][0-9a-fA-F]+|[0-9]+)", beginCaptures: { 1: { name: "variable.other.proto" }, 2: { name: "keyword.operator.assignment.proto" }, 3: { name: "constant.numeric.proto" } }, end: "(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#fieldOptions" }] }] }, field: { begin: "\\s*(optional|repeated|required)?\\s*\\b([\\w.]+)\\s+(\\w+)\\s*(=)\\s*(0[xX][0-9a-fA-F]+|[0-9]+)", beginCaptures: { 1: { name: "storage.modifier.proto" }, 2: { name: "storage.type.proto" }, 3: { name: "variable.other.proto" }, 4: { name: "keyword.operator.assignment.proto" }, 5: { name: "constant.numeric.proto" } }, end: "(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#fieldOptions" }] }, fieldOptions: { begin: "\\[", end: "\\]", patterns: [{ include: "#constants" }, { include: "#number" }, { include: "#string" }, { include: "#subMsgOption" }, { include: "#optionName" }] }, ident: { match: "[A-Za-z][A-Za-z0-9_]*", name: "entity.name.class.proto" }, import: { captures: { 1: { name: "keyword.other.proto" }, 2: { name: "keyword.other.proto" }, 3: { name: "string.quoted.double.proto.import" }, 4: { name: "punctuation.terminator.proto" } }, match: '\\s*(import)\\s+(weak|public)?\\s*("[^"]+")\\s*(;)' }, kv: { begin: "(\\w+)\\s*(:)", beginCaptures: { 1: { name: "keyword.other.proto" }, 2: { name: "punctuation.separator.key-value.proto" } }, end: "(;)|,|(?=[}/_a-zA-Z])", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#constants" }, { include: "#number" }, { include: "#string" }, { include: "#subMsgOption" }] }, mapfield: { begin: "\\s*(map)\\s*(<)\\s*([\\w.]+)\\s*,\\s*([\\w.]+)\\s*(>)\\s+(\\w+)\\s*(=)\\s*(\\d+)", beginCaptures: { 1: { name: "storage.type.proto" }, 2: { name: "punctuation.definition.typeparameters.begin.proto" }, 3: { name: "storage.type.proto" }, 4: { name: "storage.type.proto" }, 5: { name: "punctuation.definition.typeparameters.end.proto" }, 6: { name: "variable.other.proto" }, 7: { name: "keyword.operator.assignment.proto" }, 8: { name: "constant.numeric.proto" } }, end: "(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#fieldOptions" }] }, message: { begin: "(message|extend)(\\s+)([A-Za-z_][A-Za-z0-9_.]*)(\\s*)(\\{)?", beginCaptures: { 1: { name: "keyword.other.proto" }, 3: { name: "entity.name.class.message.proto" } }, end: "\\}", patterns: [{ include: "#reserved" }, { include: "$self" }, { include: "#enum" }, { include: "#optionStmt" }, { include: "#comments" }, { include: "#oneof" }, { include: "#field" }, { include: "#mapfield" }] }, method: { begin: "(rpc)\\s+([A-Za-z][A-Za-z0-9_]*)", beginCaptures: { 1: { name: "keyword.other.proto" }, 2: { name: "entity.name.function" } }, end: "\\}|(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#comments" }, { include: "#optionStmt" }, { include: "#rpcKeywords" }, { include: "#ident" }] }, number: { match: "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)\\b", name: "constant.numeric.proto" }, oneof: { begin: "(oneof)\\s+([A-Za-z][A-Za-z0-9_]*)\\s*\\{?", beginCaptures: { 1: { name: "keyword.other.proto" }, 2: { name: "variable.other.proto" } }, end: "\\}", patterns: [{ include: "#optionStmt" }, { include: "#comments" }, { include: "#field" }] }, optionName: { captures: { 1: { name: "support.other.proto" }, 2: { name: "support.other.proto" }, 3: { name: "support.other.proto" } }, match: "(\\w+|\\(\\w+(\\.\\w+)*\\))(\\.\\w+)*" }, optionStmt: { begin: "(option)\\s+(\\w+|\\(\\w+(\\.\\w+)*\\))(\\.\\w+)*\\s*(=)", beginCaptures: { 1: { name: "keyword.other.proto" }, 2: { name: "support.other.proto" }, 3: { name: "support.other.proto" }, 4: { name: "support.other.proto" }, 5: { name: "keyword.operator.assignment.proto" } }, end: "(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ include: "#constants" }, { include: "#number" }, { include: "#string" }, { include: "#subMsgOption" }] }, package: { captures: { 1: { name: "keyword.other.proto" }, 2: { name: "string.unquoted.proto.package" }, 3: { name: "punctuation.terminator.proto" } }, match: "\\s*(package)\\s+([\\w.]+)\\s*(;)" }, reserved: { begin: "(reserved)\\s+", beginCaptures: { 1: { name: "keyword.other.proto" } }, end: "(;)", endCaptures: { 1: { name: "punctuation.terminator.proto" } }, patterns: [{ captures: { 1: { name: "constant.numeric.proto" }, 3: { name: "keyword.other.proto" }, 4: { name: "constant.numeric.proto" } }, match: "(\\d+)(\\s+(to)\\s+(\\d+))?" }, { include: "#string" }] }, rpcKeywords: { match: "\\b(stream|returns)\\b", name: "keyword.other.proto" }, service: { begin: "(service)\\s+([A-Za-z][A-Za-z0-9_.]*)\\s*\\{?", beginCaptures: { 1: { name: "keyword.other.proto" }, 2: { name: "entity.name.class.message.proto" } }, end: "\\}", patterns: [{ include: "#comments" }, { include: "#optionStmt" }, { include: "#method" }] }, storagetypes: { match: "\\b(double|float|int32|int64|uint32|uint64|sint32|sint64|fixed32|fixed64|sfixed32|sfixed64|bool|string|bytes)\\b", name: "storage.type.proto" }, string: { match: `('([^']|\\')*')|("([^"]|\\")*")`, name: "string.quoted.double.proto" }, subMsgOption: { begin: "\\{", end: "\\}", patterns: [{ include: "#kv" }, { include: "#comments" }] }, syntax: { captures: { 1: { name: "keyword.other.proto" }, 2: { name: "keyword.operator.assignment.proto" }, 3: { name: "string.quoted.double.proto.syntax" }, 4: { name: "punctuation.terminator.proto" } }, match: '\\s*(syntax)\\s*(=)\\s*("proto[23]")\\s*(;)' } }, scopeName: "source.proto" });
+var t = [
+  e
+];
+export {
+  t as default
+};