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

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

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

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

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

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

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

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

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

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

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

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