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

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

@@ -0,0 +1,61 @@
+var t, s;
+function i() {
+  if (s)
+    return t;
+  s = 1, t = r, r.displayName = "csp", r.aliases = [];
+  function r(o) {
+    (function(a) {
+      function e(n) {
+        return RegExp(/([ \t])/.source + "(?:" + n + ")" + /(?=[\s;]|$)/.source, "i");
+      }
+      a.languages.csp = {
+        directive: {
+          pattern: /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
+          lookbehind: !0,
+          alias: "property"
+        },
+        scheme: {
+          pattern: e(/[a-z][a-z0-9.+-]*:/.source),
+          lookbehind: !0
+        },
+        none: {
+          pattern: e(/'none'/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        nonce: {
+          pattern: e(/'nonce-[-+/\w=]+'/.source),
+          lookbehind: !0,
+          alias: "number"
+        },
+        hash: {
+          pattern: e(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+          lookbehind: !0,
+          alias: "number"
+        },
+        host: {
+          pattern: e(/[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source + "|" + /\*[^\s;,']*/.source + "|" + /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source),
+          lookbehind: !0,
+          alias: "url",
+          inside: {
+            important: /\*/
+          }
+        },
+        keyword: [{
+          pattern: e(/'unsafe-[a-z-]+'/.source),
+          lookbehind: !0,
+          alias: "unsafe"
+        }, {
+          pattern: e(/'[a-z-]+'/.source),
+          lookbehind: !0,
+          alias: "safe"
+        }],
+        punctuation: /;/
+      };
+    })(o);
+  }
+  return t;
+}
+export {
+  i as __require
+};

package/dist/es/node_modules/refractor/lang/css-extras.mjs

@@ -0,0 +1,109 @@
+var a, l;
+function u() {
+  if (l)
+    return a;
+  l = 1, a = r, r.displayName = "cssExtras", r.aliases = [];
+  function r(s) {
+    (function(e) {
+      var n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t;
+      e.languages.css.selector = {
+        pattern: e.languages.css.selector.pattern,
+        lookbehind: !0,
+        inside: t = {
+          "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+          "pseudo-class": /:[-\w]+/,
+          class: /\.[-\w]+/,
+          id: /#[-\w]+/,
+          attribute: {
+            pattern: RegExp(`\\[(?:[^[\\]"']|` + n.source + ")*\\]"),
+            greedy: !0,
+            inside: {
+              punctuation: /^\[|\]$/,
+              "case-sensitivity": {
+                pattern: /(\s)[si]$/i,
+                lookbehind: !0,
+                alias: "keyword"
+              },
+              namespace: {
+                pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
+                lookbehind: !0,
+                inside: {
+                  punctuation: /\|$/
+                }
+              },
+              "attr-name": {
+                pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
+                lookbehind: !0
+              },
+              "attr-value": [n, {
+                pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
+                lookbehind: !0
+              }],
+              operator: /[|~*^$]?=/
+            }
+          },
+          "n-th": [{
+            pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+            lookbehind: !0,
+            inside: {
+              number: /[\dn]+/,
+              operator: /[+-]/
+            }
+          }, {
+            pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
+            lookbehind: !0
+          }],
+          combinator: />|\+|~|\|\|/,
+          // the `tag` token has been existed and removed.
+          // because we can't find a perfect tokenize to match it.
+          // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+          punctuation: /[(),]/
+        }
+      }, e.languages.css.atrule.inside["selector-function-argument"].inside = t, e.languages.insertBefore("css", "property", {
+        variable: {
+          pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+          lookbehind: !0
+        }
+      });
+      var i = {
+        pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+        lookbehind: !0
+      }, o = {
+        pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+        lookbehind: !0
+      };
+      e.languages.insertBefore("css", "function", {
+        operator: {
+          pattern: /(\s)[+\-*\/](?=\s)/,
+          lookbehind: !0
+        },
+        // CAREFUL!
+        // Previewers and Inline color use hexcode and color.
+        hexcode: {
+          pattern: /\B#[\da-f]{3,8}\b/i,
+          alias: "color"
+        },
+        color: [{
+          pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
+          lookbehind: !0
+        }, {
+          pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+          inside: {
+            unit: i,
+            number: o,
+            function: /[\w-]+(?=\()/,
+            punctuation: /[(),]/
+          }
+        }],
+        // it's important that there is no boundary assertion after the hex digits
+        entity: /\\[\da-f]{1,8}/i,
+        unit: i,
+        number: o
+      });
+    })(s);
+  }
+  return a;
+}
+export {
+  u as __require
+};

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

@@ -0,0 +1,63 @@
+var a = r;
+r.displayName = "css";
+r.aliases = [];
+function r(n) {
+  (function(s) {
+    var e = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+    s.languages.css = {
+      comment: /\/\*[\s\S]*?\*\//,
+      atrule: {
+        pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+        inside: {
+          rule: /^@[\w-]+/,
+          "selector-function-argument": {
+            pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+            lookbehind: !0,
+            alias: "selector"
+          },
+          keyword: {
+            pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+            lookbehind: !0
+          }
+          // See rest below
+        }
+      },
+      url: {
+        // https://drafts.csswg.org/css-values-3/#urls
+        pattern: RegExp("\\burl\\((?:" + e.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+        greedy: !0,
+        inside: {
+          function: /^url/i,
+          punctuation: /^\(|\)$/,
+          string: {
+            pattern: RegExp("^" + e.source + "$"),
+            alias: "url"
+          }
+        }
+      },
+      selector: {
+        pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + e.source + ")*(?=\\s*\\{)"),
+        lookbehind: !0
+      },
+      string: {
+        pattern: e,
+        greedy: !0
+      },
+      property: {
+        pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+        lookbehind: !0
+      },
+      important: /!important\b/i,
+      function: {
+        pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+        lookbehind: !0
+      },
+      punctuation: /[(){};:,]/
+    }, s.languages.css.atrule.inside.rest = s.languages.css;
+    var t = s.languages.markup;
+    t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
+  })(n);
+}
+export {
+  a as c
+};

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

@@ -0,0 +1,16 @@
+var r, a;
+function u() {
+  if (a)
+    return r;
+  a = 1, r = e, e.displayName = "csv", e.aliases = [];
+  function e(s) {
+    s.languages.csv = {
+      value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
+      punctuation: /,/
+    };
+  }
+  return r;
+}
+export {
+  u as __require
+};

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

@@ -0,0 +1,44 @@
+var r, E;
+function N() {
+  if (E)
+    return r;
+  E = 1, r = e, e.displayName = "cypher", e.aliases = [];
+  function e(n) {
+    n.languages.cypher = {
+      // https://neo4j.com/docs/cypher-manual/current/syntax/comments/
+      comment: /\/\/.*/,
+      string: {
+        pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      relationship: {
+        pattern: /(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      },
+      identifier: {
+        pattern: /`(?:[^`\\\r\n])*`/,
+        greedy: !0
+      },
+      variable: /\$\w+/,
+      // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
+      keyword: /\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
+      function: /\b\w+\b(?=\s*\()/,
+      boolean: /\b(?:false|null|true)\b/i,
+      number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+      // https://neo4j.com/docs/cypher-manual/current/syntax/operators/
+      operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
+      punctuation: /[()[\]{},;.]/
+    };
+  }
+  return r;
+}
+export {
+  N as __require
+};

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

@@ -0,0 +1,77 @@
+var t, a;
+function o() {
+  if (a)
+    return t;
+  a = 1, t = r, r.displayName = "d", r.aliases = [];
+  function r(e) {
+    e.languages.d = e.languages.extend("clike", {
+      comment: [{
+        // Shebang
+        pattern: /^\s*#!.+/,
+        greedy: !0
+      }, {
+        pattern: RegExp(/(^|[^\\])/.source + "(?:" + [
+          // /+ comment +/
+          // Allow one level of nesting
+          /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source,
+          // // comment
+          /\/\/.*/.source,
+          // /* comment */
+          /\/\*[\s\S]*?\*\//.source
+        ].join("|") + ")"),
+        lookbehind: !0,
+        greedy: !0
+      }],
+      string: [{
+        pattern: RegExp([
+          // r"", x""
+          /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source,
+          // q"[]", q"()", q"<>", q"{}"
+          /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source,
+          // q"IDENT
+          // ...
+          // IDENT"
+          /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source,
+          // q"//", q"||", etc.
+          // eslint-disable-next-line regexp/strict
+          /\bq"(.)[\s\S]*?\2"/.source,
+          // eslint-disable-next-line regexp/strict
+          /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
+        ].join("|"), "m"),
+        greedy: !0
+      }, {
+        pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
+        greedy: !0,
+        alias: "token-string"
+      }],
+      // In order: $, keywords and special tokens, globally defined symbols
+      keyword: /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
+      number: [
+        // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
+        // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
+        /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
+        {
+          pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
+          lookbehind: !0
+        }
+      ],
+      operator: /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
+    }), e.languages.insertBefore("d", "string", {
+      // Characters
+      // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
+      char: /'(?:\\(?:\W|\w+)|[^\\])'/
+    }), e.languages.insertBefore("d", "keyword", {
+      property: /\B@\w*/
+    }), e.languages.insertBefore("d", "function", {
+      register: {
+        // Iasm registers
+        pattern: /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
+        alias: "variable"
+      }
+    });
+  }
+  return t;
+}
+export {
+  o as __require
+};

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

@@ -0,0 +1,72 @@
+var n, i;
+function d() {
+  if (i)
+    return n;
+  i = 1, n = a, a.displayName = "dart", a.aliases = [];
+  function a(o) {
+    (function(e) {
+      var r = [/\b(?:async|sync|yield)\*/, /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/], s = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, t = {
+        pattern: RegExp(s + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+        lookbehind: !0,
+        inside: {
+          namespace: {
+            pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+            inside: {
+              punctuation: /\./
+            }
+          }
+        }
+      };
+      e.languages.dart = e.languages.extend("clike", {
+        "class-name": [t, {
+          // variables and parameters
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(s + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source),
+          lookbehind: !0,
+          inside: t.inside
+        }],
+        keyword: r,
+        operator: /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+      }), e.languages.insertBefore("dart", "string", {
+        "string-literal": {
+          pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+              lookbehind: !0,
+              inside: {
+                punctuation: /^\$\{?|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: e.languages.dart
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        string: void 0
+      }), e.languages.insertBefore("dart", "class-name", {
+        metadata: {
+          pattern: /@\w+/,
+          alias: "function"
+        }
+      }), e.languages.insertBefore("dart", "class-name", {
+        generics: {
+          pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+          inside: {
+            "class-name": t,
+            keyword: r,
+            punctuation: /[<>(),.:]/,
+            operator: /[?&|]/
+          }
+        }
+      });
+    })(o);
+  }
+  return n;
+}
+export {
+  d as __require
+};

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

@@ -0,0 +1,49 @@
+var t, a;
+function u() {
+  if (a)
+    return t;
+  a = 1, t = e, e.displayName = "dataweave", e.aliases = [];
+  function e(r) {
+    (function(n) {
+      n.languages.dataweave = {
+        url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+        property: {
+          pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+          greedy: !0
+        },
+        string: {
+          pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: !0
+        },
+        "mime-type": /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+        date: {
+          pattern: /\|[\w:+-]+\|/,
+          greedy: !0
+        },
+        comment: [{
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          greedy: !0
+        }, {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }],
+        regex: {
+          pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+          greedy: !0
+        },
+        keyword: /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+        function: /\b[A-Z_]\w*(?=\s*\()/i,
+        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        punctuation: /[{}[\];(),.:@]/,
+        operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+        boolean: /\b(?:false|true)\b/
+      };
+    })(r);
+  }
+  return t;
+}
+export {
+  u as __require
+};

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

@@ -0,0 +1,39 @@
+var T, A;
+function R() {
+  if (A)
+    return T;
+  A = 1, T = E, E.displayName = "dax", E.aliases = [];
+  function E(N) {
+    N.languages.dax = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
+        lookbehind: !0
+      },
+      "data-field": {
+        pattern: /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
+        alias: "symbol"
+      },
+      measure: {
+        pattern: /\[[ \w\xA0-\uFFFF]+\]/,
+        alias: "constant"
+      },
+      string: {
+        pattern: /"(?:[^"]|"")*"(?!")/,
+        greedy: !0
+      },
+      function: /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
+      keyword: /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
+      boolean: {
+        pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
+        alias: "constant"
+      },
+      number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
+      operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
+      punctuation: /[;\[\](){}`,.]/
+    };
+  }
+  return T;
+}
+export {
+  R as __require
+};

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

@@ -0,0 +1,74 @@
+var n, t;
+function i() {
+  if (t)
+    return n;
+  t = 1, n = e, e.displayName = "dhall", e.aliases = [];
+  function e(a) {
+    a.languages.dhall = {
+      // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+      // The multi-line pattern is essentially this:
+      //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+      comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+      string: {
+        pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /\$\{[^{}]*\}/,
+            inside: {
+              expression: {
+                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                lookbehind: !0,
+                alias: "language-dhall",
+                inside: null
+                // see blow
+              },
+              punctuation: /\$\{|\}/
+            }
+          }
+        }
+      },
+      label: {
+        pattern: /`[^`]*`/,
+        greedy: !0
+      },
+      url: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+        pattern: /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+        greedy: !0
+      },
+      env: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+        pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+        greedy: !0,
+        inside: {
+          function: /^env/,
+          operator: /^:/,
+          variable: /[\s\S]+/
+        }
+      },
+      hash: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+        pattern: /\bsha256:[\da-fA-F]{64}\b/,
+        inside: {
+          function: /sha256/,
+          operator: /:/,
+          number: /[\da-fA-F]{64}/
+        }
+      },
+      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+      keyword: /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+      builtin: /\b(?:None|Some)\b/,
+      boolean: /\b(?:False|True)\b/,
+      number: /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+      operator: /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+      punctuation: /\.\.|[{}\[\](),./]/,
+      // we'll just assume that every capital word left is a type name
+      "class-name": /\b[A-Z]\w*\b/
+    }, a.languages.dhall.string.inside.interpolation.inside.expression.inside = a.languages.dhall;
+  }
+  return n;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,54 @@
+var n, d;
+function u() {
+  if (d)
+    return n;
+  d = 1, n = i, i.displayName = "diff", i.aliases = [];
+  function i(t) {
+    (function(f) {
+      f.languages.diff = {
+        coord: [
+          // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
+          /^(?:\*{3}|-{3}|\+{3}).*$/m,
+          // Match "@@ ... @@" coord lines in unified diff.
+          /^@@.*@@$/m,
+          // Match coord lines in normal diff (starts with a number).
+          /^\d.*$/m
+        ]
+        // deleted, inserted, unchanged, diff
+      };
+      var r = {
+        "deleted-sign": "-",
+        "deleted-arrow": "<",
+        "inserted-sign": "+",
+        "inserted-arrow": ">",
+        unchanged: " ",
+        diff: "!"
+      };
+      Object.keys(r).forEach(function(e) {
+        var s = r[e], a = [];
+        /^\w+$/.test(e) || a.push(/\w+/.exec(e)[0]), e === "diff" && a.push("bold"), f.languages.diff[e] = {
+          pattern: RegExp("^(?:[" + s + `].*(?:\r
+?|
+|(?![\\s\\S])))+`, "m"),
+          alias: a,
+          inside: {
+            line: {
+              pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
+              lookbehind: !0
+            },
+            prefix: {
+              pattern: /[\s\S]/,
+              alias: /\w+/.exec(e)[0]
+            }
+          }
+        };
+      }), Object.defineProperty(f.languages.diff, "PREFIXES", {
+        value: r
+      });
+    })(t);
+  }
+  return n;
+}
+export {
+  u as __require
+};