@glodon-aiot/react-components 3.3.0-beta.17 → 3.3.0-beta.19

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

@@ -1,62 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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
-};