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

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

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

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

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

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

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

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

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