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

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

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

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

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

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

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

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

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

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

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

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