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

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

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

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

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

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

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

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

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

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

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

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

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

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

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