@glodon-aiot/agent-cli-ui 0.0.0-20251106104234

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

@@ -0,0 +1,84 @@
+var t, n;
+function r() {
+  if (n)
+    return t;
+  n = 1, t = a, a.displayName = "haxe", a.aliases = [];
+  function a(e) {
+    e.languages.haxe = e.languages.extend("clike", {
+      string: {
+        // Strings can be multi-line
+        pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+        greedy: !0
+      },
+      "class-name": [
+        {
+          pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+          lookbehind: !0
+        },
+        // based on naming convention
+        /\b[A-Z]\w*/
+      ],
+      // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+      keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+        greedy: !0
+      },
+      operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+    }), e.languages.insertBefore("haxe", "string", {
+      "string-interpolation": {
+        pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{?|\}$/,
+                alias: "punctuation"
+              },
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: e.languages.haxe
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.insertBefore("haxe", "class-name", {
+      regex: {
+        pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+        greedy: !0,
+        inside: {
+          "regex-flags": /\b[a-z]+$/,
+          "regex-source": {
+            pattern: /^(~\/)[\s\S]+(?=\/$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^~\/|\/$/
+        }
+      }
+    }), e.languages.insertBefore("haxe", "keyword", {
+      preprocessor: {
+        pattern: /#(?:else|elseif|end|if)\b.*/,
+        alias: "property"
+      },
+      metadata: {
+        pattern: /@:?[\w.]+/,
+        alias: "symbol"
+      },
+      reification: {
+        pattern: /\$(?:\w+|(?=\{))/,
+        alias: "important"
+      }
+    });
+  }
+  return t;
+}
+export {
+  r as __require
+};

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

@@ -0,0 +1,68 @@
+var r, a;
+function i() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "hcl", e.aliases = [];
+  function e(t) {
+    t.languages.hcl = {
+      comment: /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
+      heredoc: {
+        pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
+        greedy: !0,
+        alias: "string"
+      },
+      keyword: [{
+        pattern: /(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,
+        inside: {
+          type: {
+            pattern: /(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,
+            lookbehind: !0,
+            alias: "variable"
+          }
+        }
+      }, {
+        pattern: /(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,
+        inside: {
+          type: {
+            pattern: /(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
+            lookbehind: !0,
+            alias: "variable"
+          }
+        }
+      }, /[\w-]+(?=\s+\{)/],
+      property: [/[-\w\.]+(?=\s*=(?!=))/, /"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/],
+      string: {
+        pattern: /"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,
+            lookbehind: !0,
+            inside: {
+              type: {
+                pattern: /(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,
+                lookbehind: !0,
+                alias: "variable"
+              },
+              keyword: /\b(?:count|data|local|module|path|self|terraform|var)\b/i,
+              function: /\w+(?=\()/,
+              string: {
+                pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+                greedy: !0
+              },
+              number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+              punctuation: /[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/
+            }
+          }
+        }
+      },
+      number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
+      boolean: /\b(?:false|true)\b/i,
+      punctuation: /[=\[\]{}]/
+    };
+  }
+  return r;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,31 @@
+import { __require as i } from "./c.mjs";
+var t, a;
+function l() {
+  if (a)
+    return t;
+  a = 1;
+  var n = i();
+  t = r, r.displayName = "hlsl", r.aliases = [];
+  function r(e) {
+    e.register(n), e.languages.hlsl = e.languages.extend("c", {
+      // Regarding keywords and class names:
+      // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words
+      "class-name": [e.languages.c["class-name"], /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/],
+      keyword: [
+        // HLSL keyword
+        /\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,
+        // scalar, vector, and matrix types
+        /\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/
+      ],
+      // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers
+      number: /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
+      boolean: /\b(?:false|true)\b/
+    });
+  }
+  return t;
+}
+export {
+  l as __require
+};

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

@@ -0,0 +1,26 @@
+var n, a;
+function o() {
+  if (a)
+    return n;
+  a = 1, n = e, e.displayName = "hoon", e.aliases = [];
+  function e(r) {
+    r.languages.hoon = {
+      comment: {
+        pattern: /::.*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: !0
+      },
+      constant: /%(?:\.[ny]|[\w-]+)/,
+      "class-name": /@(?:[a-z0-9-]*[a-z0-9])?|\*/i,
+      function: /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,
+      keyword: /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/
+    };
+  }
+  return n;
+}
+export {
+  o as __require
+};

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

@@ -0,0 +1,20 @@
+var p, e;
+function i() {
+  if (e)
+    return p;
+  e = 1, p = r, r.displayName = "hpkp", r.aliases = [];
+  function r(a) {
+    a.languages.hpkp = {
+      directive: {
+        pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
+        alias: "property"
+      },
+      operator: /=/,
+      punctuation: /;/
+    };
+  }
+  return p;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,20 @@
+var e, a;
+function t() {
+  if (a)
+    return e;
+  a = 1, e = s, s.displayName = "hsts", s.aliases = [];
+  function s(r) {
+    r.languages.hsts = {
+      directive: {
+        pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,
+        alias: "property"
+      },
+      operator: /=/,
+      punctuation: /;/
+    };
+  }
+  return e;
+}
+export {
+  t as __require
+};

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

@@ -0,0 +1,126 @@
+var u, l;
+function v() {
+  if (l)
+    return u;
+  l = 1, u = i, i.displayName = "http", i.aliases = [];
+  function i(o) {
+    (function(e) {
+      function s(n) {
+        return RegExp("(^(?:" + n + "):[ 	]*(?![ 	]))[^]+", "i");
+      }
+      e.languages.http = {
+        "request-line": {
+          pattern: /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m,
+          inside: {
+            // HTTP Method
+            method: {
+              pattern: /^[A-Z]+\b/,
+              alias: "property"
+            },
+            // Request Target e.g. http://example.com, /path/to/file
+            "request-target": {
+              pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,
+              lookbehind: !0,
+              alias: "url",
+              inside: e.languages.uri
+            },
+            // HTTP Version
+            "http-version": {
+              pattern: /^(\s)HTTP\/[\d.]+/,
+              lookbehind: !0,
+              alias: "property"
+            }
+          }
+        },
+        "response-status": {
+          pattern: /^HTTP\/[\d.]+ \d+ .+/m,
+          inside: {
+            // HTTP Version
+            "http-version": {
+              pattern: /^HTTP\/[\d.]+/,
+              alias: "property"
+            },
+            // Status Code
+            "status-code": {
+              pattern: /^(\s)\d+(?=\s)/,
+              lookbehind: !0,
+              alias: "number"
+            },
+            // Reason Phrase
+            "reason-phrase": {
+              pattern: /^(\s).+/,
+              lookbehind: !0,
+              alias: "string"
+            }
+          }
+        },
+        header: {
+          pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,
+          inside: {
+            "header-value": [{
+              pattern: s(/Content-Security-Policy/.source),
+              lookbehind: !0,
+              alias: ["csp", "languages-csp"],
+              inside: e.languages.csp
+            }, {
+              pattern: s(/Public-Key-Pins(?:-Report-Only)?/.source),
+              lookbehind: !0,
+              alias: ["hpkp", "languages-hpkp"],
+              inside: e.languages.hpkp
+            }, {
+              pattern: s(/Strict-Transport-Security/.source),
+              lookbehind: !0,
+              alias: ["hsts", "languages-hsts"],
+              inside: e.languages.hsts
+            }, {
+              pattern: s(/[^:]+/.source),
+              lookbehind: !0
+            }],
+            "header-name": {
+              pattern: /^[^:]+/,
+              alias: "keyword"
+            },
+            punctuation: /^:/
+          }
+        }
+      };
+      var t = e.languages, p = {
+        "application/javascript": t.javascript,
+        "application/json": t.json || t.javascript,
+        "application/xml": t.xml,
+        "text/xml": t.xml,
+        "text/html": t.html,
+        "text/css": t.css,
+        "text/plain": t.plain
+      }, h = {
+        "application/json": !0,
+        "application/xml": !0
+      };
+      function d(n) {
+        var g = n.replace(/^[a-z]+\//, ""), f = "\\w+/(?:[\\w.-]+\\+)+" + g + "(?![+\\w.-])";
+        return "(?:" + n + "|" + f + ")";
+      }
+      var r;
+      for (var a in p)
+        if (p[a]) {
+          r = r || {};
+          var c = h[a] ? d(a) : a;
+          r[a.replace(/\//g, "-")] = {
+            pattern: RegExp("(" + /content-type:\s*/.source + c + /(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source + ")" + // This is a little interesting:
+            // The HTTP format spec required 1 empty line before the body to make everything unambiguous.
+            // However, when writing code by hand (e.g. to display on a website) people can forget about this,
+            // so we want to be liberal here. We will allow the empty line to be omitted if the first line of
+            // the body does not start with a [\w-] character (as headers do).
+            /[^ \t\w-][\s\S]*/.source, "i"),
+            lookbehind: !0,
+            inside: p[a]
+          };
+        }
+      r && e.languages.insertBefore("http", "header", r);
+    })(o);
+  }
+  return u;
+}
+export {
+  v as __require
+};

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

@@ -0,0 +1,25 @@
+var i, N;
+function T() {
+  if (N)
+    return i;
+  N = 1, i = E, E.displayName = "ichigojam", E.aliases = [];
+  function E(R) {
+    R.languages.ichigojam = {
+      comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
+      string: {
+        pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+        greedy: !0
+      },
+      number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+      keyword: /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
+      function: /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
+      label: /(?:\B@\S+)/,
+      operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
+      punctuation: /[\[,;:()\]]/
+    };
+  }
+  return i;
+}
+export {
+  T as __require
+};

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

@@ -0,0 +1,32 @@
+var r, t;
+function n() {
+  if (t)
+    return r;
+  t = 1, r = e, e.displayName = "icon", e.aliases = [];
+  function e(i) {
+    i.languages.icon = {
+      comment: /#.*/,
+      string: {
+        pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,
+        greedy: !0
+      },
+      number: /\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i,
+      "builtin-keyword": {
+        pattern: /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/,
+        alias: "variable"
+      },
+      directive: {
+        pattern: /\$\w+/,
+        alias: "builtin"
+      },
+      keyword: /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,
+      function: /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
+      operator: /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,
+      punctuation: /[\[\](){},;]/
+    };
+  }
+  return r;
+}
+export {
+  n as __require
+};

package/dist/es/node_modules/refractor/lang/icu-message-format.mjs

@@ -0,0 +1,136 @@
+var n, d;
+function p() {
+  if (d)
+    return n;
+  d = 1, n = t, t.displayName = "icuMessageFormat", t.aliases = [];
+  function t(c) {
+    (function(e) {
+      function s(u, l) {
+        return l <= 0 ? /[]/.source : u.replace(/<SELF>/g, function() {
+          return s(u, l - 1);
+        });
+      }
+      var a = /'[{}:=,](?:[^']|'')*'(?!')/, i = {
+        pattern: /''/,
+        greedy: !0,
+        alias: "operator"
+      }, g = {
+        pattern: a,
+        greedy: !0,
+        inside: {
+          escape: i
+        }
+      }, o = s(/\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(/<STR>/g, function() {
+        return a.source;
+      }), 8), r = {
+        pattern: RegExp(o),
+        inside: {
+          message: {
+            pattern: /^(\{)[\s\S]+(?=\}$)/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          "message-delimiter": {
+            pattern: /./,
+            alias: "punctuation"
+          }
+        }
+      };
+      e.languages["icu-message-format"] = {
+        argument: {
+          pattern: RegExp(o),
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /^(\{)[\s\S]+(?=\}$)/,
+              lookbehind: !0,
+              inside: {
+                "argument-name": {
+                  pattern: /^(\s*)[^{}:=,\s]+/,
+                  lookbehind: !0
+                },
+                "choice-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
+                  pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    punctuation: /\|/,
+                    range: {
+                      pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+                      lookbehind: !0,
+                      inside: {
+                        operator: /[<#\u2264]/,
+                        number: /\S+/
+                      }
+                    },
+                    rest: null
+                    // see below
+                  }
+                },
+                "plural-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    offset: /^offset:\s*\d+/,
+                    "nested-message": r,
+                    selector: {
+                      pattern: /=\d+|[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^(?:few|many|one|other|two|zero)$/
+                      }
+                    }
+                  }
+                },
+                "select-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    "nested-message": r,
+                    selector: {
+                      pattern: /[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^other$/
+                      }
+                    }
+                  }
+                },
+                keyword: /\b(?:choice|plural|select|selectordinal)\b/,
+                "arg-type": {
+                  pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+                  alias: "keyword"
+                },
+                "arg-skeleton": {
+                  pattern: /(,\s*)::[^{}:=,\s]+/,
+                  lookbehind: !0
+                },
+                "arg-style": {
+                  pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+                  lookbehind: !0
+                },
+                "arg-style-text": {
+                  pattern: RegExp(/(^\s*,\s*(?=\S))/.source + s(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"),
+                  lookbehind: !0,
+                  alias: "string"
+                },
+                punctuation: /,/
+              }
+            },
+            "argument-delimiter": {
+              pattern: /./,
+              alias: "operator"
+            }
+          }
+        },
+        escape: i,
+        string: g
+      }, r.inside.message.inside = e.languages["icu-message-format"], e.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = e.languages["icu-message-format"];
+    })(c);
+  }
+  return n;
+}
+export {
+  p as __require
+};

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

@@ -0,0 +1,30 @@
+import { __require as n } from "./haskell.mjs";
+var r, a;
+function o() {
+  if (a)
+    return r;
+  a = 1;
+  var t = n();
+  r = i, i.displayName = "idris", i.aliases = ["idr"];
+  function i(e) {
+    e.register(t), e.languages.idris = e.languages.extend("haskell", {
+      comment: {
+        pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m
+      },
+      keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+      builtin: void 0
+    }), e.languages.insertBefore("idris", "keyword", {
+      "import-statement": {
+        pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    }), e.languages.idr = e.languages.idris;
+  }
+  return r;
+}
+export {
+  o as __require
+};

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

@@ -0,0 +1,38 @@
+var E, N;
+function I() {
+  if (N)
+    return E;
+  N = 1, E = T, T.displayName = "iecst", T.aliases = [];
+  function T(e) {
+    e.languages.iecst = {
+      comment: [{
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+        lookbehind: !0,
+        greedy: !0
+      }, {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: !0,
+        greedy: !0
+      }],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      keyword: [/\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i, /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/],
+      "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+      address: {
+        pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+        alias: "symbol"
+      },
+      number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+      operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      punctuation: /[()[\].,;]/
+    };
+  }
+  return E;
+}
+export {
+  I as __require
+};

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

@@ -0,0 +1,30 @@
+var g, r;
+function o() {
+  if (r)
+    return g;
+  r = 1, g = n, n.displayName = "ignore", n.aliases = ["gitignore", "hgignore", "npmignore"];
+  function n(a) {
+    (function(e) {
+      e.languages.ignore = {
+        // https://git-scm.com/docs/gitignore
+        comment: /^#.*/m,
+        entry: {
+          pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
+          alias: "string",
+          inside: {
+            operator: /^!|\*\*?|\?/,
+            regex: {
+              pattern: /(^|[^\\])\[[^\[\]]*\]/,
+              lookbehind: !0
+            },
+            punctuation: /\//
+          }
+        }
+      }, e.languages.gitignore = e.languages.ignore, e.languages.hgignore = e.languages.ignore, e.languages.npmignore = e.languages.ignore;
+    })(a);
+  }
+  return g;
+}
+export {
+  o as __require
+};