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

package/dist/es/node_modules/refractor/lang/t4-templating.mjs

@@ -1,57 +0,0 @@
-var i, l;
-function c() {
-  if (l)
-    return i;
-  l = 1, i = r, r.displayName = "t4Templating", r.aliases = [];
-  function r(u) {
-    (function(s) {
-      function n(e, a, t) {
-        return {
-          pattern: RegExp("<#" + e + "[\\s\\S]*?#>"),
-          alias: "block",
-          inside: {
-            delimiter: {
-              pattern: RegExp("^<#" + e + "|#>$"),
-              alias: "important"
-            },
-            content: {
-              pattern: /[\s\S]+/,
-              inside: a,
-              alias: t
-            }
-          }
-        };
-      }
-      function p(e) {
-        var a = s.languages[e], t = "language-" + e;
-        return {
-          block: {
-            pattern: /<#[\s\S]+?#>/,
-            inside: {
-              directive: n("@", {
-                "attr-value": {
-                  pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
-                  inside: {
-                    punctuation: /^=|^["']|["']$/
-                  }
-                },
-                keyword: /\b\w+(?=\s)/,
-                "attr-name": /\b\w+/
-              }),
-              expression: n("=", a, t),
-              "class-feature": n("\\+", a, t),
-              standard: n("", a, t)
-            }
-          }
-        };
-      }
-      s.languages["t4-templating"] = Object.defineProperty({}, "createT4", {
-        value: p
-      });
-    })(u);
-  }
-  return i;
-}
-export {
-  c as __require
-};

package/dist/es/node_modules/refractor/lang/t4-vb.mjs

@@ -1,17 +0,0 @@
-import { __require as u } from "./t4-templating.mjs";
-import { __require as b } from "./vbnet.mjs";
-var t, a;
-function s() {
-  if (a)
-    return t;
-  a = 1;
-  var i = u(), n = b();
-  t = r, r.displayName = "t4Vb", r.aliases = [];
-  function r(e) {
-    e.register(i), e.register(n), e.languages["t4-vb"] = e.languages["t4-templating"].createT4("vbnet");
-  }
-  return t;
-}
-export {
-  s as __require
-};

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

@@ -1,35 +0,0 @@
-import { __require as n } from "./yaml.mjs";
-var r, t;
-function s() {
-  if (t)
-    return r;
-  t = 1;
-  var i = n();
-  r = a, a.displayName = "tap", a.aliases = [];
-  function a(e) {
-    e.register(i), e.languages.tap = {
-      fail: /not ok[^#{\n\r]*/,
-      pass: /ok[^#{\n\r]*/,
-      pragma: /pragma [+-][a-z]+/,
-      bailout: /bail out!.*/i,
-      version: /TAP version \d+/i,
-      plan: /\b\d+\.\.\d+(?: +#.*)?/,
-      subtest: {
-        pattern: /# Subtest(?:: .*)?/,
-        greedy: !0
-      },
-      punctuation: /[{}]/,
-      directive: /#.*/,
-      yamlish: {
-        pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
-        lookbehind: !0,
-        inside: e.languages.yaml,
-        alias: "language-yaml"
-      }
-    };
-  }
-  return r;
-}
-export {
-  s as __require
-};

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

@@ -1,51 +0,0 @@
-var t, r;
-function n() {
-  if (r)
-    return t;
-  r = 1, t = e, e.displayName = "tcl", e.aliases = [];
-  function e(a) {
-    a.languages.tcl = {
-      comment: {
-        pattern: /(^|[^\\])#.*/,
-        lookbehind: !0
-      },
-      string: {
-        pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
-        greedy: !0
-      },
-      variable: [{
-        pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
-        lookbehind: !0
-      }, {
-        pattern: /(\$)\{[^}]+\}/,
-        lookbehind: !0
-      }, {
-        pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
-        lookbehind: !0
-      }],
-      function: {
-        pattern: /(^[\t ]*proc[ \t]+)\S+/m,
-        lookbehind: !0
-      },
-      builtin: [{
-        pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
-        lookbehind: !0
-      }, /\b(?:else|elseif)\b/],
-      scope: {
-        pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
-        lookbehind: !0,
-        alias: "constant"
-      },
-      keyword: {
-        pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
-        lookbehind: !0
-      },
-      operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
-      punctuation: /[{}()\[\]]/
-    };
-  }
-  return t;
-}
-export {
-  n as __require
-};

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

@@ -1,248 +0,0 @@
-var u, l;
-function m() {
-  if (l)
-    return u;
-  l = 1, u = o, o.displayName = "textile", o.aliases = [];
-  function o(p) {
-    (function(s) {
-      var c = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source, k = /\)|\((?![^|()\n]+\))/.source;
-      function e(b, h) {
-        return RegExp(b.replace(/<MOD>/g, function() {
-          return "(?:" + c + ")";
-        }).replace(/<PAR>/g, function() {
-          return "(?:" + k + ")";
-        }), h || "");
-      }
-      var i = {
-        css: {
-          pattern: /\{[^{}]+\}/,
-          inside: {
-            rest: s.languages.css
-          }
-        },
-        "class-id": {
-          pattern: /(\()[^()]+(?=\))/,
-          lookbehind: !0,
-          alias: "attr-value"
-        },
-        lang: {
-          pattern: /(\[)[^\[\]]+(?=\])/,
-          lookbehind: !0,
-          alias: "attr-value"
-        },
-        // Anything else is punctuation (the first pattern is for row/col spans inside tables)
-        punctuation: /[\\\/]\d+|\S/
-      }, d = s.languages.textile = s.languages.extend("markup", {
-        phrase: {
-          pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
-          lookbehind: !0,
-          inside: {
-            // h1. Header 1
-            "block-tag": {
-              pattern: e(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
-              inside: {
-                modifier: {
-                  pattern: e(/(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                tag: /^[a-z]\w*/,
-                punctuation: /\.$/
-              }
-            },
-            // # List item
-            // * List item
-            list: {
-              pattern: e(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
-              inside: {
-                modifier: {
-                  pattern: e(/(^[*#]+)<MOD>+/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                punctuation: /^[*#]+/
-              }
-            },
-            // | cell | cell | cell |
-            table: {
-              // Modifiers can be applied to the row: {color:red}.|1|2|3|
-              // or the cell: |{color:red}.1|2|3|
-              pattern: e(/^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source, "m"),
-              inside: {
-                modifier: {
-                  // Modifiers for rows after the first one are
-                  // preceded by a pipe and a line feed
-                  pattern: e(/(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                punctuation: /\||^\./
-              }
-            },
-            inline: {
-              // eslint-disable-next-line regexp/no-super-linear-backtracking
-              pattern: e(/(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source),
-              lookbehind: !0,
-              inside: {
-                // Note: superscripts and subscripts are not handled specifically
-                // *bold*, **bold**
-                bold: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
-                  lookbehind: !0
-                },
-                // _italic_, __italic__
-                italic: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^(__?)<MOD>*).+?(?=\2)/.source),
-                  lookbehind: !0
-                },
-                // ??cite??
-                cite: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
-                  lookbehind: !0,
-                  alias: "string"
-                },
-                // @code@
-                code: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^@<MOD>*).+?(?=@)/.source),
-                  lookbehind: !0,
-                  alias: "keyword"
-                },
-                // +inserted+
-                inserted: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^\+<MOD>*).+?(?=\+)/.source),
-                  lookbehind: !0
-                },
-                // -deleted-
-                deleted: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^-<MOD>*).+?(?=-)/.source),
-                  lookbehind: !0
-                },
-                // %span%
-                span: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^%<MOD>*).+?(?=%)/.source),
-                  lookbehind: !0
-                },
-                modifier: {
-                  pattern: e(/(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                punctuation: /[*_%?@+\-^~]+/
-              }
-            },
-            // [alias]http://example.com
-            "link-ref": {
-              pattern: /^\[[^\]]+\]\S+$/m,
-              inside: {
-                string: {
-                  pattern: /(^\[)[^\]]+(?=\])/,
-                  lookbehind: !0
-                },
-                url: {
-                  pattern: /(^\])\S+$/,
-                  lookbehind: !0
-                },
-                punctuation: /[\[\]]/
-              }
-            },
-            // "text":http://example.com
-            // "text":link-ref
-            link: {
-              // eslint-disable-next-line regexp/no-super-linear-backtracking
-              pattern: e(/"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source),
-              inside: {
-                text: {
-                  // eslint-disable-next-line regexp/no-super-linear-backtracking
-                  pattern: e(/(^"<MOD>*)[^"]+(?=")/.source),
-                  lookbehind: !0
-                },
-                modifier: {
-                  pattern: e(/(^")<MOD>+/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                url: {
-                  pattern: /(:).+/,
-                  lookbehind: !0
-                },
-                punctuation: /[":]/
-              }
-            },
-            // !image.jpg!
-            // !image.jpg(Title)!:http://example.com
-            image: {
-              pattern: e(/!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source),
-              inside: {
-                source: {
-                  pattern: e(/(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source),
-                  lookbehind: !0,
-                  alias: "url"
-                },
-                modifier: {
-                  pattern: e(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
-                  lookbehind: !0,
-                  inside: i
-                },
-                url: {
-                  pattern: /(:).+/,
-                  lookbehind: !0
-                },
-                punctuation: /[!:]/
-              }
-            },
-            // Footnote[1]
-            footnote: {
-              pattern: /\b\[\d+\]/,
-              alias: "comment",
-              inside: {
-                punctuation: /\[|\]/
-              }
-            },
-            // CSS(Cascading Style Sheet)
-            acronym: {
-              pattern: /\b[A-Z\d]+\([^)]+\)/,
-              inside: {
-                comment: {
-                  pattern: /(\()[^()]+(?=\))/,
-                  lookbehind: !0
-                },
-                punctuation: /[()]/
-              }
-            },
-            // Prism(C)
-            mark: {
-              pattern: /\b\((?:C|R|TM)\)/,
-              alias: "comment",
-              inside: {
-                punctuation: /[()]/
-              }
-            }
-          }
-        }
-      }), t = d.phrase.inside, n = {
-        inline: t.inline,
-        link: t.link,
-        image: t.image,
-        footnote: t.footnote,
-        acronym: t.acronym,
-        mark: t.mark
-      };
-      d.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
-      var a = t.inline.inside;
-      a.bold.inside = n, a.italic.inside = n, a.inserted.inside = n, a.deleted.inside = n, a.span.inside = n;
-      var r = t.table.inside;
-      r.inline = n.inline, r.link = n.link, r.image = n.image, r.footnote = n.footnote, r.acronym = n.acronym, r.mark = n.mark;
-    })(p);
-  }
-  return u;
-}
-export {
-  m as __require
-};

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

@@ -1,54 +0,0 @@
-var r, n;
-function o() {
-  if (n)
-    return r;
-  n = 1, r = e, e.displayName = "toml", e.aliases = [];
-  function e(a) {
-    (function(d) {
-      var s = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
-      function t(u) {
-        return u.replace(/__/g, function() {
-          return s;
-        });
-      }
-      d.languages.toml = {
-        comment: {
-          pattern: /#.*/,
-          greedy: !0
-        },
-        table: {
-          pattern: RegExp(t(/(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source), "m"),
-          lookbehind: !0,
-          greedy: !0,
-          alias: "class-name"
-        },
-        key: {
-          pattern: RegExp(t(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source), "m"),
-          lookbehind: !0,
-          greedy: !0,
-          alias: "property"
-        },
-        string: {
-          pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
-          greedy: !0
-        },
-        date: [{
-          // Offset Date-Time, Local Date-Time, Local Date
-          pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
-          alias: "number"
-        }, {
-          // Local Time
-          pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
-          alias: "number"
-        }],
-        number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
-        boolean: /\b(?:false|true)\b/,
-        punctuation: /[.,=[\]{}]/
-      };
-    })(a);
-  }
-  return r;
-}
-export {
-  o as __require
-};

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

@@ -1,67 +0,0 @@
-var n, o;
-function i() {
-  if (o)
-    return n;
-  o = 1, n = r, r.displayName = "tremor", r.aliases = [];
-  function r(a) {
-    (function(e) {
-      e.languages.tremor = {
-        comment: {
-          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
-          lookbehind: !0
-        },
-        "interpolated-string": null,
-        // see below
-        extractor: {
-          pattern: /\b[a-z_]\w*\|(?:[^\r\n\\|]|\\(?:\r\n|[\s\S]))*\|/i,
-          greedy: !0,
-          inside: {
-            regex: {
-              pattern: /(^re)\|[\s\S]+/,
-              lookbehind: !0
-            },
-            function: /^\w+/,
-            value: /\|[\s\S]+/
-          }
-        },
-        identifier: {
-          pattern: /`[^`]*`/,
-          greedy: !0
-        },
-        function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())\b/,
-        keyword: /\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\b/,
-        boolean: /\b(?:false|null|true)\b/i,
-        number: /\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee][+-]?[\d_]+)?)\b/,
-        "pattern-punctuation": {
-          pattern: /%(?=[({[])/,
-          alias: "punctuation"
-        },
-        operator: /[-+*\/%~!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\b/,
-        punctuation: /::|[;\[\]()\{\},.:]/
-      };
-      var t = /#\{(?:[^"{}]|\{[^{}]*\}|"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*")*\}/.source;
-      e.languages.tremor["interpolated-string"] = {
-        pattern: RegExp(/(^|[^\\])/.source + '(?:"""(?:' + /[^"\\#]|\\[\s\S]|"(?!"")|#(?!\{)/.source + "|" + t + ')*"""|"(?:' + /[^"\\\r\n#]|\\(?:\r\n|[\s\S])|#(?!\{)/.source + "|" + t + ')*")'),
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          interpolation: {
-            pattern: RegExp(t),
-            inside: {
-              punctuation: /^#\{|\}$/,
-              expression: {
-                pattern: /[\s\S]+/,
-                inside: e.languages.tremor
-              }
-            }
-          },
-          string: /[\s\S]+/
-        }
-      }, e.languages.troy = e.languages.tremor, e.languages.trickle = e.languages.tremor;
-    })(a);
-  }
-  return n;
-}
-export {
-  i as __require
-};

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

@@ -1,22 +0,0 @@
-import { __require as i } from "./jsx.mjs";
-import { __require as l } from "./typescript.mjs";
-var s, u;
-function c() {
-  if (u)
-    return s;
-  u = 1;
-  var n = i(), p = l();
-  s = t, t.displayName = "tsx", t.aliases = [];
-  function t(a) {
-    a.register(n), a.register(p), function(e) {
-      var g = e.util.clone(e.languages.typescript);
-      e.languages.tsx = e.languages.extend("jsx", g), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"];
-      var r = e.languages.tsx.tag;
-      r.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + r.pattern.source + ")", r.pattern.flags), r.lookbehind = !0;
-    }(a);
-  }
-  return s;
-}
-export {
-  c as __require
-};

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

@@ -1,53 +0,0 @@
-import { __require as g } from "./markup-templating.mjs";
-var r, i;
-function s() {
-  if (i)
-    return r;
-  i = 1;
-  var u = g();
-  r = t, t.displayName = "tt2", t.aliases = [];
-  function t(n) {
-    n.register(u), function(e) {
-      e.languages.tt2 = e.languages.extend("clike", {
-        comment: /#.*|\[%#[\s\S]*?%\]/,
-        keyword: /\b(?:BLOCK|CALL|CASE|CATCH|CLEAR|DEBUG|DEFAULT|ELSE|ELSIF|END|FILTER|FINAL|FOREACH|GET|IF|IN|INCLUDE|INSERT|LAST|MACRO|META|NEXT|PERL|PROCESS|RAWPERL|RETURN|SET|STOP|SWITCH|TAGS|THROW|TRY|UNLESS|USE|WHILE|WRAPPER)\b/,
-        punctuation: /[[\]{},()]/
-      }), e.languages.insertBefore("tt2", "number", {
-        operator: /=[>=]?|!=?|<=?|>=?|&&|\|\|?|\b(?:and|not|or)\b/,
-        variable: {
-          pattern: /\b[a-z]\w*(?:\s*\.\s*(?:\d+|\$?[a-z]\w*))*\b/i
-        }
-      }), e.languages.insertBefore("tt2", "keyword", {
-        delimiter: {
-          pattern: /^(?:\[%|%%)-?|-?%\]$/,
-          alias: "punctuation"
-        }
-      }), e.languages.insertBefore("tt2", "string", {
-        "single-quoted-string": {
-          pattern: /'[^\\']*(?:\\[\s\S][^\\']*)*'/,
-          greedy: !0,
-          alias: "string"
-        },
-        "double-quoted-string": {
-          pattern: /"[^\\"]*(?:\\[\s\S][^\\"]*)*"/,
-          greedy: !0,
-          alias: "string",
-          inside: {
-            variable: {
-              pattern: /\$(?:[a-z]\w*(?:\.(?:\d+|\$?[a-z]\w*))*)/i
-            }
-          }
-        }
-      }), delete e.languages.tt2.string, e.hooks.add("before-tokenize", function(a) {
-        var o = /\[%[\s\S]+?%\]/g;
-        e.languages["markup-templating"].buildPlaceholders(a, "tt2", o);
-      }), e.hooks.add("after-tokenize", function(a) {
-        e.languages["markup-templating"].tokenizePlaceholders(a, "tt2");
-      });
-    }(n);
-  }
-  return r;
-}
-export {
-  s as __require
-};

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

@@ -1,62 +0,0 @@
-var r, n;
-function a() {
-  if (n)
-    return r;
-  n = 1, r = e, e.displayName = "turtle", e.aliases = [];
-  function e(t) {
-    t.languages.turtle = {
-      comment: {
-        pattern: /#.*/,
-        greedy: !0
-      },
-      "multiline-string": {
-        pattern: /"""(?:(?:""?)?(?:[^"\\]|\\.))*"""|'''(?:(?:''?)?(?:[^'\\]|\\.))*'''/,
-        greedy: !0,
-        alias: "string",
-        inside: {
-          comment: /#.*/
-        }
-      },
-      string: {
-        pattern: /"(?:[^\\"\r\n]|\\.)*"|'(?:[^\\'\r\n]|\\.)*'/,
-        greedy: !0
-      },
-      url: {
-        pattern: /<(?:[^\x00-\x20<>"{}|^`\\]|\\(?:u[\da-fA-F]{4}|U[\da-fA-F]{8}))*>/,
-        greedy: !0,
-        inside: {
-          punctuation: /[<>]/
-        }
-      },
-      function: {
-        pattern: /(?:(?![-.\d\xB7])[-.\w\xB7\xC0-\uFFFD]+)?:(?:(?![-.])(?:[-.:\w\xC0-\uFFFD]|%[\da-f]{2}|\\.)+)?/i,
-        inside: {
-          "local-name": {
-            pattern: /([^:]*:)[\s\S]+/,
-            lookbehind: !0
-          },
-          prefix: {
-            pattern: /[\s\S]+/,
-            inside: {
-              punctuation: /:/
-            }
-          }
-        }
-      },
-      number: /[+-]?\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
-      punctuation: /[{}.,;()[\]]|\^\^/,
-      boolean: /\b(?:false|true)\b/,
-      keyword: [/(?:\ba|@prefix|@base)\b|=/, /\b(?:base|graph|prefix)\b/i],
-      tag: {
-        pattern: /@[a-z]+(?:-[a-z\d]+)*/i,
-        inside: {
-          punctuation: /@/
-        }
-      }
-    }, t.languages.trig = t.languages.turtle;
-  }
-  return r;
-}
-export {
-  a as __require
-};