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

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

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

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

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

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

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

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

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

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

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

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