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

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

@@ -0,0 +1,301 @@
+import { __require as g } from "./markup-templating.mjs";
+var n, p;
+function h() {
+  if (p)
+    return n;
+  p = 1;
+  var c = g();
+  n = a, a.displayName = "php", a.aliases = [];
+  function a(i) {
+    i.register(c), function(e) {
+      var r = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, s = [{
+        pattern: /\b(?:false|true)\b/i,
+        alias: "boolean"
+      }, {
+        pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+        greedy: !0,
+        lookbehind: !0
+      }, {
+        pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+        greedy: !0,
+        lookbehind: !0
+      }, /\b(?:null)\b/i, /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/], l = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, o = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, u = /[{}\[\](),:;]/;
+      e.languages.php = {
+        delimiter: {
+          pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+          alias: "important"
+        },
+        comment: r,
+        variable: /\$+(?:\w+\b|(?=\{))/,
+        package: {
+          pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        "class-name-definition": {
+          pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        "function-definition": {
+          pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+          lookbehind: !0,
+          alias: "function"
+        },
+        keyword: [
+          {
+            pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+            alias: "type-casting",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+            alias: "type-hint",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string|void)\b/i,
+            alias: "return-type",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+            alias: "type-declaration",
+            greedy: !0
+          },
+          {
+            pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+            alias: "type-declaration",
+            greedy: !0,
+            lookbehind: !0
+          },
+          {
+            pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+            alias: "static-context",
+            greedy: !0
+          },
+          {
+            // yield from
+            pattern: /(\byield\s+)from\b/i,
+            lookbehind: !0
+          },
+          // `class` is always a keyword unlike other keywords
+          /\bclass\b/i,
+          {
+            // https://www.php.net/manual/en/reserved.keywords.php
+            //
+            // keywords cannot be preceded by "->"
+            // the complex lookbehind means `(?<!(?:->|::)\s*)`
+            pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+            lookbehind: !0
+          }
+        ],
+        "argument-name": {
+          pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i,
+          lookbehind: !0
+        },
+        "class-name": [{
+          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        }, {
+          pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        }, {
+          pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+          greedy: !0
+        }, {
+          pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-declaration",
+          greedy: !0
+        }, {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-declaration"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /\b[a-z_]\w*(?=\s*::)/i,
+          alias: "static-context",
+          greedy: !0
+        }, {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+          alias: ["class-name-fully-qualified", "static-context"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-hint",
+          greedy: !0,
+          lookbehind: !0
+        }, {
+          pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-hint"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }, {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+          alias: "return-type",
+          greedy: !0,
+          lookbehind: !0
+        }, {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          alias: ["class-name-fully-qualified", "return-type"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }],
+        constant: s,
+        function: {
+          pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        property: {
+          pattern: /(->\s*)\w+/,
+          lookbehind: !0
+        },
+        number: l,
+        operator: o,
+        punctuation: u
+      };
+      var d = {
+        pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+        lookbehind: !0,
+        inside: e.languages.php
+      }, b = [{
+        pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+        alias: "nowdoc-string",
+        greedy: !0,
+        inside: {
+          delimiter: {
+            pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+            alias: "symbol",
+            inside: {
+              punctuation: /^<<<'?|[';]$/
+            }
+          }
+        }
+      }, {
+        pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+        alias: "heredoc-string",
+        greedy: !0,
+        inside: {
+          delimiter: {
+            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+            alias: "symbol",
+            inside: {
+              punctuation: /^<<<"?|[";]$/
+            }
+          },
+          interpolation: d
+        }
+      }, {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+        alias: "backtick-quoted-string",
+        greedy: !0
+      }, {
+        pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+        alias: "single-quoted-string",
+        greedy: !0
+      }, {
+        pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+        alias: "double-quoted-string",
+        greedy: !0,
+        inside: {
+          interpolation: d
+        }
+      }];
+      e.languages.insertBefore("php", "variable", {
+        string: b,
+        attribute: {
+          pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+          greedy: !0,
+          inside: {
+            "attribute-content": {
+              pattern: /^(#\[)[\s\S]+(?=\]$)/,
+              lookbehind: !0,
+              // inside can appear subset of php
+              inside: {
+                comment: r,
+                string: b,
+                "attribute-class-name": [{
+                  pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                  alias: "class-name",
+                  greedy: !0,
+                  lookbehind: !0
+                }, {
+                  pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                  alias: ["class-name", "class-name-fully-qualified"],
+                  greedy: !0,
+                  lookbehind: !0,
+                  inside: {
+                    punctuation: /\\/
+                  }
+                }],
+                constant: s,
+                number: l,
+                operator: o,
+                punctuation: u
+              }
+            },
+            delimiter: {
+              pattern: /^#\[|\]$/,
+              alias: "punctuation"
+            }
+          }
+        }
+      }), e.hooks.add("before-tokenize", function(t) {
+        if (/<\?/.test(t.code)) {
+          var f = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+          e.languages["markup-templating"].buildPlaceholders(t, "php", f);
+        }
+      }), e.hooks.add("after-tokenize", function(t) {
+        e.languages["markup-templating"].tokenizePlaceholders(t, "php");
+      });
+    }(i);
+  }
+  return n;
+}
+export {
+  h as __require
+};

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

@@ -0,0 +1,34 @@
+import { __require as u } from "./php.mjs";
+import { __require as l } from "./javadoclike.mjs";
+var o, t;
+function s() {
+  if (t)
+    return o;
+  t = 1;
+  var n = u(), i = l();
+  o = r, r.displayName = "phpdoc", r.aliases = [];
+  function r(a) {
+    a.register(n), a.register(i), function(e) {
+      var p = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
+      e.languages.phpdoc = e.languages.extend("javadoclike", {
+        parameter: {
+          pattern: RegExp("(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + p + "\\s+)?)\\$\\w+"),
+          lookbehind: !0
+        }
+      }), e.languages.insertBefore("phpdoc", "keyword", {
+        "class-name": [{
+          pattern: RegExp("(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" + p),
+          lookbehind: !0,
+          inside: {
+            keyword: /\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
+            punctuation: /[|\\[\]()]/
+          }
+        }]
+      }), e.languages.javadoclike.addSupport("php", e.languages.phpdoc);
+    }(a);
+  }
+  return o;
+}
+export {
+  s as __require
+};

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

@@ -0,0 +1,30 @@
+import { __require as N } from "./sql.mjs";
+var T, I;
+function S() {
+  if (I)
+    return T;
+  I = 1;
+  var R = N();
+  T = A, A.displayName = "plsql", A.aliases = [];
+  function A(E) {
+    E.register(R), E.languages.plsql = E.languages.extend("sql", {
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|--.*/,
+        greedy: !0
+      },
+      // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-reserved-words-keywords.html
+      keyword: /\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
+      // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html#GUID-96A42F7C-7A71-4B90-8255-CA9C8BD9722E
+      operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
+    }), E.languages.insertBefore("plsql", "operator", {
+      label: {
+        pattern: /<<\s*\w+\s*>>/,
+        alias: "symbol"
+      }
+    });
+  }
+  return T;
+}
+export {
+  S as __require
+};

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

@@ -0,0 +1,44 @@
+var t, r;
+function a() {
+  if (r)
+    return t;
+  r = 1, t = n, n.displayName = "powerquery", n.aliases = [];
+  function n(e) {
+    e.languages.powerquery = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "quoted-identifier": {
+        pattern: /#"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: !0
+      },
+      string: {
+        pattern: /(?:#!)?"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: !0
+      },
+      constant: [/\bDay\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\b/, /\bTraceLevel\.(?:Critical|Error|Information|Verbose|Warning)\b/, /\bOccurrence\.(?:All|First|Last)\b/, /\bOrder\.(?:Ascending|Descending)\b/, /\bRoundingMode\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\b/, /\bMissingField\.(?:Error|Ignore|UseNull)\b/, /\bQuoteStyle\.(?:Csv|None)\b/, /\bJoinKind\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\b/, /\bGroupKind\.(?:Global|Local)\b/, /\bExtraValues\.(?:Error|Ignore|List)\b/, /\bJoinAlgorithm\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\b/, /\bJoinSide\.(?:Left|Right)\b/, /\bPrecision\.(?:Decimal|Double)\b/, /\bRelativePosition\.From(?:End|Start)\b/, /\bTextEncoding\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\b/, /\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\.Type\b/, /\bnull\b/],
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\b/,
+      function: {
+        pattern: /(^|[^#\w.])[a-z_][\w.]*(?=\s*\()/i,
+        lookbehind: !0
+      },
+      "data-type": {
+        pattern: /\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\b/,
+        alias: "class-name"
+      },
+      number: {
+        pattern: /\b0x[\da-f]+\b|(?:[+-]?(?:\b\d+\.)?\b\d+|[+-]\.\d+|(^|[^.])\B\.\d+)(?:e[+-]?\d+)?\b/i,
+        lookbehind: !0
+      },
+      operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
+      punctuation: /[,;\[\](){}]/
+    }, e.languages.pq = e.languages.powerquery, e.languages.mscript = e.languages.powerquery;
+  }
+  return t;
+}
+export {
+  a as __require
+};

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

@@ -0,0 +1,58 @@
+var i, t;
+function s() {
+  if (t)
+    return i;
+  t = 1, i = r, r.displayName = "powershell", r.aliases = [];
+  function r(n) {
+    (function(o) {
+      var e = o.languages.powershell = {
+        comment: [{
+          pattern: /(^|[^`])<#[\s\S]*?#>/,
+          lookbehind: !0
+        }, {
+          pattern: /(^|[^`])#.*/,
+          lookbehind: !0
+        }],
+        string: [{
+          pattern: /"(?:`[\s\S]|[^`"])*"/,
+          greedy: !0,
+          inside: null
+          // see below
+        }, {
+          pattern: /'(?:[^']|'')*'/,
+          greedy: !0
+        }],
+        // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+        // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+        namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+        boolean: /\$(?:false|true)\b/i,
+        variable: /\$\w+\b/,
+        // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+        // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+        // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+        function: [/\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i, /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i],
+        // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+        keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+        operator: {
+          pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+          lookbehind: !0
+        },
+        punctuation: /[|{}[\];(),.]/
+      };
+      e.string[0].inside = {
+        function: {
+          // Allow for one level of nesting
+          pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+          lookbehind: !0,
+          inside: e
+        },
+        boolean: e.boolean,
+        variable: e.variable
+      };
+    })(n);
+  }
+  return i;
+}
+export {
+  s as __require
+};

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

@@ -0,0 +1,25 @@
+var n, r;
+function a() {
+  if (r)
+    return n;
+  r = 1, n = e, e.displayName = "processing", e.aliases = [];
+  function e(s) {
+    s.languages.processing = s.languages.extend("clike", {
+      keyword: /\b(?:break|case|catch|class|continue|default|else|extends|final|for|if|implements|import|new|null|private|public|return|static|super|switch|this|try|void|while)\b/,
+      // Spaces are allowed between function name and parenthesis
+      function: /\b\w+(?=\s*\()/,
+      operator: /<[<=]?|>[>=]?|&&?|\|\|?|[%?]|[!=+\-*\/]=?/
+    }), s.languages.insertBefore("processing", "number", {
+      // Special case: XML is a type
+      constant: /\b(?!XML\b)[A-Z][A-Z\d_]+\b/,
+      type: {
+        pattern: /\b(?:boolean|byte|char|color|double|float|int|[A-Z]\w*)\b/,
+        alias: "class-name"
+      }
+    });
+  }
+  return n;
+}
+export {
+  a as __require
+};

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

@@ -0,0 +1,31 @@
+var e, o;
+function t() {
+  if (o)
+    return e;
+  o = 1, e = r, r.displayName = "prolog", r.aliases = [];
+  function r(n) {
+    n.languages.prolog = {
+      // Syntax depends on the implementation
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|%.*/,
+        greedy: !0
+      },
+      // Depending on the implementation, strings may allow escaped newlines and quote-escape
+      string: {
+        pattern: /(["'])(?:\1\1|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1(?!\1)/,
+        greedy: !0
+      },
+      builtin: /\b(?:fx|fy|xf[xy]?|yfx?)\b/,
+      // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?
+      function: /\b[a-z]\w*(?:(?=\()|\/\d+)/,
+      number: /\b\d+(?:\.\d*)?/,
+      // Custom operators are allowed
+      operator: /[:\\=><\-?*@\/;+^|!$.]+|\b(?:is|mod|not|xor)\b/,
+      punctuation: /[(){}\[\],]/
+    };
+  }
+  return e;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,74 @@
+var e, n;
+function l() {
+  if (n)
+    return e;
+  n = 1, e = t, t.displayName = "promql", t.aliases = [];
+  function t(r) {
+    (function(o) {
+      var i = ["sum", "min", "max", "avg", "group", "stddev", "stdvar", "count", "count_values", "bottomk", "topk", "quantile"], a = ["on", "ignoring", "group_right", "group_left", "by", "without"], u = ["offset"], s = i.concat(a, u);
+      o.languages.promql = {
+        comment: {
+          pattern: /(^[ \t]*)#.*/m,
+          lookbehind: !0
+        },
+        "vector-match": {
+          // Match the comma-separated label lists inside vector matching:
+          pattern: new RegExp("((?:" + a.join("|") + ")\\s*)\\([^)]*\\)"),
+          lookbehind: !0,
+          inside: {
+            "label-key": {
+              pattern: /\b[^,]+\b/,
+              alias: "attr-name"
+            },
+            punctuation: /[(),]/
+          }
+        },
+        "context-labels": {
+          pattern: /\{[^{}]*\}/,
+          inside: {
+            "label-key": {
+              pattern: /\b[a-z_]\w*(?=\s*(?:=|![=~]))/,
+              alias: "attr-name"
+            },
+            "label-value": {
+              pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+              greedy: !0,
+              alias: "attr-value"
+            },
+            punctuation: /\{|\}|=~?|![=~]|,/
+          }
+        },
+        "context-range": [{
+          pattern: /\[[\w\s:]+\]/,
+          // [1m]
+          inside: {
+            punctuation: /\[|\]|:/,
+            "range-duration": {
+              pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+              alias: "number"
+            }
+          }
+        }, {
+          pattern: /(\boffset\s+)\w+/,
+          // offset 1m
+          lookbehind: !0,
+          inside: {
+            "range-duration": {
+              pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+              alias: "number"
+            }
+          }
+        }],
+        keyword: new RegExp("\\b(?:" + s.join("|") + ")\\b", "i"),
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: /[-+]?(?:(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[-+]?\d+)?\b|\b(?:0x[0-9a-f]+|nan|inf)\b)/i,
+        operator: /[\^*/%+-]|==|!=|<=|<|>=|>|\b(?:and|or|unless)\b/i,
+        punctuation: /[{};()`,.[\]]/
+      };
+    })(r);
+  }
+  return e;
+}
+export {
+  l as __require
+};

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

@@ -0,0 +1,21 @@
+var e, t;
+function s() {
+  if (t)
+    return e;
+  t = 1, e = r, r.displayName = "properties", r.aliases = [];
+  function r(n) {
+    n.languages.properties = {
+      comment: /^[ \t]*[#!].*$/m,
+      "attr-value": {
+        pattern: /(^[ \t]*(?:\\(?:\r\n|[\s\S])|[^\\\s:=])+(?: *[=:] *(?! )| ))(?:\\(?:\r\n|[\s\S])|[^\\\r\n])+/m,
+        lookbehind: !0
+      },
+      "attr-name": /^[ \t]*(?:\\(?:\r\n|[\s\S])|[^\\\s:=])+(?= *[=:]| )/m,
+      punctuation: /[=:]/
+    };
+  }
+  return e;
+}
+export {
+  s as __require
+};

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

@@ -0,0 +1,47 @@
+var a, n;
+function r() {
+  if (n)
+    return a;
+  n = 1, a = e, e.displayName = "protobuf", e.aliases = [];
+  function e(o) {
+    (function(s) {
+      var t = /\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\b/;
+      s.languages.protobuf = s.languages.extend("clike", {
+        "class-name": [{
+          pattern: /(\b(?:enum|extend|message|service)\s+)[A-Za-z_]\w*(?=\s*\{)/,
+          lookbehind: !0
+        }, {
+          pattern: /(\b(?:rpc\s+\w+|returns)\s*\(\s*(?:stream\s+)?)\.?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?=\s*\))/,
+          lookbehind: !0
+        }],
+        keyword: /\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\s+\w)|service|stream|syntax|to)\b(?!\s*=\s*\d)/,
+        function: /\b[a-z_]\w*(?=\s*\()/i
+      }), s.languages.insertBefore("protobuf", "operator", {
+        map: {
+          pattern: /\bmap<\s*[\w.]+\s*,\s*[\w.]+\s*>(?=\s+[a-z_]\w*\s*[=;])/i,
+          alias: "class-name",
+          inside: {
+            punctuation: /[<>.,]/,
+            builtin: t
+          }
+        },
+        builtin: t,
+        "positional-class-name": {
+          pattern: /(?:\b|\B\.)[a-z_]\w*(?:\.[a-z_]\w*)*(?=\s+[a-z_]\w*\s*[=;])/i,
+          alias: "class-name",
+          inside: {
+            punctuation: /\./
+          }
+        },
+        annotation: {
+          pattern: /(\[\s*)[a-z_]\w*(?=\s*=)/i,
+          lookbehind: !0
+        }
+      });
+    })(o);
+  }
+  return a;
+}
+export {
+  r as __require
+};