@kong-ui-public/document-viewer 0.10.20 → 0.10.22

package/dist/prism-core.min-2ef141a5.js

@@ -1,271 +0,0 @@
-import { g as X, c as I } from "./index-c5fb19c8.js";
-function Y(y, A) {
-  for (var x = 0; x < A.length; x++) {
-    const u = A[x];
-    if (typeof u != "string" && !Array.isArray(u)) {
-      for (const p in u)
-        if (p !== "default" && !(p in y)) {
-          const k = Object.getOwnPropertyDescriptor(u, p);
-          k && Object.defineProperty(y, p, k.get ? k : {
-            enumerable: !0,
-            get: () => u[p]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(y, Symbol.toStringTag, { value: "Module" }));
-}
-var B = { exports: {} };
-(function(y) {
-  var A = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {}, x = function(u) {
-    var p = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, k = 0, _ = {}, i = { manual: u.Prism && u.Prism.manual, disableWorkerMessageHandler: u.Prism && u.Prism.disableWorkerMessageHandler, util: { encode: function r(e) {
-      return e instanceof m ? new m(e.type, r(e.content), e.alias) : Array.isArray(e) ? e.map(r) : e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
-    }, type: function(r) {
-      return Object.prototype.toString.call(r).slice(8, -1);
-    }, objId: function(r) {
-      return r.__id || Object.defineProperty(r, "__id", { value: ++k }), r.__id;
-    }, clone: function r(e, a) {
-      var t, n;
-      switch (a = a || {}, i.util.type(e)) {
-        case "Object":
-          if (n = i.util.objId(e), a[n])
-            return a[n];
-          for (var l in t = {}, a[n] = t, e)
-            e.hasOwnProperty(l) && (t[l] = r(e[l], a));
-          return t;
-        case "Array":
-          return n = i.util.objId(e), a[n] ? a[n] : (t = [], a[n] = t, e.forEach(function(o, s) {
-            t[s] = r(o, a);
-          }), t);
-        default:
-          return e;
-      }
-    }, getLanguage: function(r) {
-      for (; r; ) {
-        var e = p.exec(r.className);
-        if (e)
-          return e[1].toLowerCase();
-        r = r.parentElement;
-      }
-      return "none";
-    }, setLanguage: function(r, e) {
-      r.className = r.className.replace(RegExp(p, "gi"), ""), r.classList.add("language-" + e);
-    }, currentScript: function() {
-      if (typeof document > "u")
-        return null;
-      if ("currentScript" in document)
-        return document.currentScript;
-      try {
-        throw new Error();
-      } catch (t) {
-        var r = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(t.stack) || [])[1];
-        if (r) {
-          var e = document.getElementsByTagName("script");
-          for (var a in e)
-            if (e[a].src == r)
-              return e[a];
-        }
-        return null;
-      }
-    }, isActive: function(r, e, a) {
-      for (var t = "no-" + e; r; ) {
-        var n = r.classList;
-        if (n.contains(e))
-          return !0;
-        if (n.contains(t))
-          return !1;
-        r = r.parentElement;
-      }
-      return !!a;
-    } }, languages: { plain: _, plaintext: _, text: _, txt: _, extend: function(r, e) {
-      var a = i.util.clone(i.languages[r]);
-      for (var t in e)
-        a[t] = e[t];
-      return a;
-    }, insertBefore: function(r, e, a, t) {
-      var n = (t = t || i.languages)[r], l = {};
-      for (var o in n)
-        if (n.hasOwnProperty(o)) {
-          if (o == e)
-            for (var s in a)
-              a.hasOwnProperty(s) && (l[s] = a[s]);
-          a.hasOwnProperty(o) || (l[o] = n[o]);
-        }
-      var g = t[r];
-      return t[r] = l, i.languages.DFS(i.languages, function(c, S) {
-        S === g && c != r && (this[c] = l);
-      }), l;
-    }, DFS: function r(e, a, t, n) {
-      n = n || {};
-      var l = i.util.objId;
-      for (var o in e)
-        if (e.hasOwnProperty(o)) {
-          a.call(e, o, e[o], t || o);
-          var s = e[o], g = i.util.type(s);
-          g !== "Object" || n[l(s)] ? g !== "Array" || n[l(s)] || (n[l(s)] = !0, r(s, a, o, n)) : (n[l(s)] = !0, r(s, a, null, n));
-        }
-    } }, plugins: {}, highlightAll: function(r, e) {
-      i.highlightAllUnder(document, r, e);
-    }, highlightAllUnder: function(r, e, a) {
-      var t = { callback: a, container: r, selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code' };
-      i.hooks.run("before-highlightall", t), t.elements = Array.prototype.slice.apply(t.container.querySelectorAll(t.selector)), i.hooks.run("before-all-elements-highlight", t);
-      for (var n, l = 0; n = t.elements[l++]; )
-        i.highlightElement(n, e === !0, t.callback);
-    }, highlightElement: function(r, e, a) {
-      var t = i.util.getLanguage(r), n = i.languages[t];
-      i.util.setLanguage(r, t);
-      var l = r.parentElement;
-      l && l.nodeName.toLowerCase() === "pre" && i.util.setLanguage(l, t);
-      var o = { element: r, language: t, grammar: n, code: r.textContent };
-      function s(c) {
-        o.highlightedCode = c, i.hooks.run("before-insert", o), o.element.innerHTML = o.highlightedCode, i.hooks.run("after-highlight", o), i.hooks.run("complete", o), a && a.call(o.element);
-      }
-      if (i.hooks.run("before-sanity-check", o), (l = o.element.parentElement) && l.nodeName.toLowerCase() === "pre" && !l.hasAttribute("tabindex") && l.setAttribute("tabindex", "0"), !o.code)
-        return i.hooks.run("complete", o), void (a && a.call(o.element));
-      if (i.hooks.run("before-highlight", o), o.grammar)
-        if (e && u.Worker) {
-          var g = new Worker(i.filename);
-          g.onmessage = function(c) {
-            s(c.data);
-          }, g.postMessage(JSON.stringify({ language: o.language, code: o.code, immediateClose: !0 }));
-        } else
-          s(i.highlight(o.code, o.grammar, o.language));
-      else
-        s(i.util.encode(o.code));
-    }, highlight: function(r, e, a) {
-      var t = { code: r, grammar: e, language: a };
-      if (i.hooks.run("before-tokenize", t), !t.grammar)
-        throw new Error('The language "' + t.language + '" has no grammar.');
-      return t.tokens = i.tokenize(t.code, t.grammar), i.hooks.run("after-tokenize", t), m.stringify(i.util.encode(t.tokens), t.language);
-    }, tokenize: function(r, e) {
-      var a = e.rest;
-      if (a) {
-        for (var t in a)
-          e[t] = a[t];
-        delete e.rest;
-      }
-      var n = new R();
-      return E(n, n.head, r), W(r, n, e, n.head, 0), function(l) {
-        for (var o = [], s = l.head.next; s !== l.tail; )
-          o.push(s.value), s = s.next;
-        return o;
-      }(n);
-    }, hooks: { all: {}, add: function(r, e) {
-      var a = i.hooks.all;
-      a[r] = a[r] || [], a[r].push(e);
-    }, run: function(r, e) {
-      var a = i.hooks.all[r];
-      if (a && a.length)
-        for (var t, n = 0; t = a[n++]; )
-          t(e);
-    } }, Token: m };
-    function m(r, e, a, t) {
-      this.type = r, this.content = e, this.alias = a, this.length = 0 | (t || "").length;
-    }
-    function F(r, e, a, t) {
-      r.lastIndex = e;
-      var n = r.exec(a);
-      if (n && t && n[1]) {
-        var l = n[1].length;
-        n.index += l, n[0] = n[0].slice(l);
-      }
-      return n;
-    }
-    function W(r, e, a, t, n, l) {
-      for (var o in a)
-        if (a.hasOwnProperty(o) && a[o]) {
-          var s = a[o];
-          s = Array.isArray(s) ? s : [s];
-          for (var g = 0; g < s.length; ++g) {
-            if (l && l.cause == o + "," + g)
-              return;
-            var c = s[g], S = c.inside, q = !!c.lookbehind, H = !!c.greedy, K = c.alias;
-            if (H && !c.pattern.global) {
-              var Q = c.pattern.toString().match(/[imsuy]*$/)[0];
-              c.pattern = RegExp(c.pattern.source, Q + "g");
-            }
-            for (var z = c.pattern || c, f = t.next, h = n; f !== e.tail && !(l && h >= l.reach); h += f.value.length, f = f.next) {
-              var b = f.value;
-              if (e.length > r.length)
-                return;
-              if (!(b instanceof m)) {
-                var d, L = 1;
-                if (H) {
-                  if (!(d = F(z, h, r, q)) || d.index >= r.length)
-                    break;
-                  var C = d.index, V = d.index + d[0].length, v = h;
-                  for (v += f.value.length; C >= v; )
-                    v += (f = f.next).value.length;
-                  if (h = v -= f.value.length, f.value instanceof m)
-                    continue;
-                  for (var w = f; w !== e.tail && (v < V || typeof w.value == "string"); w = w.next)
-                    L++, v += w.value.length;
-                  L--, b = r.slice(h, v), d.index -= h;
-                } else if (!(d = F(z, 0, b, q)))
-                  continue;
-                C = d.index;
-                var j = d[0], N = b.slice(0, C), G = b.slice(C + j.length), T = h + b.length;
-                l && T > l.reach && (l.reach = T);
-                var P = f.prev;
-                if (N && (P = E(e, P, N), h += N.length), U(e, P, L), f = E(e, P, new m(o, S ? i.tokenize(j, S) : j, K, j)), G && E(e, f, G), L > 1) {
-                  var D = { cause: o + "," + g, reach: T };
-                  W(r, e, a, f.prev, h, D), l && D.reach > l.reach && (l.reach = D.reach);
-                }
-              }
-            }
-          }
-        }
-    }
-    function R() {
-      var r = { value: null, prev: null, next: null }, e = { value: null, prev: r, next: null };
-      r.next = e, this.head = r, this.tail = e, this.length = 0;
-    }
-    function E(r, e, a) {
-      var t = e.next, n = { value: a, prev: e, next: t };
-      return e.next = n, t.prev = n, r.length++, n;
-    }
-    function U(r, e, a) {
-      for (var t = e.next, n = 0; n < a && t !== r.tail; n++)
-        t = t.next;
-      e.next = t, t.prev = e, r.length -= n;
-    }
-    if (u.Prism = i, m.stringify = function r(e, a) {
-      if (typeof e == "string")
-        return e;
-      if (Array.isArray(e)) {
-        var t = "";
-        return e.forEach(function(g) {
-          t += r(g, a);
-        }), t;
-      }
-      var n = { type: e.type, content: r(e.content, a), tag: "span", classes: ["token", e.type], attributes: {}, language: a }, l = e.alias;
-      l && (Array.isArray(l) ? Array.prototype.push.apply(n.classes, l) : n.classes.push(l)), i.hooks.run("wrap", n);
-      var o = "";
-      for (var s in n.attributes)
-        o += " " + s + '="' + (n.attributes[s] || "").replace(/"/g, "&quot;") + '"';
-      return "<" + n.tag + ' class="' + n.classes.join(" ") + '"' + o + ">" + n.content + "</" + n.tag + ">";
-    }, !u.document)
-      return u.addEventListener && (i.disableWorkerMessageHandler || u.addEventListener("message", function(r) {
-        var e = JSON.parse(r.data), a = e.language, t = e.code, n = e.immediateClose;
-        u.postMessage(i.highlight(t, i.languages[a], a)), n && u.close();
-      }, !1)), i;
-    var O = i.util.currentScript();
-    function M() {
-      i.manual || i.highlightAll();
-    }
-    if (O && (i.filename = O.src, O.hasAttribute("data-manual") && (i.manual = !0)), !i.manual) {
-      var $ = document.readyState;
-      $ === "loading" || $ === "interactive" && O && O.defer ? document.addEventListener("DOMContentLoaded", M) : window.requestAnimationFrame ? window.requestAnimationFrame(M) : window.setTimeout(M, 16);
-    }
-    return i;
-  }(A);
-  y.exports && (y.exports = x), typeof I < "u" && (I.Prism = x);
-})(B);
-var J = B.exports;
-const Z = /* @__PURE__ */ X(J), re = /* @__PURE__ */ Y({
-  __proto__: null,
-  default: Z
-}, [J]);
-export {
-  re as p
-};

package/dist/prism-cpp.min-ac230d87.js

@@ -1,13 +0,0 @@
-(function(e) {
-  var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, n = "\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b".replace(/<keyword>/g, function() {
-    return t.source;
-  });
-  e.languages.cpp = e.languages.extend("c", { "class-name": [{ pattern: RegExp("(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+".replace(/<keyword>/g, function() {
-    return t.source;
-  })), lookbehind: !0 }, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/], keyword: t, number: { pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i, greedy: !0 }, operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, boolean: /\b(?:false|true)\b/ }), e.languages.insertBefore("cpp", "string", { module: { pattern: RegExp(`(\\b(?:import|module)\\s+)(?:"(?:\\\\(?:\r
-|[^])|[^"\\\\\r
-])*"|<[^<>\r
-]*>|` + "<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>".replace(/<mod-name>/g, function() {
-    return n;
-  }) + ")"), lookbehind: !0, greedy: !0, inside: { string: /^[<"][\s\S]+/, operator: /:/, punctuation: /\./ } }, "raw-string": { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: "string", greedy: !0 } }), e.languages.insertBefore("cpp", "keyword", { "generic-function": { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { function: /^\w+/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: e.languages.cpp } } } }), e.languages.insertBefore("cpp", "operator", { "double-colon": { pattern: /::/, alias: "punctuation" } }), e.languages.insertBefore("cpp", "class-name", { "base-clause": { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: !0, greedy: !0, inside: e.languages.extend("cpp", {}) } }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
-})(Prism);

package/dist/prism-crystal.min-13116708.js

@@ -1,3 +0,0 @@
-(function(e) {
-  e.languages.crystal = e.languages.extend("ruby", { keyword: [/\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/, { pattern: /(\.\s*)(?:is_a|responds_to)\?/, lookbehind: !0 }], number: /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/, operator: [/->/, e.languages.ruby.operator], punctuation: /[(){}[\].,;\\]/ }), e.languages.insertBefore("crystal", "string-literal", { attribute: { pattern: /@\[.*?\]/, inside: { delimiter: { pattern: /^@\[|\]$/, alias: "punctuation" }, attribute: { pattern: /^(\s*)\w+/, lookbehind: !0, alias: "class-name" }, args: { pattern: /\S(?:[\s\S]*\S)?/, inside: e.languages.crystal } } }, expansion: { pattern: /\{(?:\{.*?\}|%.*?%)\}/, inside: { content: { pattern: /^(\{.)[\s\S]+(?=.\}$)/, lookbehind: !0, inside: e.languages.crystal }, delimiter: { pattern: /^\{[\{%]|[\}%]\}$/, alias: "operator" } } }, char: { pattern: /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/, greedy: !0 } });
-})(Prism);

package/dist/prism-csharp.min-2a7aa1d7.js

@@ -1,35 +0,0 @@
-(function(s) {
-  function n(a, o) {
-    return a.replace(/<<(\d+)>>/g, function(p, H) {
-      return "(?:" + o[+H] + ")";
-    });
-  }
-  function e(a, o, p) {
-    return RegExp(n(a, o), p || "");
-  }
-  function d(a, o) {
-    for (var p = 0; p < o; p++)
-      a = a.replace(/<<self>>/g, function() {
-        return "(?:" + a + ")";
-      });
-    return a.replace(/<<self>>/g, "[^\\s\\S]");
-  }
-  var w = "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void", c = "class enum interface record struct", v = "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)", m = "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";
-  function u(a) {
-    return "\\b(?:" + a.trim().replace(/ /g, "|") + ")\\b";
-  }
-  var x = u(c), g = RegExp(u(w + " " + c + " " + v + " " + m)), U = u(c + " " + v + " " + m), Z = u(w + " " + c + " " + m), b = d("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2), h = d("\\((?:[^()]|<<self>>)*\\)", 2), r = "@?\\b[A-Za-z_]\\w*\\b", f = n("<<0>>(?:\\s*<<1>>)?", [r, b]), i = n("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [U, f]), k = "\\[\\s*(?:,\\s*)*\\]", q = n("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [i, k]), C = n("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [b, h, k]), D = n("\\(<<0>>+(?:,<<0>>+)+\\)", [C]), l = n("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [D, i, k]), t = { keyword: g, punctuation: /[<>()?,.:[\]]/ }, $ = `'(?:[^\r
-'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'`, _ = `"(?:\\\\.|[^\\\\"\r
-])*"`;
-  s.languages.csharp = s.languages.extend("clike", { string: [{ pattern: e("(^|[^$\\\\])<<0>>", ['@"(?:""|\\\\[^]|[^\\\\"])*"(?!")']), lookbehind: !0, greedy: !0 }, { pattern: e("(^|[^@$\\\\])<<0>>", [_]), lookbehind: !0, greedy: !0 }], "class-name": [{ pattern: e("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [r, l]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+)<<0>>(?=\\s*=)", [r]), lookbehind: !0 }, { pattern: e("(\\b<<0>>\\s+)<<1>>", [x, f]), lookbehind: !0, inside: t }, { pattern: e("(\\bcatch\\s*\\(\\s*)<<0>>", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\bwhere\\s+)<<0>>", [r]), lookbehind: !0 }, { pattern: e("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [q]), lookbehind: !0, inside: t }, { pattern: e("\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))", [l, Z, r]), inside: t }], keyword: g, number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i, operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/, punctuation: /\?\.?|::|[{}[\];(),.:]/ }), s.languages.insertBefore("csharp", "number", { range: { pattern: /\.\./, alias: "operator" } }), s.languages.insertBefore("csharp", "punctuation", { "named-parameter": { pattern: e("([(,]\\s*)<<0>>(?=\\s*:)", [r]), lookbehind: !0, alias: "punctuation" } }), s.languages.insertBefore("csharp", "class-name", { namespace: { pattern: e("(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])", [r]), lookbehind: !0, inside: { punctuation: /\./ } }, "type-expression": { pattern: e("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))", [h]), lookbehind: !0, alias: "class-name", inside: t }, "return-type": { pattern: e("<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [l, i]), inside: t, alias: "class-name" }, "constructor-invocation": { pattern: e("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [l]), lookbehind: !0, inside: t, alias: "class-name" }, "generic-method": { pattern: e("<<0>>\\s*<<1>>(?=\\s*\\()", [r, b]), inside: { function: e("^<<0>>", [r]), generic: { pattern: RegExp(b), alias: "class-name", inside: t } } }, "type-list": { pattern: e("\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))", [x, f, r, l, g.source, h, "\\bnew\\s*\\(\\s*\\)"]), lookbehind: !0, inside: { "record-arguments": { pattern: e("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [f, h]), lookbehind: !0, greedy: !0, inside: s.languages.csharp }, keyword: g, "class-name": { pattern: RegExp(l), greedy: !0, inside: t }, punctuation: /[,()]/ } }, preprocessor: { pattern: /(^[\t ]*)#.*/m, lookbehind: !0, alias: "property", inside: { directive: { pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/, lookbehind: !0, alias: "keyword" } } } });
-  var B = _ + "|" + $, E = n(`/(?![*/])|//[^\r
-]*[\r
-]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>`, [B]), R = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), z = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", G = n("<<0>>(?:\\s*\\(<<1>>*\\))?", [i, R]);
-  s.languages.insertBefore("csharp", "class-name", { attribute: { pattern: e("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])", [z, G]), lookbehind: !0, greedy: !0, inside: { target: { pattern: e("^<<0>>(?=\\s*:)", [z]), alias: "keyword" }, "attribute-arguments": { pattern: e("\\(<<0>>*\\)", [R]), inside: s.languages.csharp }, "class-name": { pattern: RegExp(i), inside: { punctuation: /\./ } }, punctuation: /[:,]/ } } });
-  var y = `:[^}\r
-]+`, S = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), j = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [S, y]), A = d(n(`[^"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)`, [B]), 2), F = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [A, y]);
-  function P(a, o) {
-    return { interpolation: { pattern: e("((?:^|[^{])(?:\\{\\{)*)<<0>>", [a]), lookbehind: !0, inside: { "format-string": { pattern: e("(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)", [o, y]), lookbehind: !0, inside: { punctuation: /^:/ } }, punctuation: /^\{|\}$/, expression: { pattern: /[\s\S]+/, alias: "language-csharp", inside: s.languages.csharp } } }, string: /[\s\S]+/ };
-  }
-  s.languages.insertBefore("csharp", "string", { "interpolation-string": [{ pattern: e('(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"', [j]), lookbehind: !0, greedy: !0, inside: P(j, S) }, { pattern: e('(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"', [F]), lookbehind: !0, greedy: !0, inside: P(F, A) }], char: { pattern: RegExp($), greedy: !0 } }), s.languages.dotnet = s.languages.cs = s.languages.csharp;
-})(Prism);

package/dist/prism-cshtml.min-e0dea03d.js

@@ -1,16 +0,0 @@
-(function(e) {
-  function t(n, m) {
-    for (var p = 0; p < m; p++)
-      n = n.replace(/<self>/g, function() {
-        return "(?:" + n + ")";
-      });
-    return n.replace(/<self>/g, "[^\\s\\S]").replace(/<str>/g, `(?:@(?!")|"(?:[^\r
-\\\\"]|\\\\.)*"|@"(?:[^\\\\"]|""|\\\\[^])*"(?!")|'(?:(?:[^\r
-'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'|(?=[^\\\\](?!'))))`).replace(/<comment>/g, `(?:/(?![/*])|//.*[\r
-]|/\\*[^*]*(?:\\*(?!/)[^*]*)*\\*/)`);
-  }
-  var a = t(`\\((?:[^()'"@/]|<str>|<comment>|<self>)*\\)`, 2), u = t(`\\[(?:[^\\[\\]'"@/]|<str>|<comment>|<self>)*\\]`, 1), s = t(`\\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\\}`, 2), g = "@(?:await\\b\\s*)?(?:(?!await\\b)\\w+\\b|" + a + ")(?:[?!]?\\.\\w+\\b|(?:" + t(`<(?:[^<>'"@/]|<comment>|<self>)*>`, 1) + ")?" + a + "|" + u + ")*(?![?!\\.(\\[]|<(?!/))", o = `(?:"[^"@]*"|'[^'@]*'|[^\\s'"@>=]+(?=[\\s>])|["'][^"'@]*(?:(?:@(?![\\w()])|` + g + `)[^"'@]*)+["'])`, l = "(?:\\s(?:\\s*[^\\s>/=]+(?:\\s*=\\s*<tagAttrValue>|(?=[\\s/>])))+)?".replace(/<tagAttrValue>/, o), r = "(?!\\d)[^\\s>/=$<%]+" + l + "\\s*/?>", d = "\\B@?(?:<([a-zA-Z][\\w:]*)" + l + "\\s*>(?:[^<]|</?(?!\\1\\b)" + r + "|" + t("<\\1" + l + "\\s*>(?:[^<]|</?(?!\\1\\b)" + r + "|<self>)*</\\1\\s*>", 2) + ")*</\\1\\s*>|<" + r + ")";
-  e.languages.cshtml = e.languages.extend("markup", {});
-  var i = { pattern: /\S[\s\S]*/, alias: "language-csharp", inside: e.languages.insertBefore("csharp", "string", { html: { pattern: RegExp(d), greedy: !0, inside: e.languages.cshtml } }, { csharp: e.languages.extend("csharp", {}) }) }, c = { pattern: RegExp("(^|[^@])" + g), lookbehind: !0, greedy: !0, alias: "variable", inside: { keyword: /^@/, csharp: i } };
-  e.languages.cshtml.tag.pattern = RegExp("</?" + r), e.languages.cshtml.tag.inside["attr-value"].pattern = RegExp("=\\s*" + o), e.languages.insertBefore("inside", "punctuation", { value: c }, e.languages.cshtml.tag.inside["attr-value"]), e.languages.insertBefore("cshtml", "prolog", { "razor-comment": { pattern: /@\*[\s\S]*?\*@/, greedy: !0, alias: "comment" }, block: { pattern: RegExp("(^|[^@])@(?:" + [s, "(?:code|functions)\\s*" + s, "(?:for|foreach|lock|switch|using|while)\\s*" + a + "\\s*" + s, "do\\s*" + s + "\\s*while\\s*" + a + "(?:\\s*;)?", "try\\s*" + s + "\\s*catch\\s*" + a + "\\s*" + s + "\\s*finally\\s*" + s, "if\\s*" + a + "\\s*" + s + "(?:\\s*else(?:\\s+if\\s*" + a + ")?\\s*" + s + ")*", "helper\\s+\\w+\\s*" + a + "\\s*" + s].join("|") + ")"), lookbehind: !0, greedy: !0, inside: { keyword: /^@\w*/, csharp: i } }, directive: { pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m, lookbehind: !0, greedy: !0, inside: { keyword: /^@\w+/, csharp: i } }, value: c, "delegate-operator": { pattern: /(^|[^@])@(?=<)/, lookbehind: !0, alias: "operator" } }), e.languages.razor = e.languages.cshtml;
-})(Prism);

package/dist/prism-csp.min-9632aa13.js

@@ -1,6 +0,0 @@
-(function(n) {
-  function e(t) {
-    return RegExp("([ 	])(?:" + t + ")(?=[\\s;]|$)", "i");
-  }
-  n.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.+-]*:"), lookbehind: !0 }, none: { pattern: e("'none'"), lookbehind: !0, alias: "keyword" }, nonce: { pattern: e("'nonce-[-+/\\w=]+'"), lookbehind: !0, alias: "number" }, hash: { pattern: e("'sha(?:256|384|512)-[-+/\\w=]+'"), lookbehind: !0, alias: "number" }, host: { pattern: e("[a-z][a-z0-9.+-]*://[^\\s;,']*|\\*[^\\s;,']*|[a-z0-9-]+(?:\\.[a-z0-9-]+)+(?::[\\d*]+)?(?:/[^\\s;,']*)?"), lookbehind: !0, alias: "url", inside: { important: /\*/ } }, keyword: [{ pattern: e("'unsafe-[a-z-]+'"), lookbehind: !0, alias: "unsafe" }, { pattern: e("'[a-z-]+'"), lookbehind: !0, alias: "safe" }], punctuation: /;/ };
-})(Prism);

package/dist/prism-css-extras.min-b8bed0b9.js

@@ -1,6 +0,0 @@
-(function(e) {
-  var a, n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
-  e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: !0, inside: a = { "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: />|\+|~|\|\|/, punctuation: /[(),]/ } }, e.languages.css.atrule.inside["selector-function-argument"].inside = a, e.languages.insertBefore("css", "property", { variable: { pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i, lookbehind: !0 } });
-  var r = { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 }, i = { pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/, lookbehind: !0 };
-  e.languages.insertBefore("css", "function", { operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: !0 }, 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|RebeccaPurple|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: r, number: i, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: r, number: i });
-})(Prism);

package/dist/prism-css.min-e38589a9.js

@@ -1,7 +0,0 @@
-(function(s) {
-  var e = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-  s.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp(`@[\\w-](?:[^;{\\s"']|\\s+(?!\\s)|` + e.source + ")*?(?:;|(?=\\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 } } }, url: { pattern: RegExp("\\burl\\((?:" + e.source + `|(?:[^\\\\\r
-()"']|\\\\[^])*)\\)`, "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"));
-})(Prism);

package/dist/prism-csv.min-59c9f7fe.js

@@ -1 +0,0 @@
-Prism.languages.csv = { value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/, punctuation: /,/ };

package/dist/prism-cue.min-a0471d75.js

@@ -1,7 +0,0 @@
-(function(e) {
-  var n = "(?:" + `"""(?:[^\\\\"]|"(?!""\\2)|<esc>)*"""|'''(?:[^\\\\']|'(?!''\\2)|<esc>)*'''|"(?:[^\\\\\r
-"]|"(?!\\2)|<esc>)*"|'(?:[^\\\\\r
-']|'(?!\\2)|<esc>)*'`.replace(/<esc>/g, `\\\\(?:(?!\\2)|\\2(?:[^()\r
-]|\\([^()]*\\)))`) + ")";
-  e.languages.cue = { comment: { pattern: /\/\/.*/, greedy: !0 }, "string-literal": { pattern: RegExp(`(^|[^#"'\\\\])(#*)` + n + `(?!["'])\\2`), lookbehind: !0, greedy: !0, inside: { escape: { pattern: /(?=[\s\S]*["'](#*)$)\\\1(?:U[a-fA-F0-9]{1,8}|u[a-fA-F0-9]{1,4}|x[a-fA-F0-9]{1,2}|\d{2,3}|[^(])/, greedy: !0, alias: "string" }, interpolation: { pattern: /(?=[\s\S]*["'](#*)$)\\\1\([^()]*\)/, greedy: !0, inside: { punctuation: /^\\#*\(|\)$/, expression: { pattern: /[\s\S]+/, inside: null } } }, string: /[\s\S]+/ } }, keyword: { pattern: /(^|[^\w$])(?:for|if|import|in|let|null|package)(?![\w$])/, lookbehind: !0 }, boolean: { pattern: /(^|[^\w$])(?:false|true)(?![\w$])/, lookbehind: !0 }, builtin: { pattern: /(^|[^\w$])(?:bool|bytes|float|float(?:32|64)|u?int(?:8|16|32|64|128)?|number|rune|string)(?![\w$])/, lookbehind: !0 }, attribute: { pattern: /@[\w$]+(?=\s*\()/, alias: "function" }, function: { pattern: /(^|[^\w$])[a-z_$][\w$]*(?=\s*\()/i, lookbehind: !0 }, number: { pattern: /(^|[^\w$.])(?:0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*|(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[eE][+-]?\d+(?:_\d+)*)?(?:[KMGTP]i?)?)(?![\w$])/, lookbehind: !0 }, operator: /\.{3}|_\|_|&&?|\|\|?|[=!]~|[<>=!]=?|[+\-*/?]/, punctuation: /[()[\]{},.:]/ }, e.languages.cue["string-literal"].inside.interpolation.inside.expression.inside = e.languages.cue;
-})(Prism);

package/dist/prism-cypher.min-c0e5a4ac.js

@@ -1 +0,0 @@
-Prism.languages.cypher = { 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+/, 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/, operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/, punctuation: /[()[\]{},;.]/ };

package/dist/prism-d.min-fe73d282.js

@@ -1 +0,0 @@
-Prism.languages.d = Prism.languages.extend("clike", { comment: [{ pattern: /^\s*#!.+/, greedy: !0 }, { pattern: RegExp("(^|[^\\\\])(?:" + ["/\\+(?:/\\+(?:[^+]|\\+(?!/))*\\+/|(?!/\\+)[^])*?\\+/", "//.*", "/\\*[^]*?\\*/"].join("|") + ")"), lookbehind: !0, greedy: !0 }], string: [{ pattern: RegExp(['\\b[rx]"(?:\\\\[^]|[^\\\\"])*"[cwd]?', '\\bq"(?:\\[[^]*?\\]|\\([^]*?\\)|<[^]*?>|\\{[^]*?\\})"', '\\bq"((?!\\d)\\w+)$[^]*?^\\1"', '\\bq"(.)[^]*?\\2"', '(["`])(?:\\\\[^]|(?!\\3)[^\\\\])*\\3[cwd]?'].join("|"), "m"), greedy: !0 }, { pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/, greedy: !0, alias: "token-string" }], 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: [/\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|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/ }), Prism.languages.insertBefore("d", "string", { char: /'(?:\\(?:\W|\w+)|[^\\])'/ }), Prism.languages.insertBefore("d", "keyword", { property: /\B@\w*/ }), Prism.languages.insertBefore("d", "function", { register: { 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" } });

package/dist/prism-dart.min-79822d61.js

@@ -1,4 +0,0 @@
-(function(e) {
-  var n = [/\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*)*", a = { pattern: RegExp(s + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"), 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": [a, { pattern: RegExp(s + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])"), lookbehind: !0, inside: a.inside }], keyword: n, 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": a, keyword: n, punctuation: /[<>(),.:]/, operator: /[?&|]/ } } });
-})(Prism);

package/dist/prism-dataweave.min-ac7788bb.js

@@ -1,3 +0,0 @@
-(function(e) {
-  e.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/ };
-})(Prism);

package/dist/prism-dax.min-10526a78.js

@@ -1 +0,0 @@
-Prism.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: /[;\[\](){}`,.]/ };

package/dist/prism-dhall.min-1d8f852b.js

@@ -1 +0,0 @@
-Prism.languages.dhall = { comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/, string: { pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/, greedy: !0, inside: { interpolation: { pattern: /\$\{[^{}]*\}/, inside: { expression: { pattern: /(^\$\{)[\s\S]+(?=\}$)/, lookbehind: !0, alias: "language-dhall", inside: null }, punctuation: /\$\{|\}/ } } } }, label: { pattern: /`[^`]*`/, greedy: !0 }, url: { pattern: /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/, greedy: !0 }, env: { pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/, greedy: !0, inside: { function: /^env/, operator: /^:/, variable: /[\s\S]+/ } }, hash: { pattern: /\bsha256:[\da-fA-F]{64}\b/, inside: { function: /sha256/, operator: /:/, number: /[\da-fA-F]{64}/ } }, 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: /\.\.|[{}\[\](),./]/, "class-name": /\b[A-Z]\w*\b/ }, Prism.languages.dhall.string.inside.interpolation.inside.expression.inside = Prism.languages.dhall;

package/dist/prism-diff.min-58a65b3c.js

@@ -1,10 +0,0 @@
-(function(n) {
-  n.languages.diff = { coord: [/^(?:\*{3}|-{3}|\+{3}).*$/m, /^@@.*@@$/m, /^\d.*$/m] };
-  var i = { "deleted-sign": "-", "deleted-arrow": "<", "inserted-sign": "+", "inserted-arrow": ">", unchanged: " ", diff: "!" };
-  Object.keys(i).forEach(function(e) {
-    var d = i[e], r = [];
-    /^\w+$/.test(e) || r.push(/\w+/.exec(e)[0]), e === "diff" && r.push("bold"), n.languages.diff[e] = { pattern: RegExp("^(?:[" + d + `].*(?:\r
-?|
-|(?![\\s\\S])))+`, "m"), alias: r, inside: { line: { pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/, lookbehind: !0 }, prefix: { pattern: /[\s\S]/, alias: /\w+/.exec(e)[0] } } };
-  }), Object.defineProperty(n.languages.diff, "PREFIXES", { value: i });
-})(Prism);

package/dist/prism-django.min-966e5f65.js

@@ -1,13 +0,0 @@
-(function(n) {
-  n.languages.django = { comment: /^\{#[\s\S]*?#\}$/, tag: { pattern: /(^\{%[+-]?\s*)\w+/, lookbehind: !0, alias: "keyword" }, delimiter: { pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/, alias: "punctuation" }, string: { pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/, greedy: !0 }, filter: { pattern: /(\|)\w+/, lookbehind: !0, alias: "function" }, test: { pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/, lookbehind: !0, alias: "function" }, function: /\b[a-z_]\w+(?=\s*\()/i, keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/, operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, number: /\b\d+(?:\.\d+)?\b/, boolean: /[Ff]alse|[Nn]one|[Tt]rue/, variable: /\b\w+\b/, punctuation: /[{}[\](),.:;]/ };
-  var e = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g, a = n.languages["markup-templating"];
-  n.hooks.add("before-tokenize", function(o) {
-    a.buildPlaceholders(o, "django", e);
-  }), n.hooks.add("after-tokenize", function(o) {
-    a.tokenizePlaceholders(o, "django");
-  }), n.languages.jinja2 = n.languages.django, n.hooks.add("before-tokenize", function(o) {
-    a.buildPlaceholders(o, "jinja2", e);
-  }), n.hooks.add("after-tokenize", function(o) {
-    a.tokenizePlaceholders(o, "jinja2");
-  });
-})(Prism);

package/dist/prism-dns-zone-file.min-6884205e.js

@@ -1 +0,0 @@
-Prism.languages["dns-zone-file"] = { comment: /;.*/, string: { pattern: /"(?:\\.|[^"\\\r\n])*"/, greedy: !0 }, variable: [{ pattern: /(^\$ORIGIN[ \t]+)\S+/m, lookbehind: !0 }, { pattern: /(^|\s)@(?=\s|$)/, lookbehind: !0 }], keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m, class: { pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/, lookbehind: !0, alias: "keyword" }, type: { pattern: /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/, lookbehind: !0, alias: "keyword" }, punctuation: /[()]/ }, Prism.languages["dns-zone"] = Prism.languages["dns-zone-file"];

package/dist/prism-docker.min-2330af65.js

@@ -1,22 +0,0 @@
-(function(n) {
-  var a = "(?:[ 	]+(?![ 	])(?:<SP_BS>)?|<SP_BS>)".replace(/<SP_BS>/g, function() {
-    return `\\\\[\r
-](?:\\s|\\\\[\r
-]|#.*(?!.))*(?![\\s#]|\\\\[\r
-])`;
-  }), t = `"(?:[^"\\\\\r
-]|\\\\(?:\r
-|[^]))*"|'(?:[^'\\\\\r
-]|\\\\(?:\r
-|[^]))*'`, S = `--[\\w-]+=(?:<STR>|(?!["'])(?:[^\\s\\\\]|\\\\.)+)`.replace(/<STR>/g, function() {
-    return t;
-  }), o = { pattern: RegExp(t), greedy: !0 }, i = { pattern: /(^[ \t]*)#.*/m, lookbehind: !0, greedy: !0 };
-  function e(r, P) {
-    return r = r.replace(/<OPT>/g, function() {
-      return S;
-    }).replace(/<SP>/g, function() {
-      return a;
-    }), RegExp(r, P);
-  }
-  n.languages.docker = { instruction: { pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im, lookbehind: !0, greedy: !0, inside: { options: { pattern: e("(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*", "i"), lookbehind: !0, greedy: !0, inside: { property: { pattern: /(^|\s)--[\w-]+/, lookbehind: !0 }, string: [o, { pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/, lookbehind: !0 }], operator: /\\$/m, punctuation: /=/ } }, keyword: [{ pattern: e("(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b", "i"), lookbehind: !0, greedy: !0 }, { pattern: e("(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ 	\\\\]+<SP>)AS", "i"), lookbehind: !0, greedy: !0 }, { pattern: e("(^ONBUILD<SP>)\\w+", "i"), lookbehind: !0, greedy: !0 }, { pattern: /^\w+/, greedy: !0 }], comment: i, string: o, variable: /\$(?:\w+|\{[^{}"'\\]*\})/, operator: /\\$/m } }, comment: i }, n.languages.dockerfile = n.languages.docker;
-})(Prism);

package/dist/prism-dot.min-b7040a53.js

@@ -1,13 +0,0 @@
-(function(a) {
-  var r = "(?:" + ["[a-zA-Z_\\x80-\\uFFFF][\\w\\x80-\\uFFFF]*", "-?(?:\\.\\d+|\\d+(?:\\.\\d*)?)", '"[^"\\\\]*(?:\\\\[^][^"\\\\]*)*"', `<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>`].join("|") + ")", e = { markup: { pattern: /(^<)[\s\S]+(?=>$)/, lookbehind: !0, alias: ["language-markup", "language-html", "language-xml"], inside: a.languages.markup } };
-  function n(t, i) {
-    return RegExp(t.replace(/<ID>/g, function() {
-      return r;
-    }), i);
-  }
-  a.languages.dot = { comment: { pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m, greedy: !0 }, "graph-name": { pattern: n(`(\\b(?:digraph|graph|subgraph)[ 	\r
-]+)<ID>`, "i"), lookbehind: !0, greedy: !0, alias: "class-name", inside: e }, "attr-value": { pattern: n(`(=[ 	\r
-]*)<ID>`), lookbehind: !0, greedy: !0, inside: e }, "attr-name": { pattern: n(`([\\[;, 	\r
-])<ID>(?=[ 	\r
-]*=)`), lookbehind: !0, greedy: !0, inside: e }, keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i, "compass-point": { pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/, lookbehind: !0, alias: "builtin" }, node: { pattern: n("(^|[^-.\\w\\x80-\\uFFFF\\\\])<ID>"), lookbehind: !0, greedy: !0, inside: e }, operator: /[=:]|-[->]/, punctuation: /[\[\]{};,]/ }, a.languages.gv = a.languages.dot;
-})(Prism);

package/dist/prism-ebnf.min-72a1d666.js

@@ -1 +0,0 @@
-Prism.languages.ebnf = { comment: /\(\*[\s\S]*?\*\)/, string: { pattern: /"[^"\r\n]*"|'[^'\r\n]*'/, greedy: !0 }, special: { pattern: /\?[^?\r\n]*\?/, greedy: !0, alias: "class-name" }, definition: { pattern: /^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im, lookbehind: !0, alias: ["rule", "keyword"] }, rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i, punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/, operator: /[-=|*/!]/ };

package/dist/prism-editorconfig.min-f0a114f7.js

@@ -1 +0,0 @@
-Prism.languages.editorconfig = { comment: /[;#].*/, section: { pattern: /(^[ \t]*)\[.+\]/m, lookbehind: !0, alias: "selector", inside: { regex: /\\\\[\[\]{},!?.*]/, operator: /[!?]|\.\.|\*{1,2}/, punctuation: /[\[\]{},]/ } }, key: { pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m, lookbehind: !0, alias: "attr-name" }, value: { pattern: /=.*/, alias: "attr-value", inside: { punctuation: /^=/ } } };

package/dist/prism-eiffel.min-49594bdc.js

@@ -1 +0,0 @@
-Prism.languages.eiffel = { comment: /--.*/, string: [{ pattern: /"([^[]*)\[[\s\S]*?\]\1"/, greedy: !0 }, { pattern: /"([^{]*)\{[\s\S]*?\}\1"/, greedy: !0 }, { pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/, greedy: !0 }], char: /'(?:%.|[^%'\r\n])+'/, keyword: /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i, boolean: /\b(?:False|True)\b/i, "class-name": /\b[A-Z][\dA-Z_]*\b/, number: [/\b0[xcb][\da-f](?:_*[\da-f])*\b/i, /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i], punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/, operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/ };

package/dist/prism-ejs.min-a2f2c9ea.js

@@ -1,7 +0,0 @@
-(function(e) {
-  e.languages.ejs = { delimiter: { pattern: /^<%[-_=]?|[-_]?%>$/, alias: "punctuation" }, comment: /^#[\s\S]*/, "language-javascript": { pattern: /[\s\S]+/, inside: e.languages.javascript } }, e.hooks.add("before-tokenize", function(a) {
-    e.languages["markup-templating"].buildPlaceholders(a, "ejs", /<%(?!%)[\s\S]+?%>/g);
-  }), e.hooks.add("after-tokenize", function(a) {
-    e.languages["markup-templating"].tokenizePlaceholders(a, "ejs");
-  }), e.languages.eta = e.languages.ejs;
-})(Prism);

package/dist/prism-elixir.min-ba69265c.js

@@ -1,3 +0,0 @@
-Prism.languages.elixir = { doc: { pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/, inside: { attribute: /^@\w+/, string: /['"][\s\S]+/ } }, comment: { pattern: /#.*/, greedy: !0 }, regex: { pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/, greedy: !0 }, string: [{ pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/, greedy: !0, inside: {} }, { pattern: /("""|''')[\s\S]*?\1/, greedy: !0, inside: {} }, { pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: !0, inside: {} }], atom: { pattern: /(^|[^:]):\w+/, lookbehind: !0, alias: "symbol" }, module: { pattern: /\b[A-Z]\w*\b/, alias: "class-name" }, "attr-name": /\b\w+\??:(?!:)/, argument: { pattern: /(^|[^&])&\d+/, lookbehind: !0, alias: "variable" }, attribute: { pattern: /@\w+/, alias: "variable" }, function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/, number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i, keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/, boolean: /\b(?:false|nil|true)\b/, operator: [/\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/, { pattern: /([^<])<(?!<)/, lookbehind: !0 }, { pattern: /([^>])>(?!>)/, lookbehind: !0 }], punctuation: /<<|>>|[.,%\[\]{}()]/ }, Prism.languages.elixir.string.forEach(function(e) {
-  e.inside = { interpolation: { pattern: /#\{[^}]+\}/, inside: { delimiter: { pattern: /^#\{|\}$/, alias: "punctuation" }, rest: Prism.languages.elixir } } };
-});

package/dist/prism-elm.min-3290c07f.js

@@ -1 +0,0 @@
-Prism.languages.elm = { comment: /--.*|\{-[\s\S]*?-\}/, char: { pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/, greedy: !0 }, string: [{ pattern: /"""[\s\S]*?"""/, greedy: !0 }, { pattern: /"(?:[^\\"\r\n]|\\.)*"/, greedy: !0 }], "import-statement": { pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m, lookbehind: !0, inside: { keyword: /\b(?:as|exposing|import)\b/ } }, keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/, builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/, number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i, operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/, hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/, constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/, punctuation: /[{}[\]|(),.:]/ };

package/dist/prism-erb.min-51922f18.js

@@ -1,7 +0,0 @@
-(function(n) {
-  n.languages.erb = { delimiter: { pattern: /^(\s*)<%=?|%>(?=\s*$)/, lookbehind: !0, alias: "punctuation" }, ruby: { pattern: /\s*\S[\s\S]*/, alias: "language-ruby", inside: n.languages.ruby } }, n.hooks.add("before-tokenize", function(e) {
-    n.languages["markup-templating"].buildPlaceholders(e, "erb", /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g);
-  }), n.hooks.add("after-tokenize", function(e) {
-    n.languages["markup-templating"].tokenizePlaceholders(e, "erb");
-  });
-})(Prism);

package/dist/prism-erlang.min-1847c6a7.js

@@ -1 +0,0 @@
-Prism.languages.erlang = { comment: /%.+/, string: { pattern: /"(?:\\.|[^\\"\r\n])*"/, greedy: !0 }, "quoted-function": { pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/, alias: "function" }, "quoted-atom": { pattern: /'(?:\\.|[^\\'\r\n])+'/, alias: "atom" }, boolean: /\b(?:false|true)\b/, keyword: /\b(?:after|begin|case|catch|end|fun|if|of|receive|try|when)\b/, number: [/\$\\?./, /\b\d+#[a-z0-9]+/i, /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i], function: /\b[a-z][\w@]*(?=\()/, variable: { pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/, lookbehind: !0 }, operator: [/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/, { pattern: /(^|[^<])<(?!<)/, lookbehind: !0 }, { pattern: /(^|[^>])>(?!>)/, lookbehind: !0 }], atom: /\b[a-z][\w@]*/, punctuation: /[()[\]{}:;,.#|]|<<|>>/ };

package/dist/prism-etlua.min-d9358902.js

@@ -1,7 +0,0 @@
-(function(e) {
-  e.languages.etlua = { delimiter: { pattern: /^<%[-=]?|-?%>$/, alias: "punctuation" }, "language-lua": { pattern: /[\s\S]+/, inside: e.languages.lua } }, e.hooks.add("before-tokenize", function(a) {
-    e.languages["markup-templating"].buildPlaceholders(a, "etlua", /<%[\s\S]+?%>/g);
-  }), e.hooks.add("after-tokenize", function(a) {
-    e.languages["markup-templating"].tokenizePlaceholders(a, "etlua");
-  });
-})(Prism);

package/dist/prism-excel-formula.min-0e717178.js

@@ -1 +0,0 @@
-Prism.languages["excel-formula"] = { comment: { pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i, lookbehind: !0, greedy: !0 }, string: { pattern: /"(?:[^"]|"")*"(?!")/, greedy: !0 }, reference: { pattern: /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/, greedy: !0, alias: "string", inside: { operator: /!$/, punctuation: /'/, sheet: { pattern: /[^[\]]+$/, alias: "function" }, file: { pattern: /\[[^[\]]+\]$/, inside: { punctuation: /[[\]]/ } }, path: /[\s\S]+/ } }, "function-name": { pattern: /\b[A-Z]\w*(?=\()/i, alias: "builtin" }, range: { pattern: /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i, alias: "selector", inside: { operator: /:/, cell: /\$?[A-Z]+\$?\d+/i, column: /\$?[A-Z]+/i, row: /\$?\d+/ } }, cell: { pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/, alias: "selector" }, number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i, boolean: /\b(?:FALSE|TRUE)\b/i, operator: /[-+*/^%=&,]|<[=>]?|>=?/, punctuation: /[[\]();{}|]/ }, Prism.languages.xlsx = Prism.languages.xls = Prism.languages["excel-formula"];