@glodon-aiot/react-components 3.3.0-beta.15 → 3.3.0-beta.18

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

@@ -0,0 +1,48 @@
+import { __require as u } from "./markup-templating.mjs";
+var r, n;
+function d() {
+  if (n)
+    return r;
+  n = 1;
+  var i = u();
+  r = a, a.displayName = "twig", a.aliases = [];
+  function a(e) {
+    e.register(i), e.languages.twig = {
+      comment: /^\{#[\s\S]*?#\}$/,
+      "tag-name": {
+        pattern: /(^\{%-?\s*)\w+/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      delimiter: {
+        pattern: /^\{[{%]-?|-?[%}]\}$/,
+        alias: "punctuation"
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        inside: {
+          punctuation: /^['"]|['"]$/
+        }
+      },
+      keyword: /\b(?:even|if|odd)\b/,
+      boolean: /\b(?:false|null|true)\b/,
+      number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+      operator: [{
+        pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+        lookbehind: !0
+      }, /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/],
+      punctuation: /[()\[\]{}:.,]/
+    }, e.hooks.add("before-tokenize", function(t) {
+      if (t.language === "twig") {
+        var o = /\{(?:#[\s\S]*?#|%[\s\S]*?%|\{[\s\S]*?\})\}/g;
+        e.languages["markup-templating"].buildPlaceholders(t, "twig", o);
+      }
+    }), e.hooks.add("after-tokenize", function(t) {
+      e.languages["markup-templating"].tokenizePlaceholders(t, "twig");
+    });
+  }
+  return r;
+}
+export {
+  d as __require
+};

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

@@ -0,0 +1,57 @@
+var n, s;
+function i() {
+  if (s)
+    return n;
+  s = 1, n = t, t.displayName = "typescript", t.aliases = ["ts"];
+  function t(r) {
+    (function(e) {
+      e.languages.typescript = e.languages.extend("javascript", {
+        "class-name": {
+          pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: null
+          // see below
+        },
+        builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+      }), e.languages.typescript.keyword.push(
+        /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+        // keywords that have to be followed by an identifier
+        /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+        // This is for `import type *, {}`
+        /\btype\b(?=\s*(?:[\{*]|$))/
+      ), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
+      var a = e.languages.extend("typescript", {});
+      delete a["class-name"], e.languages.typescript["class-name"].inside = a, e.languages.insertBefore("typescript", "function", {
+        decorator: {
+          pattern: /@[$\w\xA0-\uFFFF]+/,
+          inside: {
+            at: {
+              pattern: /^@/,
+              alias: "operator"
+            },
+            function: /^[\s\S]+/
+          }
+        },
+        "generic-function": {
+          // e.g. foo<T extends "bar" | "baz">( ...
+          pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+          greedy: !0,
+          inside: {
+            function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+            generic: {
+              pattern: /<[\s\S]+/,
+              // everything after the first <
+              alias: "class-name",
+              inside: a
+            }
+          }
+        }
+      }), e.languages.ts = e.languages.typescript;
+    })(r);
+  }
+  return n;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,81 @@
+var e, E;
+function o() {
+  if (E)
+    return e;
+  E = 1, e = t, t.displayName = "typoscript", t.aliases = ["tsconfig"];
+  function t(i) {
+    (function(r) {
+      var n = /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
+      r.languages.typoscript = {
+        comment: [{
+          // multiline comments /* */
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0
+        }, {
+          // double-slash comments - ignored when backslashes or colon is found in front
+          // also ignored whenever directly after an equal-sign, because it would probably be an url without protocol
+          pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }, {
+          // hash comments - ignored when leading quote is found for hex colors in strings
+          pattern: /(^|[^"'])#.*/,
+          lookbehind: !0,
+          greedy: !0
+        }],
+        function: [{
+          // old include style
+          pattern: /<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
+          inside: {
+            string: {
+              pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+              inside: {
+                keyword: n
+              }
+            },
+            keyword: {
+              pattern: /INCLUDE_TYPOSCRIPT/
+            }
+          }
+        }, {
+          // new include style
+          pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
+          inside: {
+            string: /"[^"\r\n]*"|'[^'\r\n]*'/
+          }
+        }],
+        string: {
+          pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
+          lookbehind: !0,
+          inside: {
+            function: /\{\$.*\}/,
+            // constants include
+            keyword: n,
+            number: /^\d+$/,
+            punctuation: /[,|:]/
+          }
+        },
+        keyword: n,
+        number: {
+          // special highlighting for indexes of arrays in tags
+          pattern: /\b\d+\s*[.{=]/,
+          inside: {
+            operator: /[.{=]/
+          }
+        },
+        tag: {
+          pattern: /\.?[-\w\\]+\.?/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /[{}[\];(),.:|]/,
+        operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
+      }, r.languages.tsconfig = r.languages.typoscript;
+    })(i);
+  }
+  return e;
+}
+export {
+  o as __require
+};

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

@@ -0,0 +1,50 @@
+var r, a;
+function n() {
+  if (a)
+    return r;
+  a = 1, r = t, t.displayName = "unrealscript", t.aliases = ["uc", "uscript"];
+  function t(e) {
+    e.languages.unrealscript = {
+      comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      category: {
+        pattern: /(\b(?:(?:autoexpand|hide|show)categories|var)\s*\()[^()]+(?=\))/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      },
+      metadata: {
+        pattern: /(\w\s*)<\s*\w+\s*=[^<>|=\r\n]+(?:\|\s*\w+\s*=[^<>|=\r\n]+)*>/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          property: /\b\w+(?=\s*=)/,
+          operator: /=/,
+          punctuation: /[<>|]/
+        }
+      },
+      macro: {
+        pattern: /`\w+/,
+        alias: "property"
+      },
+      "class-name": {
+        pattern: /(\b(?:class|enum|extends|interface|state(?:\(\))?|struct|within)\s+)\w+/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:abstract|actor|array|auto|autoexpandcategories|bool|break|byte|case|class|classgroup|client|coerce|collapsecategories|config|const|continue|default|defaultproperties|delegate|dependson|deprecated|do|dontcollapsecategories|editconst|editinlinenew|else|enum|event|exec|export|extends|final|float|for|forcescriptorder|foreach|function|goto|guid|hidecategories|hidedropdown|if|ignores|implements|inherits|input|int|interface|iterator|latent|local|material|name|native|nativereplication|noexport|nontransient|noteditinlinenew|notplaceable|operator|optional|out|pawn|perobjectconfig|perobjectlocalized|placeable|postoperator|preoperator|private|protected|reliable|replication|return|server|showcategories|simulated|singular|state|static|string|struct|structdefault|structdefaultproperties|switch|texture|transient|travel|unreliable|until|var|vector|while|within)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      // https://docs.unrealengine.com/udk/Three/UnrealScriptExpressions.html
+      operator: />>|<<|--|\+\+|\*\*|[-+*/~!=<>$@]=?|&&?|\|\|?|\^\^?|[?:%]|\b(?:ClockwiseFrom|Cross|Dot)\b/,
+      punctuation: /[()[\]{};,.]/
+    }, e.languages.uc = e.languages.uscript = e.languages.unrealscript;
+  }
+  return r;
+}
+export {
+  n as __require
+};

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

@@ -0,0 +1,57 @@
+var t, r;
+function s() {
+  if (r)
+    return t;
+  r = 1, t = e, e.displayName = "uorazor", e.aliases = [];
+  function e(a) {
+    a.languages.uorazor = {
+      "comment-hash": {
+        pattern: /#.*/,
+        alias: "comment",
+        greedy: !0
+      },
+      "comment-slash": {
+        pattern: /\/\/.*/,
+        alias: "comment",
+        greedy: !0
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        inside: {
+          punctuation: /^['"]|['"]$/
+        },
+        greedy: !0
+      },
+      "source-layers": {
+        pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
+        alias: "function"
+      },
+      "source-commands": {
+        pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
+        alias: "function"
+      },
+      "tag-name": {
+        pattern: /(^\{%-?\s*)\w+/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      delimiter: {
+        pattern: /^\{[{%]-?|-?[%}]\}$/,
+        alias: "punctuation"
+      },
+      function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
+      keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
+      boolean: /\b(?:false|null|true)\b/,
+      number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+      operator: [{
+        pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+        lookbehind: !0
+      }, /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/],
+      punctuation: /[()\[\]{}:.,]/
+    };
+  }
+  return t;
+}
+export {
+  s as __require
+};

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

@@ -0,0 +1,92 @@
+var i, t;
+function a() {
+  if (t)
+    return i;
+  t = 1, i = e, e.displayName = "uri", e.aliases = ["url"];
+  function e(r) {
+    r.languages.uri = {
+      scheme: {
+        pattern: /^[a-z][a-z0-9+.-]*:/im,
+        greedy: !0,
+        inside: {
+          "scheme-delimiter": /:$/
+        }
+      },
+      fragment: {
+        pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
+        inside: {
+          "fragment-delimiter": /^#/
+        }
+      },
+      query: {
+        pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
+        inside: {
+          "query-delimiter": {
+            pattern: /^\?/,
+            greedy: !0
+          },
+          "pair-delimiter": /[&;]/,
+          pair: {
+            pattern: /^[^=][\s\S]*/,
+            inside: {
+              key: /^[^=]+/,
+              value: {
+                pattern: /(^=)[\s\S]+/,
+                lookbehind: !0
+              }
+            }
+          }
+        }
+      },
+      authority: {
+        pattern: RegExp(/^\/\//.source + // [ userinfo "@" ]
+        /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + // host
+        ("(?:" + // IP-literal
+        /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + // IPv4address or registered name
+        /[\w\-.~!$&'()*+,;=%]*/.source + ")") + // [ ":" port ]
+        /(?::\d*)?/.source, "m"),
+        inside: {
+          "authority-delimiter": /^\/\//,
+          "user-info-segment": {
+            pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
+            inside: {
+              "user-info-delimiter": /@$/,
+              "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
+            }
+          },
+          "port-segment": {
+            pattern: /:\d*$/,
+            inside: {
+              "port-delimiter": /^:/,
+              port: /^\d+/
+            }
+          },
+          host: {
+            pattern: /[\s\S]+/,
+            inside: {
+              "ip-literal": {
+                pattern: /^\[[\s\S]+\]$/,
+                inside: {
+                  "ip-literal-delimiter": /^\[|\]$/,
+                  "ipv-future": /^v[\s\S]+/,
+                  "ipv6-address": /^[\s\S]+/
+                }
+              },
+              "ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
+            }
+          }
+        }
+      },
+      path: {
+        pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
+        inside: {
+          "path-separator": /\//
+        }
+      }
+    }, r.languages.url = r.languages.uri;
+  }
+  return i;
+}
+export {
+  a as __require
+};

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

@@ -0,0 +1,85 @@
+var t, i;
+function o() {
+  if (i)
+    return t;
+  i = 1, t = n, n.displayName = "v", n.aliases = [];
+  function n(r) {
+    (function(e) {
+      var a = {
+        pattern: /[\s\S]+/,
+        inside: null
+      };
+      e.languages.v = e.languages.extend("clike", {
+        string: {
+          pattern: /r?(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          alias: "quoted-string",
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[^{}]*\}|\w+(?:\.\w+(?:\([^\(\)]*\))?|\[[^\[\]]+\])*)/,
+              lookbehind: !0,
+              inside: {
+                "interpolation-variable": {
+                  pattern: /^\$\w[\s\S]*$/,
+                  alias: "variable"
+                },
+                "interpolation-punctuation": {
+                  pattern: /^\$\{|\}$/,
+                  alias: "punctuation"
+                },
+                "interpolation-expression": a
+              }
+            }
+          }
+        },
+        "class-name": {
+          pattern: /(\b(?:enum|interface|struct|type)\s+)(?:C\.)?\w+/,
+          lookbehind: !0
+        },
+        keyword: /(?:\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\$(?:else|for|if)|#(?:flag|include))\b/,
+        number: /\b(?:0x[a-f\d]+(?:_[a-f\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?)\b/i,
+        operator: /~|\?|[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\.?/,
+        builtin: /\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\b/
+      }), a.inside = e.languages.v, e.languages.insertBefore("v", "string", {
+        char: {
+          pattern: /`(?:\\`|\\?[^`]{1,2})`/,
+          // using {1,2} instead of `u` flag for compatibility
+          alias: "rune"
+        }
+      }), e.languages.insertBefore("v", "operator", {
+        attribute: {
+          pattern: /(^[\t ]*)\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\]/m,
+          lookbehind: !0,
+          alias: "annotation",
+          inside: {
+            punctuation: /[\[\]]/,
+            keyword: /\w+/
+          }
+        },
+        generic: {
+          pattern: /<\w+>(?=\s*[\)\{])/,
+          inside: {
+            punctuation: /[<>]/,
+            "class-name": /\w+/
+          }
+        }
+      }), e.languages.insertBefore("v", "function", {
+        "generic-function": {
+          // e.g. foo<T>( ...
+          pattern: /\b\w+\s*<\w+>(?=\()/,
+          inside: {
+            function: /^\w+/,
+            generic: {
+              pattern: /<\w+>/,
+              inside: e.languages.v.generic.inside
+            }
+          }
+        }
+      });
+    })(r);
+  }
+  return t;
+}
+export {
+  o as __require
+};

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

@@ -0,0 +1,87 @@
+var a, n;
+function r() {
+  if (n)
+    return a;
+  n = 1, a = t, t.displayName = "vala", t.aliases = [];
+  function t(e) {
+    e.languages.vala = e.languages.extend("clike", {
+      // Classes copied from prism-csharp
+      "class-name": [{
+        // (Foo bar, Bar baz)
+        pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
+        inside: {
+          punctuation: /\./
+        }
+      }, {
+        // [Foo]
+        pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }, {
+        // class Foo : Bar
+        pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }, {
+        // class Foo
+        pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }],
+      keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
+      function: /\b\w+(?=\s*\()/,
+      number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
+      operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
+      punctuation: /[{}[\];(),.:]/,
+      constant: /\b[A-Z0-9_]+\b/
+    }), e.languages.insertBefore("vala", "string", {
+      "raw-string": {
+        pattern: /"""[\s\S]*?"""/,
+        greedy: !0,
+        alias: "string"
+      },
+      "template-string": {
+        pattern: /@"[\s\S]*?"/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
+            inside: {
+              delimiter: {
+                pattern: /^\$\(?|\)$/,
+                alias: "punctuation"
+              },
+              rest: e.languages.vala
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.insertBefore("vala", "keyword", {
+      regex: {
+        pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
+        greedy: !0,
+        inside: {
+          "regex-source": {
+            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^\//,
+          "regex-flags": /^[a-z]+$/
+        }
+      }
+    });
+  }
+  return a;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,34 @@
+import { __require as S } from "./basic.mjs";
+var R, O;
+function L() {
+  if (O)
+    return R;
+  O = 1;
+  var N = S();
+  R = E, E.displayName = "vbnet", E.aliases = [];
+  function E(T) {
+    T.register(N), T.languages.vbnet = T.languages.extend("basic", {
+      comment: [{
+        pattern: /(?:!|REM\b).+/i,
+        inside: {
+          keyword: /^REM/i
+        }
+      }, {
+        pattern: /(^|[^\\:])'.*/,
+        lookbehind: !0,
+        greedy: !0
+      }],
+      string: {
+        pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+      punctuation: /[,;:(){}]/
+    });
+  }
+  return R;
+}
+export {
+  L as __require
+};

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

@@ -0,0 +1,75 @@
+var a, i;
+function o() {
+  if (i)
+    return a;
+  i = 1, a = n, n.displayName = "velocity", n.aliases = [];
+  function n(r) {
+    (function(t) {
+      t.languages.velocity = t.languages.extend("markup", {});
+      var e = {
+        variable: {
+          pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
+          lookbehind: !0,
+          inside: {}
+          // See below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: !0
+        },
+        number: /\b\d+\b/,
+        boolean: /\b(?:false|true)\b/,
+        operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
+        punctuation: /[(){}[\]:,.]/
+      };
+      e.variable.inside = {
+        string: e.string,
+        function: {
+          pattern: /([^\w-])[a-z][\w-]*(?=\()/,
+          lookbehind: !0
+        },
+        number: e.number,
+        boolean: e.boolean,
+        punctuation: e.punctuation
+      }, t.languages.insertBefore("velocity", "comment", {
+        unparsed: {
+          pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            punctuation: /^#\[\[|\]\]#$/
+          }
+        },
+        "velocity-comment": [{
+          pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "comment"
+        }, {
+          pattern: /(^|[^\\])##.*/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "comment"
+        }],
+        directive: {
+          pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
+          lookbehind: !0,
+          inside: {
+            keyword: {
+              pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
+              inside: {
+                punctuation: /[{}]/
+              }
+            },
+            rest: e
+          }
+        },
+        variable: e.variable
+      }), t.languages.velocity.tag.inside["attr-value"].inside.rest = t.languages.velocity;
+    })(r);
+  }
+  return a;
+}
+export {
+  o as __require
+};