@glodon-aiot/agent-cli-ui 0.0.0-20251106104234

package/dist/es/node_modules/refractor/lang/q.mjs

@@ -0,0 +1,62 @@
+var r, t;
+function a() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "q", e.aliases = [];
+  function e(s) {
+    s.languages.q = {
+      string: /"(?:\\.|[^"\\\r\n])*"/,
+      comment: [
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.
+        {
+          pattern: /([\t )\]}])\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.
+        // A / on a line by itself begins a multiline comment which is terminated by the next \ on a line by itself.
+        // If a / is not matched by a \, the multiline comment is unterminated and continues to end of file.
+        // The / and \ must be the first char on the line, but may be followed by any amount of whitespace.
+        {
+          pattern: /(^|\r?\n|\r)\/[\t ]*(?:(?:\r?\n|\r)(?:.*(?:\r?\n|\r(?!\n)))*?(?:\\(?=[\t ]*(?:\r?\n|\r))|$)|\S.*)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A \ on a line by itself with no preceding matching / will comment to end of file.
+        {
+          pattern: /^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
+          greedy: !0
+        },
+        {
+          pattern: /^#!.+/m,
+          greedy: !0
+        }
+      ],
+      symbol: /`(?::\S+|[\w.]*)/,
+      datetime: {
+        pattern: /0N[mdzuvt]|0W[dtz]|\d{4}\.\d\d(?:m|\.\d\d(?:T(?:\d\d(?::\d\d(?::\d\d(?:[.:]\d\d\d)?)?)?)?)?[dz]?)|\d\d:\d\d(?::\d\d(?:[.:]\d\d\d)?)?[uvt]?/,
+        alias: "number"
+      },
+      // The negative look-ahead prevents bad highlighting
+      // of verbs 0: and 1:
+      number: /\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\da-fA-F]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?[hjfeb]?)/,
+      keyword: /\\\w+\b|\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\b/,
+      adverb: {
+        pattern: /['\/\\]:?|\beach\b/,
+        alias: "function"
+      },
+      verb: {
+        pattern: /(?:\B\.\B|\b[01]:|<[=>]?|>=?|[:+\-*%,!?~=|$&#@^]):?|\b_\b:?/,
+        alias: "operator"
+      },
+      punctuation: /[(){}\[\];.]/
+    };
+  }
+  return r;
+}
+export {
+  a as __require
+};

package/dist/es/node_modules/refractor/lang/qml.mjs

@@ -0,0 +1,67 @@
+var n, s;
+function i() {
+  if (s)
+    return n;
+  s = 1, n = r, r.displayName = "qml", r.aliases = [];
+  function r(u) {
+    (function(t) {
+      for (var o = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source, p = /\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))*\*\//.source, e = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/.source.replace(/<string>/g, function() {
+        return o;
+      }).replace(/<comment>/g, function() {
+        return p;
+      }), a = 0; a < 2; a++)
+        e = e.replace(/<expr>/g, function() {
+          return e;
+        });
+      e = e.replace(/<expr>/g, "[^\\s\\S]"), t.languages.qml = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: !0
+        },
+        "javascript-function": {
+          pattern: RegExp(/((?:^|;)[ \t]*)function\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(/<js>/g, function() {
+            return e;
+          }), "m"),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "language-javascript",
+          inside: t.languages.javascript
+        },
+        "class-name": {
+          pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m,
+          lookbehind: !0
+        },
+        property: [{
+          pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+          lookbehind: !0
+        }, {
+          pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+          lookbehind: !0,
+          inside: {
+            keyword: /^property/,
+            property: /\w+(?:\.\w+)*/
+          }
+        }],
+        "javascript-expression": {
+          pattern: RegExp(/(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(/<js>/g, function() {
+            return e;
+          }), "m"),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "language-javascript",
+          inside: t.languages.javascript
+        },
+        string: {
+          pattern: /"(?:\\.|[^\\"\r\n])*"/,
+          greedy: !0
+        },
+        keyword: /\b(?:as|import|on)\b/,
+        punctuation: /[{}[\]:;,]/
+      };
+    })(u);
+  }
+  return n;
+}
+export {
+  i as __require
+};

package/dist/es/node_modules/refractor/lang/qore.mjs

@@ -0,0 +1,32 @@
+var t, n;
+function o() {
+  if (n)
+    return t;
+  n = 1, t = e, e.displayName = "qore", e.aliases = [];
+  function e(r) {
+    r.languages.qore = r.languages.extend("clike", {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+        lookbehind: !0
+      },
+      // Overridden to allow unescaped multi-line strings
+      string: {
+        pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: !0
+      },
+      keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+      boolean: /\b(?:false|true)\b/i,
+      function: /\$?\b(?!\d)\w+(?=\()/,
+      number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+        lookbehind: !0
+      },
+      variable: /\$(?!\d)\w+\b/
+    });
+  }
+  return t;
+}
+export {
+  o as __require
+};

package/dist/es/node_modules/refractor/lang/qsharp.mjs

@@ -0,0 +1,93 @@
+var u, f;
+function v() {
+  if (f)
+    return u;
+  f = 1, u = i, i.displayName = "qsharp", i.aliases = ["qs"];
+  function i(o) {
+    (function(r) {
+      function s(e, a) {
+        return e.replace(/<<(\d+)>>/g, function(t, w) {
+          return "(?:" + a[+w] + ")";
+        });
+      }
+      function n(e, a, t) {
+        return RegExp(s(e, a), t || "");
+      }
+      function h(e, a) {
+        for (var t = 0; t < a; t++)
+          e = e.replace(/<<self>>/g, function() {
+            return "(?:" + e + ")";
+          });
+        return e.replace(/<<self>>/g, "[^\\s\\S]");
+      }
+      var l = {
+        // keywords which represent a return or variable type
+        type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+        // all other keywords
+        other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+      };
+      function q(e) {
+        return "\\b(?:" + e.trim().replace(/ /g, "|") + ")\\b";
+      }
+      var p = RegExp(q(l.type + " " + l.other)), y = /\b[A-Za-z_]\w*\b/.source, d = s(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [y]), g = {
+        keyword: p,
+        punctuation: /[<>()?,.:[\]]/
+      }, c = /"(?:\\.|[^\\"])*"/.source;
+      r.languages.qsharp = r.languages.extend("clike", {
+        comment: /\/\/.*/,
+        string: [{
+          pattern: n(/(^|[^$\\])<<0>>/.source, [c]),
+          lookbehind: !0,
+          greedy: !0
+        }],
+        "class-name": [{
+          // open Microsoft.Quantum.Canon;
+          // open Microsoft.Quantum.Canon as CN;
+          pattern: n(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [d]),
+          lookbehind: !0,
+          inside: g
+        }, {
+          // namespace Quantum.App1;
+          pattern: n(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [d]),
+          lookbehind: !0,
+          inside: g
+        }],
+        keyword: p,
+        number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+        operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+        punctuation: /::|[{}[\];(),.:]/
+      }), r.languages.insertBefore("qsharp", "number", {
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        }
+      });
+      var b = h(s(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [c]), 2);
+      r.languages.insertBefore("qsharp", "string", {
+        "interpolation-string": {
+          pattern: n(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [b]),
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: n(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [b]),
+              lookbehind: !0,
+              inside: {
+                punctuation: /^\{|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  alias: "language-qsharp",
+                  inside: r.languages.qsharp
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+    })(o), o.languages.qs = o.languages.qsharp;
+  }
+  return u;
+}
+export {
+  v as __require
+};

package/dist/es/node_modules/refractor/lang/r.mjs

@@ -0,0 +1,31 @@
+var r, a;
+function t() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "r", e.aliases = [];
+  function e(n) {
+    n.languages.r = {
+      comment: /#.*/,
+      string: {
+        pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "percent-operator": {
+        // Includes user-defined operators
+        // and %%, %*%, %/%, %in%, %o%, %x%
+        pattern: /%[^%\s]*%/,
+        alias: "operator"
+      },
+      boolean: /\b(?:FALSE|TRUE)\b/,
+      ellipsis: /\.\.(?:\.|\d+)/,
+      number: [/\b(?:Inf|NaN)\b/, /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/],
+      keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+      operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+      punctuation: /[(){}\[\],;]/
+    };
+  }
+  return r;
+}
+export {
+  t as __require
+};

package/dist/es/node_modules/refractor/lang/racket.mjs

@@ -0,0 +1,29 @@
+import { __require as u } from "./scheme.mjs";
+var r, t;
+function c() {
+  if (t)
+    return r;
+  t = 1;
+  var n = u();
+  r = a, a.displayName = "racket", a.aliases = ["rkt"];
+  function a(e) {
+    e.register(n), e.languages.racket = e.languages.extend("scheme", {
+      "lambda-parameter": {
+        // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.
+        // this will just prevent false positives of the `function` pattern
+        pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
+        lookbehind: !0
+      }
+    }), e.languages.insertBefore("racket", "string", {
+      lang: {
+        pattern: /^#lang.+/m,
+        greedy: !0,
+        alias: "keyword"
+      }
+    }), e.languages.rkt = e.languages.racket;
+  }
+  return r;
+}
+export {
+  c as __require
+};

package/dist/es/node_modules/refractor/lang/reason.mjs

@@ -0,0 +1,33 @@
+var a, r;
+function t() {
+  if (r)
+    return a;
+  r = 1, a = n, n.displayName = "reason", n.aliases = [];
+  function n(e) {
+    e.languages.reason = e.languages.extend("clike", {
+      string: {
+        pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+        greedy: !0
+      },
+      // 'class-name' must be matched *after* 'constructor' defined below
+      "class-name": /\b[A-Z]\w*/,
+      keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
+      operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/
+    }), e.languages.insertBefore("reason", "class-name", {
+      char: {
+        pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
+        greedy: !0
+      },
+      // Negative look-ahead prevents from matching things like String.capitalize
+      constructor: /\b[A-Z]\w*\b(?!\s*\.)/,
+      label: {
+        pattern: /\b[a-z]\w*(?=::)/,
+        alias: "symbol"
+      }
+    }), delete e.languages.reason.function;
+  }
+  return a;
+}
+export {
+  t as __require
+};

package/dist/es/node_modules/refractor/lang/regex.mjs

@@ -0,0 +1,97 @@
+var r, s;
+function d() {
+  if (s)
+    return r;
+  s = 1, r = e, e.displayName = "regex", e.aliases = [];
+  function e(p) {
+    (function(c) {
+      var t = {
+        pattern: /\\[\\(){}[\]^$+*?|.]/,
+        alias: "escape"
+      }, a = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, u = {
+        pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      }, o = {
+        pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      }, n = "(?:[^\\\\-]|" + a.source + ")", l = RegExp(n + "-" + n), i = {
+        pattern: /(<|')[^<>']+(?=[>']$)/,
+        lookbehind: !0,
+        alias: "variable"
+      };
+      c.languages.regex = {
+        "char-class": {
+          pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+          lookbehind: !0,
+          inside: {
+            "char-class-negation": {
+              pattern: /(^\[)\^/,
+              lookbehind: !0,
+              alias: "operator"
+            },
+            "char-class-punctuation": {
+              pattern: /^\[|\]$/,
+              alias: "punctuation"
+            },
+            range: {
+              pattern: l,
+              inside: {
+                escape: a,
+                "range-punctuation": {
+                  pattern: /-/,
+                  alias: "operator"
+                }
+              }
+            },
+            "special-escape": t,
+            "char-set": o,
+            escape: a
+          }
+        },
+        "special-escape": t,
+        "char-set": u,
+        backreference: [{
+          // a backreference which is not an octal escape
+          pattern: /\\(?![123][0-7]{2})[1-9]/,
+          alias: "keyword"
+        }, {
+          pattern: /\\k<[^<>']+>/,
+          alias: "keyword",
+          inside: {
+            "group-name": i
+          }
+        }],
+        anchor: {
+          pattern: /[$^]|\\[ABbGZz]/,
+          alias: "function"
+        },
+        escape: a,
+        group: [{
+          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+          pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+          alias: "punctuation",
+          inside: {
+            "group-name": i
+          }
+        }, {
+          pattern: /\)/,
+          alias: "punctuation"
+        }],
+        quantifier: {
+          pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+          alias: "number"
+        },
+        alternation: {
+          pattern: /\|/,
+          alias: "keyword"
+        }
+      };
+    })(p);
+  }
+  return r;
+}
+export {
+  d as __require
+};

package/dist/es/node_modules/refractor/lang/rego.mjs

@@ -0,0 +1,37 @@
+var r, t;
+function a() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "rego", e.aliases = [];
+  function e(n) {
+    n.languages.rego = {
+      comment: /#.*/,
+      property: {
+        pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
+        lookbehind: !0,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"|`[^`]*`/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /\b(?:as|default|else|import|not|null|package|set(?=\s*\()|some|with)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*\b(?:\s*\.\s*\b[a-z_]\w*\b)*(?=\s*\()/i,
+        inside: {
+          namespace: /\b\w+\b(?=\s*\.)/,
+          punctuation: /\./
+        }
+      },
+      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
+      punctuation: /[,;.\[\]{}()]/
+    };
+  }
+  return r;
+}
+export {
+  a as __require
+};

package/dist/es/node_modules/refractor/lang/renpy.mjs

@@ -0,0 +1,30 @@
+var i, n;
+function a() {
+  if (n)
+    return i;
+  n = 1, i = e, e.displayName = "renpy", e.aliases = ["rpy"];
+  function e(t) {
+    t.languages.renpy = {
+      comment: {
+        pattern: /(^|[^\\])#.+/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\])*\2|(?:^#?(?:(?:[0-9a-fA-F]){3}|[0-9a-fA-F]{6})$)/m,
+        greedy: !0
+      },
+      function: /\b[a-z_]\w*(?=\()/i,
+      property: /\b(?:Update|UpdateVersion|action|activate_sound|adv_nvl_transition|after_load_transition|align|alpha|alt|anchor|antialias|area|auto|background|bar_invert|bar_resizing|bar_vertical|black_color|bold|bottom_bar|bottom_gutter|bottom_margin|bottom_padding|box_reverse|box_wrap|can_update|caret|child|color|crop|default_afm_enable|default_afm_time|default_fullscreen|default_text_cps|developer|directory_name|drag_handle|drag_joined|drag_name|drag_raise|draggable|dragged|drop_shadow|drop_shadow_color|droppable|dropped|easein|easeout|edgescroll|end_game_transition|end_splash_transition|enter_replay_transition|enter_sound|enter_transition|enter_yesno_transition|executable_name|exit_replay_transition|exit_sound|exit_transition|exit_yesno_transition|fadein|fadeout|first_indent|first_spacing|fit_first|focus|focus_mask|font|foreground|game_main_transition|get_installed_packages|google_play_key|google_play_salt|ground|has_music|has_sound|has_voice|height|help|hinting|hover|hover_background|hover_color|hover_sound|hovered|hyperlink_functions|idle|idle_color|image_style|include_update|insensitive|insensitive_background|insensitive_color|inside|intra_transition|italic|justify|kerning|keyboard_focus|language|layer_clipping|layers|layout|left_bar|left_gutter|left_margin|left_padding|length|line_leading|line_overlap_split|line_spacing|linear|main_game_transition|main_menu_music|maximum|min_width|minimum|minwidth|modal|mouse|mousewheel|name|narrator_menu|newline_indent|nvl_adv_transition|offset|order_reverse|outlines|overlay_functions|pos|position|prefix|radius|range|rest_indent|right_bar|right_gutter|right_margin|right_padding|rotate|rotate_pad|ruby_style|sample_sound|save_directory|say_attribute_transition|screen_height|screen_width|scrollbars|selected_hover|selected_hover_color|selected_idle|selected_idle_color|selected_insensitive|show_side_image|show_two_window|side_spacing|side_xpos|side_ypos|size|size_group|slow_cps|slow_cps_multiplier|spacing|strikethrough|subpixel|text_align|text_style|text_xpos|text_y_fudge|text_ypos|thumb|thumb_offset|thumb_shadow|thumbnail_height|thumbnail_width|time|top_bar|top_gutter|top_margin|top_padding|translations|underline|unscrollable|update|value|version|version_name|version_tuple|vertical|width|window_hide_transition|window_icon|window_left_padding|window_show_transition|window_title|windows_icon|xadjustment|xalign|xanchor|xanchoraround|xaround|xcenter|xfill|xinitial|xmargin|xmaximum|xminimum|xoffset|xofsset|xpadding|xpos|xsize|xzoom|yadjustment|yalign|yanchor|yanchoraround|yaround|ycenter|yfill|yinitial|ymargin|ymaximum|yminimum|yoffset|ypadding|ypos|ysize|ysizexysize|yzoom|zoom|zorder)\b/,
+      tag: /\b(?:bar|block|button|buttoscreenn|drag|draggroup|fixed|frame|grid|[hv]box|hotbar|hotspot|image|imagebutton|imagemap|input|key|label|menu|mm_menu_frame|mousearea|nvl|parallel|screen|self|side|tag|text|textbutton|timer|vbar|viewport|window)\b|\$/,
+      keyword: /\b(?:None|add|adjustment|alignaround|allow|angle|animation|around|as|assert|behind|box_layout|break|build|cache|call|center|changed|child_size|choice|circles|class|clear|clicked|clipping|clockwise|config|contains|continue|corner1|corner2|counterclockwise|def|default|define|del|delay|disabled|disabled_text|dissolve|elif|else|event|except|exclude|exec|expression|fade|finally|for|from|function|global|gm_root|has|hide|id|if|import|in|init|is|jump|knot|lambda|left|less_rounded|mm_root|movie|music|null|on|onlayer|pass|pause|persistent|play|print|python|queue|raise|random|renpy|repeat|return|right|rounded_window|scene|scope|set|show|slow|slow_abortable|slow_done|sound|stop|store|style|style_group|substitute|suffix|theme|transform|transform_anchor|transpose|try|ui|unhovered|updater|use|voice|while|widget|widget_hover|widget_selected|widget_text|yield)\b/,
+      boolean: /\b(?:[Ff]alse|[Tt]rue)\b/,
+      number: /(?:\b(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?)|\B\.\d+)(?:e[+-]?\d+)?j?/i,
+      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:and|at|not|or|with)\b/,
+      punctuation: /[{}[\];(),.:]/
+    }, t.languages.rpy = t.languages.renpy;
+  }
+  return i;
+}
+export {
+  a as __require
+};