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

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

@@ -1,47 +0,0 @@
-var t, _;
-function s() {
-  if (_)
-    return t;
-  _ = 1, t = e, e.displayName = "psl", e.aliases = [];
-  function e(n) {
-    n.languages.psl = {
-      comment: {
-        pattern: /#.*/,
-        greedy: !0
-      },
-      string: {
-        pattern: /"(?:\\.|[^\\"])*"/,
-        greedy: !0,
-        inside: {
-          symbol: /\\[ntrbA-Z"\\]/
-        }
-      },
-      "heredoc-string": {
-        pattern: /<<<([a-zA-Z_]\w*)[\r\n](?:.*[\r\n])*?\1\b/,
-        alias: "string",
-        greedy: !0
-      },
-      keyword: /\b(?:__multi|__single|case|default|do|else|elsif|exit|export|for|foreach|function|if|last|line|local|next|requires|return|switch|until|while|word)\b/,
-      constant: /\b(?:ALARM|CHART_ADD_GRAPH|CHART_DELETE_GRAPH|CHART_DESTROY|CHART_LOAD|CHART_PRINT|EOF|OFFLINE|OK|PSL_PROF_LOG|R_CHECK_HORIZ|R_CHECK_VERT|R_CLICKER|R_COLUMN|R_FRAME|R_ICON|R_LABEL|R_LABEL_CENTER|R_LIST_MULTIPLE|R_LIST_MULTIPLE_ND|R_LIST_SINGLE|R_LIST_SINGLE_ND|R_MENU|R_POPUP|R_POPUP_SCROLLED|R_RADIO_HORIZ|R_RADIO_VERT|R_ROW|R_SCALE_HORIZ|R_SCALE_VERT|R_SEP_HORIZ|R_SEP_VERT|R_SPINNER|R_TEXT_FIELD|R_TEXT_FIELD_LABEL|R_TOGGLE|TRIM_LEADING|TRIM_LEADING_AND_TRAILING|TRIM_REDUNDANT|TRIM_TRAILING|VOID|WARN)\b/,
-      boolean: /\b(?:FALSE|False|NO|No|TRUE|True|YES|Yes|false|no|true|yes)\b/,
-      variable: /\b(?:PslDebug|errno|exit_status)\b/,
-      builtin: {
-        pattern: /\b(?:PslExecute|PslFunctionCall|PslFunctionExists|PslSetOptions|_snmp_debug|acos|add_diary|annotate|annotate_get|ascii_to_ebcdic|asctime|asin|atan|atexit|batch_set|blackout|cat|ceil|chan_exists|change_state|close|code_cvt|cond_signal|cond_wait|console_type|convert_base|convert_date|convert_locale_date|cos|cosh|create|date|dcget_text|destroy|destroy_lock|dget_text|difference|dump_hist|ebcdic_to_ascii|encrypt|event_archive|event_catalog_get|event_check|event_query|event_range_manage|event_range_query|event_report|event_schedule|event_trigger|event_trigger2|execute|exists|exp|fabs|file|floor|fmod|fopen|fseek|ftell|full_discovery|get|get_chan_info|get_ranges|get_text|get_vars|getenv|gethostinfo|getpid|getpname|grep|history|history_get_retention|in_transition|index|int|internal|intersection|is_var|isnumber|join|kill|length|lines|lock|lock_info|log|log10|loge|matchline|msg_check|msg_get_format|msg_get_severity|msg_printf|msg_sprintf|ntharg|nthargf|nthline|nthlinef|num_bytes|num_consoles|pconfig|popen|poplines|pow|print|printf|proc_exists|process|random|read|readln|refresh_parameters|remote_check|remote_close|remote_event_query|remote_event_trigger|remote_file_send|remote_open|remove|replace|rindex|sec_check_priv|sec_store_get|sec_store_set|set|set_alarm_ranges|set_locale|share|sin|sinh|sleep|snmp_agent_config|snmp_agent_start|snmp_agent_stop|snmp_close|snmp_config|snmp_get|snmp_get_next|snmp_h_get|snmp_h_get_next|snmp_h_set|snmp_open|snmp_set|snmp_trap_ignore|snmp_trap_listen|snmp_trap_raise_std_trap|snmp_trap_receive|snmp_trap_register_im|snmp_trap_send|snmp_walk|sopen|sort|splitline|sprintf|sqrt|srandom|str_repeat|strcasecmp|subset|substr|system|tail|tan|tanh|text_domain|time|tmpnam|tolower|toupper|trace_psl_process|trim|union|unique|unlock|unset|va_arg|va_start|write)\b/,
-        alias: "builtin-function"
-      },
-      "foreach-variable": {
-        pattern: /(\bforeach\s+(?:(?:\w+\b|"(?:\\.|[^\\"])*")\s+){0,2})[_a-zA-Z]\w*(?=\s*\()/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      function: /\b[_a-z]\w*\b(?=\s*\()/i,
-      number: /\b(?:0x[0-9a-f]+|\d+(?:\.\d+)?)\b/i,
-      operator: /--|\+\+|&&=?|\|\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\.|[:?]/,
-      punctuation: /[(){}\[\];,]/
-    };
-  }
-  return t;
-}
-export {
-  s as __require
-};

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

@@ -1,173 +0,0 @@
-var r, l;
-function g() {
-  if (l)
-    return r;
-  l = 1, r = a, a.displayName = "pug", a.aliases = [];
-  function a(u) {
-    (function(e) {
-      e.languages.pug = {
-        // Multiline stuff should appear before the rest
-        // This handles both single-line and multi-line comments
-        comment: {
-          pattern: /(^([\t ]*))\/\/.*(?:(?:\r?\n|\r)\2[\t ].+)*/m,
-          lookbehind: !0
-        },
-        // All the tag-related part is in lookbehind
-        // so that it can be highlighted by the "tag" pattern
-        "multiline-script": {
-          pattern: /(^([\t ]*)script\b.*\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-          lookbehind: !0,
-          inside: e.languages.javascript
-        },
-        // See at the end of the file for known filters
-        filter: {
-          pattern: /(^([\t ]*)):.+(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "variable"
-            },
-            text: /\S[\s\S]*/
-          }
-        },
-        "multiline-plain-text": {
-          pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-          lookbehind: !0
-        },
-        markup: {
-          pattern: /(^[\t ]*)<.+/m,
-          lookbehind: !0,
-          inside: e.languages.markup
-        },
-        doctype: {
-          pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
-          lookbehind: !0
-        },
-        // This handle all conditional and loop keywords
-        "flow-control": {
-          pattern: /(^[\t ]*)(?:case|default|each|else|if|unless|when|while)\b(?: .+)?/m,
-          lookbehind: !0,
-          inside: {
-            each: {
-              pattern: /^each .+? in\b/,
-              inside: {
-                keyword: /\b(?:each|in)\b/,
-                punctuation: /,/
-              }
-            },
-            branch: {
-              pattern: /^(?:case|default|else|if|unless|when|while)\b/,
-              alias: "keyword"
-            },
-            rest: e.languages.javascript
-          }
-        },
-        keyword: {
-          pattern: /(^[\t ]*)(?:append|block|extends|include|prepend)\b.+/m,
-          lookbehind: !0
-        },
-        mixin: [
-          // Declaration
-          {
-            pattern: /(^[\t ]*)mixin .+/m,
-            lookbehind: !0,
-            inside: {
-              keyword: /^mixin/,
-              function: /\w+(?=\s*\(|\s*$)/,
-              punctuation: /[(),.]/
-            }
-          },
-          // Usage
-          {
-            pattern: /(^[\t ]*)\+.+/m,
-            lookbehind: !0,
-            inside: {
-              name: {
-                pattern: /^\+\w+/,
-                alias: "function"
-              },
-              rest: e.languages.javascript
-            }
-          }
-        ],
-        script: {
-          pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]).+/m,
-          lookbehind: !0,
-          inside: e.languages.javascript
-        },
-        "plain-text": {
-          pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]).+/m,
-          lookbehind: !0
-        },
-        tag: {
-          pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
-          lookbehind: !0,
-          inside: {
-            attributes: [{
-              pattern: /&[^(]+\([^)]+\)/,
-              inside: e.languages.javascript
-            }, {
-              pattern: /\([^)]+\)/,
-              inside: {
-                "attr-value": {
-                  pattern: /(=\s*(?!\s))(?:\{[^}]*\}|[^,)\r\n]+)/,
-                  lookbehind: !0,
-                  inside: e.languages.javascript
-                },
-                "attr-name": /[\w-]+(?=\s*!?=|\s*[,)])/,
-                punctuation: /[!=(),]+/
-              }
-            }],
-            punctuation: /:/,
-            "attr-id": /#[\w\-]+/,
-            "attr-class": /\.[\w\-]+/
-          }
-        },
-        code: [{
-          pattern: /(^[\t ]*(?:-|!?=)).+/m,
-          lookbehind: !0,
-          inside: e.languages.javascript
-        }],
-        punctuation: /[.\-!=|]+/
-      };
-      for (var p = /(^([\t ]*)):<filter_name>(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/.source, i = [{
-        filter: "atpl",
-        language: "twig"
-      }, {
-        filter: "coffee",
-        language: "coffeescript"
-      }, "ejs", "handlebars", "less", "livescript", "markdown", {
-        filter: "sass",
-        language: "scss"
-      }, "stylus"], s = {}, n = 0, o = i.length; n < o; n++) {
-        var t = i[n];
-        t = typeof t == "string" ? {
-          filter: t,
-          language: t
-        } : t, e.languages[t.language] && (s["filter-" + t.filter] = {
-          pattern: RegExp(p.replace("<filter_name>", function() {
-            return t.filter;
-          }), "m"),
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "variable"
-            },
-            text: {
-              pattern: /\S[\s\S]*/,
-              alias: [t.language, "language-" + t.language],
-              inside: e.languages[t.language]
-            }
-          }
-        });
-      }
-      e.languages.insertBefore("pug", "filter", s);
-    })(u);
-  }
-  return r;
-}
-export {
-  g as __require
-};

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

@@ -1,140 +0,0 @@
-var n, a;
-function u() {
-  if (a)
-    return n;
-  a = 1, n = t, t.displayName = "puppet", t.aliases = [];
-  function t(i) {
-    (function(e) {
-      e.languages.puppet = {
-        heredoc: [
-          // Matches the content of a quoted heredoc string (subject to interpolation)
-          {
-            pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-            lookbehind: !0,
-            alias: "string",
-            inside: {
-              // Matches the end tag
-              punctuation: /(?=\S).*\S(?= *$)/
-              // See interpolation below
-            }
-          },
-          // Matches the content of an unquoted heredoc string (no interpolation)
-          {
-            pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
-            lookbehind: !0,
-            greedy: !0,
-            alias: "string",
-            inside: {
-              // Matches the end tag
-              punctuation: /(?=\S).*\S(?= *$)/
-            }
-          },
-          // Matches the start tag of heredoc strings
-          {
-            pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
-            alias: "string",
-            inside: {
-              punctuation: {
-                pattern: /(\().+?(?=\))/,
-                lookbehind: !0
-              }
-            }
-          }
-        ],
-        "multiline-comment": {
-          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "comment"
-        },
-        regex: {
-          // Must be prefixed with the keyword "node" or a non-word char
-          pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
-          lookbehind: !0,
-          greedy: !0,
-          inside: {
-            // Extended regexes must have the x flag. They can contain single-line comments.
-            "extended-regex": {
-              pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
-              inside: {
-                comment: /#.*/
-              }
-            }
-          }
-        },
-        comment: {
-          pattern: /(^|[^\\])#.*/,
-          lookbehind: !0,
-          greedy: !0
-        },
-        string: {
-          // Allow for one nested level of double quotes inside interpolation
-          pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
-          greedy: !0,
-          inside: {
-            "double-quoted": {
-              pattern: /^"[\s\S]*"$/,
-              inside: {
-                // See interpolation below
-              }
-            }
-          }
-        },
-        variable: {
-          pattern: /\$(?:::)?\w+(?:::\w+)*/,
-          inside: {
-            punctuation: /::/
-          }
-        },
-        "attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
-        function: [{
-          pattern: /(\.)(?!\d)\w+/,
-          lookbehind: !0
-        }, /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/],
-        number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
-        boolean: /\b(?:false|true)\b/,
-        // Includes words reserved for future use
-        keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
-        datatype: {
-          pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
-          alias: "symbol"
-        },
-        operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
-        punctuation: /[\[\]{}().,;]|:+/
-      };
-      var r = [{
-        // Allow for one nested level of braces inside interpolation
-        pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
-        lookbehind: !0,
-        inside: {
-          "short-variable": {
-            // Negative look-ahead prevent wrong highlighting of functions
-            pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
-            lookbehind: !0,
-            alias: "variable",
-            inside: {
-              punctuation: /::/
-            }
-          },
-          delimiter: {
-            pattern: /^\$/,
-            alias: "variable"
-          },
-          rest: e.languages.puppet
-        }
-      }, {
-        pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
-        lookbehind: !0,
-        alias: "variable",
-        inside: {
-          punctuation: /::/
-        }
-      }];
-      e.languages.puppet.heredoc[0].inside.interpolation = r, e.languages.puppet.string.inside["double-quoted"].inside.interpolation = r;
-    })(i);
-  }
-  return n;
-}
-export {
-  u as __require
-};

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

@@ -1,72 +0,0 @@
-var n, p;
-function c() {
-  if (p)
-    return n;
-  p = 1, n = a, a.displayName = "pure", a.aliases = [];
-  function a(l) {
-    (function(e) {
-      e.languages.pure = {
-        comment: [{
-          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-          lookbehind: !0
-        }, {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: !0
-        }, /#!.+/],
-        "inline-lang": {
-          pattern: /%<[\s\S]+?%>/,
-          greedy: !0,
-          inside: {
-            lang: {
-              pattern: /(^%< *)-\*-.+?-\*-/,
-              lookbehind: !0,
-              alias: "comment"
-            },
-            delimiter: {
-              pattern: /^%<.*|%>$/,
-              alias: "punctuation"
-            }
-          }
-        },
-        string: {
-          pattern: /"(?:\\.|[^"\\\r\n])*"/,
-          greedy: !0
-        },
-        number: {
-          // The look-behind prevents wrong highlighting of the .. operator
-          pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
-          lookbehind: !0
-        },
-        keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
-        function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
-        special: {
-          pattern: /\b__[a-z]+__\b/i,
-          alias: "builtin"
-        },
-        // Any combination of operator chars can be an operator
-        // eslint-disable-next-line no-misleading-character-class
-        operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
-        // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
-        punctuation: /[(){}\[\];,|]/
-      };
-      var o = ["c", {
-        lang: "c++",
-        alias: "cpp"
-      }, "fortran"], s = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
-      o.forEach(function(t) {
-        var r = t;
-        if (typeof t != "string" && (r = t.alias, t = t.lang), e.languages[r]) {
-          var i = {};
-          i["inline-lang-" + r] = {
-            pattern: RegExp(s.replace("<lang>", t.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")), "i"),
-            inside: e.util.clone(e.languages.pure["inline-lang"].inside)
-          }, i["inline-lang-" + r].inside.rest = e.util.clone(e.languages[r]), e.languages.insertBefore("pure", "inline-lang", i);
-        }
-      }), e.languages.c && (e.languages.pure["inline-lang"].inside.rest = e.util.clone(e.languages.c));
-    })(l);
-  }
-  return n;
-}
-export {
-  c as __require
-};

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

@@ -1,63 +0,0 @@
-var a, d;
-function n() {
-  if (d)
-    return a;
-  d = 1, a = r, r.displayName = "purebasic", r.aliases = [];
-  function r(e) {
-    e.languages.purebasic = e.languages.extend("clike", {
-      comment: /;.*/,
-      keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
-      function: /\b\w+(?:\.\w+)?\s*(?=\()/,
-      number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
-      operator: /(?:@\*?|\?|\*)\w+|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
-    }), e.languages.insertBefore("purebasic", "keyword", {
-      tag: /#\w+\$?/,
-      asm: {
-        pattern: /(^[\t ]*)!.*/m,
-        lookbehind: !0,
-        alias: "tag",
-        inside: {
-          comment: /;.*/,
-          string: {
-            pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-            greedy: !0
-          },
-          // Anonymous label references, i.e.: jmp @b
-          "label-reference-anonymous": {
-            pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
-            lookbehind: !0,
-            alias: "fasm-label"
-          },
-          // Named label reference, i.e.: jne label1
-          "label-reference-addressed": {
-            pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
-            lookbehind: !0,
-            alias: "fasm-label"
-          },
-          keyword: [/\b(?:extern|global)\b[^;\r\n]*/i, /\b(?:CPU|DEFAULT|FLOAT)\b.*/],
-          function: {
-            pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
-            lookbehind: !0
-          },
-          "function-inline": {
-            pattern: /(:\s*)[\da-z]+(?=\s)/i,
-            lookbehind: !0,
-            alias: "function"
-          },
-          label: {
-            pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
-            lookbehind: !0,
-            alias: "fasm-label"
-          },
-          register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
-          number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
-          operator: /[\[\]*+\-/%<>=&|$!,.:]/
-        }
-      }
-    }), delete e.languages.purebasic["class-name"], delete e.languages.purebasic.boolean, e.languages.pbfasm = e.languages.purebasic;
-  }
-  return a;
-}
-export {
-  n as __require
-};

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

@@ -1,41 +0,0 @@
-import { __require as d } from "./haskell.mjs";
-var e, a;
-function b() {
-  if (a)
-    return e;
-  a = 1;
-  var r = d();
-  e = f, f.displayName = "purescript", f.aliases = ["purs"];
-  function f(u) {
-    u.register(r), u.languages.purescript = u.languages.extend("haskell", {
-      keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
-      "import-statement": {
-        // The imported or hidden names are not included in this import
-        // statement. This is because we want to highlight those exactly like
-        // we do for the names in the program.
-        pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
-        lookbehind: !0,
-        inside: {
-          keyword: /\b(?:as|hiding|import)\b/,
-          punctuation: /\./
-        }
-      },
-      // These are builtin functions only. Constructors are highlighted later as a constant.
-      builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
-      operator: [
-        // Infix operators
-        u.languages.haskell.operator[0],
-        // ASCII operators
-        u.languages.haskell.operator[2],
-        // All UTF16 Unicode operator symbols
-        // This regex is equivalent to /(?=[\x80-\uFFFF])[\p{gc=Math_Symbol}\p{gc=Currency_Symbol}\p{Modifier_Symbol}\p{Other_Symbol}]/u
-        // See https://github.com/PrismJS/prism/issues/3006 for more details.
-        /[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
-      ]
-    }), u.languages.purs = u.languages.purescript;
-  }
-  return e;
-}
-export {
-  b as __require
-};

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

@@ -1,73 +0,0 @@
-var n, r;
-function a() {
-  if (r)
-    return n;
-  r = 1, n = t, t.displayName = "python", t.aliases = ["py"];
-  function t(e) {
-    e.languages.python = {
-      comment: {
-        pattern: /(^|[^\\])#.*/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      "string-interpolation": {
-        pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
-        greedy: !0,
-        inside: {
-          interpolation: {
-            // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-            pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
-            lookbehind: !0,
-            inside: {
-              "format-spec": {
-                pattern: /(:)[^:(){}]+(?=\}$)/,
-                lookbehind: !0
-              },
-              "conversion-option": {
-                pattern: /![sra](?=[:}]$)/,
-                alias: "punctuation"
-              },
-              rest: null
-            }
-          },
-          string: /[\s\S]+/
-        }
-      },
-      "triple-quoted-string": {
-        pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
-        greedy: !0,
-        alias: "string"
-      },
-      string: {
-        pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-        greedy: !0
-      },
-      function: {
-        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-        lookbehind: !0
-      },
-      "class-name": {
-        pattern: /(\bclass\s+)\w+/i,
-        lookbehind: !0
-      },
-      decorator: {
-        pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
-        lookbehind: !0,
-        alias: ["annotation", "punctuation"],
-        inside: {
-          punctuation: /\./
-        }
-      },
-      keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
-      builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
-      boolean: /\b(?:False|None|True)\b/,
-      number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
-      operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-      punctuation: /[{}[\];(),.:]/
-    }, e.languages.python["string-interpolation"].inside.interpolation.inside.rest = e.languages.python, e.languages.py = e.languages.python;
-  }
-  return n;
-}
-export {
-  a as __require
-};