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

package/dist/prism-js-templates.min-c950373d.js

@@ -1,83 +0,0 @@
-(function(a) {
-  var y = a.languages.javascript["template-string"], q = y.pattern.source, d = y.inside.interpolation, w = d.inside["interpolation-punctuation"], O = d.pattern.source;
-  function v(t, r) {
-    if (a.languages[t])
-      return { pattern: RegExp("((?:" + r + ")\\s*)" + q), lookbehind: !0, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: t } } };
-  }
-  function T(t, r) {
-    return "___" + r.toUpperCase() + "_" + t + "___";
-  }
-  function A(t, r, e) {
-    var n = { code: t, grammar: r, language: e };
-    return a.hooks.run("before-tokenize", n), n.tokens = a.tokenize(n.code, n.grammar), a.hooks.run("after-tokenize", n), n.tokens;
-  }
-  function E(t) {
-    var r = {};
-    r["interpolation-punctuation"] = w;
-    var e = a.tokenize(t, r);
-    if (e.length === 3) {
-      var n = [1, 1];
-      n.push.apply(n, A(e[1], a.languages.javascript, "javascript")), e.splice.apply(e, n);
-    }
-    return new a.Token("interpolation", e, d.alias, t);
-  }
-  function R(t, r, e) {
-    var n = a.tokenize(t, { interpolation: { pattern: RegExp(O), lookbehind: !0 } }), g = 0, u = {}, o = A(n.map(function(l) {
-      if (typeof l == "string")
-        return l;
-      for (var i, p = l.content; t.indexOf(i = T(g++, e)) !== -1; )
-        ;
-      return u[i] = p, i;
-    }).join(""), r, e), c = Object.keys(u);
-    return g = 0, function l(i) {
-      for (var p = 0; p < i.length; p++) {
-        if (g >= c.length)
-          return;
-        var s = i[p];
-        if (typeof s == "string" || typeof s.content == "string") {
-          var k = c[g], m = typeof s == "string" ? s : s.content, b = m.indexOf(k);
-          if (b !== -1) {
-            ++g;
-            var x = m.substring(0, b), B = E(u[k]), _ = m.substring(b + k.length), f = [];
-            if (x && f.push(x), f.push(B), _) {
-              var z = [_];
-              l(z), f.push.apply(f, z);
-            }
-            typeof s == "string" ? (i.splice.apply(i, [p, 1].concat(f)), p += f.length - 1) : s.content = f;
-          }
-        } else {
-          var j = s.content;
-          Array.isArray(j) ? l(j) : l([j]);
-        }
-      }
-    }(o), new a.Token(e, o, "language-" + e, t);
-  }
-  a.languages.javascript["template-string"] = [v("css", "\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)"), v("html", "\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?="), v("svg", "\\bsvg"), v("markdown", "\\b(?:markdown|md)"), v("graphql", "\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)"), v("sql", "\\bsql"), y].filter(Boolean);
-  var S = { javascript: !0, js: !0, typescript: !0, ts: !0, jsx: !0, tsx: !0 };
-  function h(t) {
-    return typeof t == "string" ? t : Array.isArray(t) ? t.map(h).join("") : h(t.content);
-  }
-  a.hooks.add("after-tokenize", function(t) {
-    t.language in S && function r(e) {
-      for (var n = 0, g = e.length; n < g; n++) {
-        var u = e[n];
-        if (typeof u != "string") {
-          var o = u.content;
-          if (Array.isArray(o))
-            if (u.type === "template-string") {
-              var c = o[1];
-              if (o.length === 3 && typeof c != "string" && c.type === "embedded-code") {
-                var l = h(c), i = c.alias, p = Array.isArray(i) ? i[0] : i, s = a.languages[p];
-                if (!s)
-                  continue;
-                o[1] = R(l, s, p);
-              }
-            } else
-              r(o);
-          else
-            typeof o != "string" && r([o]);
-        }
-      }
-    }(t.tokens);
-  });
-})(Prism);

package/dist/prism-jsdoc.min-02975619.js

@@ -1,6 +0,0 @@
-(function(e) {
-  var a = e.languages.javascript, n = "\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})+\\}", t = "(@(?:arg|argument|param|property)\\s+(?:" + n + "\\s+)?)";
-  e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: { pattern: RegExp(t + "(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?=\\s|$)"), lookbehind: !0, inside: { punctuation: /\./ } } }), e.languages.insertBefore("jsdoc", "keyword", { "optional-parameter": { pattern: RegExp(t + "\\[(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?:=[^[\\]]+)?\\](?=\\s|$)"), lookbehind: !0, inside: { parameter: { pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/, lookbehind: !0, inside: { punctuation: /\./ } }, code: { pattern: /(=)[\s\S]*(?=\]$)/, lookbehind: !0, inside: a, alias: "language-javascript" }, punctuation: /[=[\]]/ } }, "class-name": [{ pattern: RegExp("(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\\s+(?:<TYPE>\\s+)?)[A-Z]\\w*(?:\\.[A-Z]\\w*)*".replace(/<TYPE>/g, function() {
-    return n;
-  })), lookbehind: !0, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + n), lookbehind: !0, inside: { string: a.string, number: a.number, boolean: a.boolean, keyword: e.languages.typescript.keyword, operator: /=>|\.\.\.|[&|?:*]/, punctuation: /[.,;=<>{}()[\]]/ } }], example: { pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, lookbehind: !0, inside: { code: { pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, lookbehind: !0, inside: a, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
-})(Prism);

package/dist/prism-json.min-fa2dced5.js

@@ -1 +0,0 @@
-Prism.languages.json = { property: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/, lookbehind: !0, greedy: !0 }, string: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/, lookbehind: !0, greedy: !0 }, comment: { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 }, number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, punctuation: /[{}[\],]/, operator: /:/, boolean: /\b(?:false|true)\b/, null: { pattern: /\bnull\b/, alias: "keyword" } }, Prism.languages.webmanifest = Prism.languages.json;

package/dist/prism-json5.min-3917dd44.js

@@ -1,4 +0,0 @@
-(function(e) {
-  var n = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
-  e.languages.json5 = e.languages.extend("json", { property: [{ pattern: RegExp(n.source + "(?=\\s*:)"), greedy: !0 }, { pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/, alias: "unquoted" }], string: { pattern: n, greedy: !0 }, number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/ });
-})(Prism);

package/dist/prism-jsonp.min-a0f4106e.js

@@ -1 +0,0 @@
-Prism.languages.jsonp = Prism.languages.extend("json", { punctuation: /[{}[\]();,.]/ }), Prism.languages.insertBefore("jsonp", "punctuation", { function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/ });

package/dist/prism-jsstacktrace.min-bc3f3759.js

@@ -1 +0,0 @@
-Prism.languages.jsstacktrace = { "error-message": { pattern: /^\S.*/m, alias: "string" }, "stack-frame": { pattern: /(^[ \t]+)at[ \t].*/m, lookbehind: !0, inside: { "not-my-code": { pattern: /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m, alias: "comment" }, filename: { pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/, lookbehind: !0, alias: "url" }, function: { pattern: /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/, lookbehind: !0, inside: { punctuation: /\./ } }, punctuation: /[()]/, keyword: /\b(?:at|new)\b/, alias: { pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/, alias: "variable" }, "line-number": { pattern: /:\d+(?::\d+)?\b/, alias: "number", inside: { punctuation: /:/ } } } } };

package/dist/prism-jsx.min-8af1efbf.js

@@ -1,28 +0,0 @@
-(function(a) {
-  var p = a.util.clone(a.languages.javascript), r = "(?:\\{<S>*\\.{3}(?:[^{}]|<BRACES>)*\\})";
-  function c(n, e) {
-    return n = n.replace(/<S>/g, function() {
-      return "(?:\\s|//.*(?!.)|/\\*(?:[^*]|\\*(?!/))\\*/)";
-    }).replace(/<BRACES>/g, function() {
-      return "(?:\\{(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])*\\})";
-    }).replace(/<SPREAD>/g, function() {
-      return r;
-    }), RegExp(n, e);
-  }
-  r = c(r).source, a.languages.jsx = a.languages.extend("markup", p), a.languages.jsx.tag.pattern = c(`</?(?:[\\w.:-]+(?:<S>+(?:[\\w.:$-]+(?:=(?:"(?:\\\\[^]|[^\\\\"])*"|'(?:\\\\[^]|[^\\\\'])*'|[^\\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*/?)?>`), a.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, a.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, a.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, a.languages.jsx.tag.inside.comment = p.comment, a.languages.insertBefore("inside", "attr-name", { spread: { pattern: c("<SPREAD>"), inside: a.languages.jsx } }, a.languages.jsx.tag), a.languages.insertBefore("inside", "special-attr", { script: { pattern: c("=<BRACES>"), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: a.languages.jsx } } }, a.languages.jsx.tag);
-  var g = function(n) {
-    return n ? typeof n == "string" ? n : typeof n.content == "string" ? n.content : n.content.map(g).join("") : "";
-  }, l = function(n) {
-    for (var e = [], s = 0; s < n.length; s++) {
-      var t = n[s], u = !1;
-      if (typeof t != "string" && (t.type === "tag" && t.content[0] && t.content[0].type === "tag" ? t.content[0].content[0].content === "</" ? e.length > 0 && e[e.length - 1].tagName === g(t.content[0].content[1]) && e.pop() : t.content[t.content.length - 1].content === "/>" || e.push({ tagName: g(t.content[0].content[1]), openedBraces: 0 }) : e.length > 0 && t.type === "punctuation" && t.content === "{" ? e[e.length - 1].openedBraces++ : e.length > 0 && e[e.length - 1].openedBraces > 0 && t.type === "punctuation" && t.content === "}" ? e[e.length - 1].openedBraces-- : u = !0), (u || typeof t == "string") && e.length > 0 && e[e.length - 1].openedBraces === 0) {
-        var i = g(t);
-        s < n.length - 1 && (typeof n[s + 1] == "string" || n[s + 1].type === "plain-text") && (i += g(n[s + 1]), n.splice(s + 1, 1)), s > 0 && (typeof n[s - 1] == "string" || n[s - 1].type === "plain-text") && (i = g(n[s - 1]) + i, n.splice(s - 1, 1), s--), n[s] = new a.Token("plain-text", i, null, i);
-      }
-      t.content && typeof t.content != "string" && l(t.content);
-    }
-  };
-  a.hooks.add("after-tokenize", function(n) {
-    n.language !== "jsx" && n.language !== "tsx" || l(n.tokens);
-  });
-})(Prism);

package/dist/prism-julia.min-cc71d15e.js

@@ -1 +0,0 @@
-Prism.languages.julia = { comment: { pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/, lookbehind: !0 }, regex: { pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/, greedy: !0 }, string: { pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/, greedy: !0 }, char: { pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/, lookbehind: !0, greedy: !0 }, keyword: /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/, boolean: /\b(?:false|true)\b/, number: /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i, operator: /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/, punctuation: /::?|[{}[\]();,.?]/, constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/ };

package/dist/prism-keepalived.min-1428eb2f.js

@@ -1,3 +0,0 @@
-Prism.languages.keepalived = { comment: { pattern: /[#!].*/, greedy: !0 }, string: { pattern: /(^|[^\\])(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, lookbehind: !0, greedy: !0 }, ip: { pattern: RegExp("\\b(?:(?:(?:[\\da-f]{1,4}:){7}[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){6}:[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){5}:(?:[\\da-f]{1,4}:)?[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){4}:(?:[\\da-f]{1,4}:){0,2}[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){3}:(?:[\\da-f]{1,4}:){0,3}[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){2}:(?:[\\da-f]{1,4}:){0,4}[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){6}<ipv4>|(?:[\\da-f]{1,4}:){0,5}:<ipv4>|::(?:[\\da-f]{1,4}:){0,5}<ipv4>|[\\da-f]{1,4}::(?:[\\da-f]{1,4}:){0,5}[\\da-f]{1,4}|::(?:[\\da-f]{1,4}:){0,6}[\\da-f]{1,4}|(?:[\\da-f]{1,4}:){1,7}:)(?:/\\d{1,3})?|<ipv4>(?:/\\d{1,2})?)\\b".replace(/<ipv4>/g, function() {
-  return "(?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d))";
-}), "i"), alias: "number" }, path: { pattern: /(\s)\/(?:[^\/\s]+\/)*[^\/\s]*|\b[a-zA-Z]:\\(?:[^\\\s]+\\)*[^\\\s]*/, lookbehind: !0, alias: "string" }, variable: /\$\{?\w+\}?/, email: { pattern: /[\w-]+@[\w-]+(?:\.[\w-]{2,3}){1,2}/, alias: "string" }, "conditional-configuration": { pattern: /@\^?[\w-]+/, alias: "variable" }, operator: /=/, property: /\b(?:BFD_CHECK|DNS_CHECK|FILE_CHECK|HTTP_GET|MISC_CHECK|NAME|PING_CHECK|SCRIPTS|SMTP_CHECK|SSL|SSL_GET|TCP_CHECK|UDP_CHECK|accept|advert_int|alpha|auth_pass|auth_type|authentication|bfd_cpu_affinity|bfd_instance|bfd_no_swap|bfd_priority|bfd_process_name|bfd_rlimit_rttime|bfd_rt_priority|bind_if|bind_port|bindto|ca|certificate|check_unicast_src|checker|checker_cpu_affinity|checker_log_all_failures|checker_no_swap|checker_priority|checker_rlimit_rttime|checker_rt_priority|child_wait_time|connect_ip|connect_port|connect_timeout|dbus_service_name|debug|default_interface|delay|delay_before_retry|delay_loop|digest|dont_track_primary|dynamic|dynamic_interfaces|enable_(?:dbus|script_security|sni|snmp_checker|snmp_rfc|snmp_rfcv2|snmp_rfcv3|snmp_vrrp|traps)|end|fall|fast_recovery|file|flag-[123]|fork_delay|full_command|fwmark|garp_group|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|global_defs|global_tracking|gna_interval|group|ha_suspend|hashed|helo_name|higher_prio_send_advert|hoplimit|http_protocol|hysteresis|idle_tx|include|inhibit_on_failure|init_fail|init_file|instance|interface|interfaces|interval|ip_family|ipvs_process_name|keepalived.conf|kernel_rx_buf_size|key|linkbeat_interfaces|linkbeat_use_polling|log_all_failures|log_unknown_vrids|lower_prio_no_advert|lthreshold|lvs_flush|lvs_flush_onstop|lvs_method|lvs_netlink_cmd_rcv_bufs|lvs_netlink_cmd_rcv_bufs_force|lvs_netlink_monitor_rcv_bufs|lvs_netlink_monitor_rcv_bufs_force|lvs_notify_fifo|lvs_notify_fifo_script|lvs_sched|lvs_sync_daemon|max_auto_priority|max_hops|mcast_src_ip|mh-fallback|mh-port|min_auto_priority_delay|min_rx|min_tx|misc_dynamic|misc_path|misc_timeout|multiplier|name|namespace_with_ipsets|native_ipv6|neighbor_ip|net_namespace|net_namespace_ipvs|nftables|nftables_counters|nftables_ifindex|nftables_priority|no_accept|no_checker_emails|no_email_faults|nopreempt|notification_email|notification_email_from|notify|notify_backup|notify_deleted|notify_down|notify_fault|notify_fifo|notify_fifo_script|notify_master|notify_master_rx_lower_pri|notify_priority_changes|notify_stop|notify_up|old_unicast_checksum|omega|ops|param_match|passive|password|path|persistence_engine|persistence_granularity|persistence_timeout|preempt|preempt_delay|priority|process|process_monitor_rcv_bufs|process_monitor_rcv_bufs_force|process_name|process_names|promote_secondaries|protocol|proxy_arp|proxy_arp_pvlan|quorum|quorum_down|quorum_max|quorum_up|random_seed|real_server|regex|regex_max_offset|regex_min_offset|regex_no_match|regex_options|regex_stack|reload_repeat|reload_time_file|require_reply|retry|rise|router_id|rs_init_notifies|script|script_user|sh-fallback|sh-port|shutdown_script|shutdown_script_timeout|skip_check_adv_addr|smtp_alert|smtp_alert_checker|smtp_alert_vrrp|smtp_connect_timeout|smtp_helo_name|smtp_server|snmp_socket|sorry_server|sorry_server_inhibit|sorry_server_lvs_method|source_ip|start|startup_script|startup_script_timeout|state|static_ipaddress|static_routes|static_rules|status_code|step|strict_mode|sync_group_tracking_weight|terminate_delay|timeout|track_bfd|track_file|track_group|track_interface|track_process|track_script|track_src_ip|ttl|type|umask|unicast_peer|unicast_src_ip|unicast_ttl|url|use_ipvlan|use_pid_dir|use_vmac|user|uthreshold|val[123]|version|virtual_ipaddress|virtual_ipaddress_excluded|virtual_router_id|virtual_routes|virtual_rules|virtual_server|virtual_server_group|virtualhost|vmac_xmit_base|vrrp|vrrp_(?:check_unicast_src|cpu_affinity|garp_interval|garp_lower_prio_delay|garp_lower_prio_repeat|garp_master_delay|garp_master_refresh|garp_master_refresh_repeat|garp_master_repeat|gna_interval|higher_prio_send_advert|instance|ipsets|iptables|lower_prio_no_advert|mcast_group4|mcast_group6|min_garp|netlink_cmd_rcv_bufs|netlink_cmd_rcv_bufs_force|netlink_monitor_rcv_bufs|netlink_monitor_rcv_bufs_force|no_swap|notify_fifo|notify_fifo_script|notify_priority_changes|priority|process_name|rlimit_rttime|rt_priority|rx_bufs_multiplier|rx_bufs_policy|script|skip_check_adv_addr|startup_delay|strict|sync_group|track_process|version)|warmup|weight)\b/, constant: /\b(?:A|AAAA|AH|BACKUP|CNAME|DR|MASTER|MX|NAT|NS|PASS|SCTP|SOA|TCP|TUN|TXT|UDP|dh|fo|lblc|lblcr|lc|mh|nq|ovf|rr|sed|sh|wlc|wrr)\b/, number: { pattern: /(^|[^\w.-])-?\d+(?:\.\d+)?/, lookbehind: !0 }, boolean: /\b(?:false|no|off|on|true|yes)\b/, punctuation: /[\{\}]/ };

package/dist/prism-keyman.min-3b419e70.js

@@ -1 +0,0 @@
-Prism.languages.keyman = { comment: { pattern: /\bc .*/i, greedy: !0 }, string: { pattern: /"[^"\r\n]*"|'[^'\r\n]*'/, greedy: !0 }, "virtual-key": { pattern: /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i, greedy: !0, alias: "function" }, "header-keyword": { pattern: /&\w+/, alias: "bold" }, "header-statement": { pattern: /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i, alias: "bold" }, "rule-keyword": { pattern: /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i, alias: "keyword" }, "structural-keyword": { pattern: /\b(?:ansi|begin|group|match|newcontext|nomatch|postkeystroke|readonly|unicode|using keys)\b/i, alias: "keyword" }, "compile-target": { pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i, alias: "property" }, number: /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i, operator: /[+>\\$]|\.\./, punctuation: /[()=,]/ };

package/dist/prism-kotlin.min-ecbf8553.js

@@ -1,5 +0,0 @@
-(function(e) {
-  e.languages.kotlin = e.languages.extend("clike", { keyword: { pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/, lookbehind: !0 }, function: [{ pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: !0 }, { pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/, lookbehind: !0, greedy: !0 }], number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/, operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/ }), delete e.languages.kotlin["class-name"];
-  var n = { "interpolation-punctuation": { pattern: /^\$\{?|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: e.languages.kotlin } };
-  e.languages.insertBefore("kotlin", "string", { "string-literal": [{ pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, alias: "multiline", inside: { interpolation: { pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, inside: n }, string: /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: "singleline", inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: !0, inside: n }, string: /[\s\S]+/ } }], char: { pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, greedy: !0 } }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", { annotation: { pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, alias: "builtin" } }), e.languages.insertBefore("kotlin", "function", { label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" } }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
-})(Prism);

package/dist/prism-kumir.min-624860b6.js

@@ -1,6 +0,0 @@
-(function(o) {
-  function n(e, a) {
-    return RegExp(e.replace(/<nonId>/g, "\\s\\x00-\\x1f\\x22-\\x2f\\x3a-\\x3f\\x5b-\\x5e\\x60\\x7b-\\x7e"), a);
-  }
-  o.languages.kumir = { comment: { pattern: /\|.*/ }, prolog: { pattern: /#.*/, greedy: !0 }, string: { pattern: /"[^\n\r"]*"|'[^\n\r']*'/, greedy: !0 }, boolean: { pattern: n("(^|[<nonId>])(?:да|нет)(?=[<nonId>]|$)"), lookbehind: !0 }, "operator-word": { pattern: n("(^|[<nonId>])(?:и|или|не)(?=[<nonId>]|$)"), lookbehind: !0, alias: "keyword" }, "system-variable": { pattern: n("(^|[<nonId>])знач(?=[<nonId>]|$)"), lookbehind: !0, alias: "keyword" }, type: [{ pattern: n("(^|[<nonId>])(?:вещ|лит|лог|сим|цел)(?:\\x20*таб)?(?=[<nonId>]|$)"), lookbehind: !0, alias: "builtin" }, { pattern: n("(^|[<nonId>])(?:компл|сканкод|файл|цвет)(?=[<nonId>]|$)"), lookbehind: !0, alias: "important" }], keyword: { pattern: n("(^|[<nonId>])(?:алг|арг(?:\\x20*рез)?|ввод|ВКЛЮЧИТЬ|вс[её]|выбор|вывод|выход|дано|для|до|дс|если|иначе|исп|использовать|кон(?:(?:\\x20+|_)исп)?|кц(?:(?:\\x20+|_)при)?|надо|нач|нс|нц|от|пауза|пока|при|раза?|рез|стоп|таб|то|утв|шаг)(?=[<nonId>]|$)"), lookbehind: !0 }, name: { pattern: n("(^|[<nonId>])[^\\d<nonId>][^<nonId>]*(?:\\x20+[^<nonId>]+)*(?=[<nonId>]|$)"), lookbehind: !0 }, number: { pattern: n("(^|[<nonId>])(?:\\B\\$[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)(?=[<nonId>]|$)", "i"), lookbehind: !0 }, punctuation: /:=|[(),:;\[\]]/, "operator-char": { pattern: /\*\*?|<[=>]?|>=?|[-+/=]/, alias: "operator" } }, o.languages.kum = o.languages.kumir;
-})(Prism);

package/dist/prism-kusto.min-67b0f58b.js

@@ -1 +0,0 @@
-Prism.languages.kusto = { comment: { pattern: /\/\/.*/, greedy: !0 }, string: { pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/, greedy: !0 }, verb: { pattern: /(\|\s*)[a-z][\w-]*/i, lookbehind: !0, alias: "keyword" }, command: { pattern: /\.[a-z][a-z\d-]*\b/, alias: "keyword" }, "class-name": /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/, keyword: /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/, boolean: /\b(?:false|null|true)\b/, function: /\b[a-z_]\w*(?=\s*\()/, datetime: [{ pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/, alias: "number" }, { pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/, alias: "number" }], number: /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/, operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./, punctuation: /[()\[\]{},;.:]/ };

package/dist/prism-latex.min-af145af5.js

@@ -1,4 +0,0 @@
-(function(a) {
-  var e = /\\(?:[^a-z()[\]]|[a-z*]+)/i, n = { "equation-command": { pattern: e, alias: "regex" } };
-  a.languages.latex = { comment: /%.*/, cdata: { pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/, lookbehind: !0 }, equation: [{ pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/, inside: n, alias: "string" }, { pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/, lookbehind: !0, inside: n, alias: "string" }], keyword: { pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/, lookbehind: !0 }, url: { pattern: /(\\url\{)[^}]+(?=\})/, lookbehind: !0 }, headline: { pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/, lookbehind: !0, alias: "class-name" }, function: { pattern: e, alias: "selector" }, punctuation: /[[\]{}&]/ }, a.languages.tex = a.languages.latex, a.languages.context = a.languages.latex;
-})(Prism);

package/dist/prism-latte.min-b9a60122.js

@@ -1,9 +0,0 @@
-(function(t) {
-  t.languages.latte = { comment: /^\{\*[\s\S]*/, "latte-tag": { pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i, lookbehind: !0, alias: "important" }, delimiter: { pattern: /^\{\/?|\}$/, alias: "punctuation" }, php: { pattern: /\S(?:[\s\S]*\S)?/, alias: "language-php", inside: t.languages.php } };
-  var e = t.languages.extend("markup", {});
-  t.languages.insertBefore("inside", "attr-value", { "n-attr": { pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/, inside: { "attr-name": { pattern: /^[^\s=]+/, alias: "important" }, "attr-value": { pattern: /=[\s\S]+/, inside: { punctuation: [/^=/, { pattern: /^(\s*)["']|["']$/, lookbehind: !0 }], php: { pattern: /\S(?:[\s\S]*\S)?/, inside: t.languages.php } } } } } }, e.tag), t.hooks.add("before-tokenize", function(a) {
-    a.language === "latte" && (t.languages["markup-templating"].buildPlaceholders(a, "latte", /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g), a.grammar = e);
-  }), t.hooks.add("after-tokenize", function(a) {
-    t.languages["markup-templating"].tokenizePlaceholders(a, "latte");
-  });
-})(Prism);

package/dist/prism-less.min-3a3313ed.js

@@ -1 +0,0 @@
-Prism.languages.less = Prism.languages.extend("css", { comment: [/\/\*[\s\S]*?\*\//, { pattern: /(^|[^\\])\/\/.*/, lookbehind: !0 }], atrule: { pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/, inside: { punctuation: /[:()]/ } }, selector: { pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/, inside: { variable: /@+[\w-]+/ } }, property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/, operator: /[+\-*\/]/ }), Prism.languages.insertBefore("less", "property", { variable: [{ pattern: /@[\w-]+\s*:/, inside: { punctuation: /:/ } }, /@@?[\w-]+/], "mixin-usage": { pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/, lookbehind: !0, alias: "function" } });

package/dist/prism-lilypond.min-b0ed8db8.js

@@ -1,11 +0,0 @@
-(function(n) {
-  for (var e = '\\((?:[^();"#\\\\]|\\\\[^]|;.*(?!.)|"(?:[^"\\\\]|\\\\.)*"|#(?:\\{(?:(?!#\\})[^])*#\\}|[^{])|<expr>)*\\)', i = 0; i < 5; i++)
-    e = e.replace(/<expr>/g, function() {
-      return e;
-    });
-  e = e.replace(/<expr>/g, "[^\\s\\S]");
-  var d = n.languages.lilypond = { comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/, "embedded-scheme": { pattern: RegExp('(^|[=\\s])#(?:"(?:[^"\\\\]|\\\\.)*"|[^\\s()"]*(?:[^\\s()]|<expr>))'.replace(/<expr>/g, function() {
-    return e;
-  }), "m"), lookbehind: !0, greedy: !0, inside: { scheme: { pattern: /^(#)[\s\S]+$/, lookbehind: !0, alias: "language-scheme", inside: { "embedded-lilypond": { pattern: /#\{[\s\S]*?#\}/, greedy: !0, inside: { punctuation: /^#\{|#\}$/, lilypond: { pattern: /[\s\S]+/, alias: "language-lilypond", inside: null } } }, rest: n.languages.scheme } }, punctuation: /#/ } }, string: { pattern: /"(?:[^"\\]|\\.)*"/, greedy: !0 }, "class-name": { pattern: /(\\new\s+)[\w-]+/, lookbehind: !0 }, keyword: { pattern: /\\[a-z][-\w]*/i, inside: { punctuation: /^\\/ } }, operator: /[=|]|<<|>>/, punctuation: { pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/, lookbehind: !0 }, number: /\b\d+(?:\/\d+)?\b/ };
-  d["embedded-scheme"].inside.scheme.inside["embedded-lilypond"].inside.lilypond.inside = d, n.languages.ly = d;
-})(Prism);

package/dist/prism-linker-script.min-dc3fc5ad.js

@@ -1 +0,0 @@
-Prism.languages["linker-script"] = { comment: { pattern: /(^|\s)\/\*[\s\S]*?(?:$|\*\/)/, lookbehind: !0, greedy: !0 }, identifier: { pattern: /"[^"\r\n]*"/, greedy: !0 }, "location-counter": { pattern: /\B\.\B/, alias: "important" }, section: { pattern: /(^|[^\w*])\.\w+\b/, lookbehind: !0, alias: "keyword" }, function: /\b[A-Z][A-Z_]*(?=\s*\()/, number: /\b(?:0[xX][a-fA-F0-9]+|\d+)[KM]?\b/, operator: />>=?|<<=?|->|\+\+|--|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?/, punctuation: /[(){},;]/ }, Prism.languages.ld = Prism.languages["linker-script"];

package/dist/prism-liquid.min-86fa81e6.js

@@ -1,16 +0,0 @@
-Prism.languages.liquid = { comment: { pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/, lookbehind: !0 }, delimiter: { pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/, alias: "punctuation" }, string: { pattern: /"[^"]*"|'[^']*'/, greedy: !0 }, keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/, object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/, function: [{ pattern: /(\|\s*)\w+/, lookbehind: !0, alias: "filter" }, { pattern: /(\.\s*)(?:first|last|size)/, lookbehind: !0 }], boolean: /\b(?:false|nil|true)\b/, range: { pattern: /\.\./, alias: "operator" }, number: /\b\d+(?:\.\d+)?\b/, operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/, punctuation: /[.,\[\]()]/, empty: { pattern: /\bempty\b/, alias: "keyword" } }, Prism.hooks.add("before-tokenize", function(t) {
-  var e = !1;
-  Prism.languages["markup-templating"].buildPlaceholders(t, "liquid", /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g, function(i) {
-    var n = /^\{%-?\s*(\w+)/.exec(i);
-    if (n) {
-      var a = n[1];
-      if (a === "raw" && !e)
-        return e = !0, !0;
-      if (a === "endraw")
-        return e = !1, !0;
-    }
-    return !e;
-  });
-}), Prism.hooks.add("after-tokenize", function(t) {
-  Prism.languages["markup-templating"].tokenizePlaceholders(t, "liquid");
-});

package/dist/prism-lisp.min-cae2f73f.js

@@ -1,10 +0,0 @@
-(function(a) {
-  function o(l) {
-    return RegExp("(\\()(?:" + l + ")(?=[\\s\\)])");
-  }
-  function p(l) {
-    return RegExp("([\\s([])(?:" + l + ")(?=[\\s)])");
-  }
-  var e = "(?!\\d)[-+*/~!@$%^=<>{}\\w]+", d = "(\\()", t = "(?:[^()]|\\((?:[^()]|\\((?:[^()]|\\((?:[^()]|\\((?:[^()]|\\([^()]*\\))*\\))*\\))*\\))*\\))*", n = { heading: { pattern: /;;;.*/, alias: ["comment", "title"] }, comment: /;.*/, string: { pattern: /"(?:[^"\\]|\\.)*"/, greedy: !0, inside: { argument: /[-A-Z]+(?=[.,\s])/, symbol: RegExp("`" + e + "'") } }, "quoted-symbol": { pattern: RegExp("#?'" + e), alias: ["variable", "symbol"] }, "lisp-property": { pattern: RegExp(":" + e), alias: "property" }, splice: { pattern: RegExp(",@?" + e), alias: ["symbol", "variable"] }, keyword: [{ pattern: RegExp("(\\()(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)(?=\\s)"), lookbehind: !0 }, { pattern: RegExp("(\\()(?:append|by|collect|concat|do|finally|for|in|return)(?=\\s)"), lookbehind: !0 }], declare: { pattern: o("declare"), lookbehind: !0, alias: "keyword" }, interactive: { pattern: o("interactive"), lookbehind: !0, alias: "keyword" }, boolean: { pattern: p("nil|t"), lookbehind: !0 }, number: { pattern: p("[-+]?\\d+(?:\\.\\d*)?"), lookbehind: !0 }, defvar: { pattern: RegExp("(\\()def(?:const|custom|group|var)\\s+" + e), lookbehind: !0, inside: { keyword: /^def[a-z]+/, variable: RegExp(e) } }, defun: { pattern: RegExp("(\\()(?:cl-)?(?:defmacro|defun\\*?)\\s+" + e + "\\s+\\(" + t + "\\)"), lookbehind: !0, greedy: !0, inside: { keyword: /^(?:cl-)?def\S+/, arguments: null, function: { pattern: RegExp("(^\\s)" + e), lookbehind: !0 }, punctuation: /[()]/ } }, lambda: { pattern: RegExp("(\\()lambda\\s+\\(\\s*(?:&?" + e + "(?:\\s+&?" + e + ")*\\s*)?\\)"), lookbehind: !0, greedy: !0, inside: { keyword: /^lambda/, arguments: null, punctuation: /[()]/ } }, car: { pattern: RegExp(d + e), lookbehind: !0 }, punctuation: [/(?:['`,]?\(|[)\[\]])/, { pattern: /(\s)\.(?=\s)/, lookbehind: !0 }] }, r = { "lisp-marker": RegExp("&(?!\\d)[-+*/~!@$%^=<>{}\\w]+"), varform: { pattern: RegExp("\\(" + e + "\\s+(?=\\S)" + t + "\\)"), inside: n }, argument: { pattern: RegExp("(^|[\\s(])" + e), lookbehind: !0, alias: "variable" }, rest: n }, i = "\\S+(?:\\s+\\S+)*", s = { pattern: RegExp(d + t + "(?=\\))"), lookbehind: !0, inside: { "rest-vars": { pattern: RegExp("&(?:body|rest)\\s+" + i), inside: r }, "other-marker-vars": { pattern: RegExp("&(?:aux|optional)\\s+" + i), inside: r }, keys: { pattern: RegExp("&key\\s+" + i + "(?:\\s+&allow-other-keys)?"), inside: r }, argument: { pattern: RegExp(e), alias: "variable" }, punctuation: /[()]/ } };
-  n.lambda.inside.arguments = s, n.defun.inside.arguments = a.util.clone(s), n.defun.inside.arguments.inside.sublist = s, a.languages.lisp = n, a.languages.elisp = n, a.languages.emacs = n, a.languages["emacs-lisp"] = n;
-})(Prism);

package/dist/prism-livescript.min-b5d9d700.js

@@ -1 +0,0 @@
-Prism.languages.livescript = { comment: [{ pattern: /(^|[^\\])\/\*[\s\S]*?\*\//, lookbehind: !0 }, { pattern: /(^|[^\\])#.*/, lookbehind: !0 }], "interpolated-string": { pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/, lookbehind: !0, greedy: !0, inside: { variable: { pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m, lookbehind: !0 }, interpolation: { pattern: /(^|[^\\])#\{[^}]+\}/m, lookbehind: !0, inside: { "interpolation-punctuation": { pattern: /^#\{|\}$/, alias: "variable" } } }, string: /[\s\S]+/ } }, string: [{ pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/, greedy: !0 }, { pattern: /<\[[\s\S]*?\]>/, greedy: !0 }, /\\[^\s,;\])}]+/], regex: [{ pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/, greedy: !0, inside: { comment: { pattern: /(^|[^\\])#.*/, lookbehind: !0 } } }, { pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/, greedy: !0 }], keyword: { pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m, lookbehind: !0 }, "keyword-operator": { pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m, lookbehind: !0, alias: "operator" }, boolean: { pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m, lookbehind: !0 }, argument: { pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m, lookbehind: !0, alias: "variable" }, number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i, identifier: /[a-z_](?:-?[a-z]|[\d_])*/i, operator: [{ pattern: /( )\.(?= )/, lookbehind: !0 }, /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/], punctuation: /[(){}\[\]|.,:;`]/ }, Prism.languages.livescript["interpolated-string"].inside.interpolation.inside.rest = Prism.languages.livescript;

package/dist/prism-llvm.min-2b4a3e33.js

@@ -1,3 +0,0 @@
-(function(a) {
-  a.languages.llvm = { comment: /;.*/, string: { pattern: /"[^"]*"/, greedy: !0 }, boolean: /\b(?:false|true)\b/, variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i, label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i, type: { pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/, alias: "class-name" }, keyword: /\b[a-z_][a-z_0-9]*\b/, number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/, punctuation: /[{}[\];(),.!*=<>]/ };
-})(Prism);

package/dist/prism-log.min-e9ba9fa2.js

@@ -1 +0,0 @@
-Prism.languages.log = { string: { pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/, greedy: !0 }, exception: { pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/, lookbehind: !0, greedy: !0, alias: ["javastacktrace", "language-javastacktrace"], inside: Prism.languages.javastacktrace || { keyword: /\bat\b/, function: /[a-z_][\w$]*(?=\()/, punctuation: /[.:()]/ } }, level: [{ pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/, alias: ["error", "important"] }, { pattern: /\b(?:WARN|WARNING|WRN)\b/, alias: ["warning", "important"] }, { pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/, alias: ["info", "keyword"] }, { pattern: /\b(?:DBG|DEBUG|FINE)\b/, alias: ["debug", "keyword"] }, { pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/, alias: ["trace", "comment"] }], property: { pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im, lookbehind: !0 }, separator: { pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m, lookbehind: !0, alias: "comment" }, url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/, email: { pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/, lookbehind: !0, alias: "url" }, "ip-address": { pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/, alias: "constant" }, "mac-address": { pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i, alias: "constant" }, domain: { pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/, lookbehind: !0, alias: "constant" }, uuid: { pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, alias: "constant" }, hash: { pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i, alias: "constant" }, "file-path": { pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i, lookbehind: !0, greedy: !0, alias: "string" }, date: { pattern: RegExp("\\b\\d{4}[-/]\\d{2}[-/]\\d{2}(?:T(?=\\d{1,2}:)|(?=\\s\\d{1,2}:))|\\b\\d{1,4}[-/ ](?:\\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\\d{2,4}T?\\b|\\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\\s{1,2}\\d{1,2}\\b", "i"), alias: "number" }, time: { pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/, alias: "number" }, boolean: /\b(?:false|null|true)\b/i, number: { pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i, lookbehind: !0 }, operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/, punctuation: /[\[\].,]/ };

package/dist/prism-lolcode.min-1d0782a6.js

@@ -1 +0,0 @@
-Prism.languages.lolcode = { comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/], string: { pattern: /"(?::.|[^":])*"/, inside: { variable: /:\{[^}]+\}/, symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/] }, greedy: !0 }, number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/, symbol: { pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/, lookbehind: !0, inside: { keyword: /A(?=\s)/ } }, label: { pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/, lookbehind: !0, alias: "string" }, function: { pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/, lookbehind: !0 }, keyword: [{ pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/, lookbehind: !0 }, /'Z(?=\s|,|$)/], boolean: { pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/, lookbehind: !0 }, variable: { pattern: /(^|\s)IT(?=\s|,|$)/, lookbehind: !0 }, operator: { pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/, lookbehind: !0 }, punctuation: /\.{3}|…|,|!/ };

package/dist/prism-lua.min-9c7e1242.js

@@ -1 +0,0 @@
-Prism.languages.lua = { comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m, string: { pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/, greedy: !0 }, number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i, keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/, function: /(?!\d)\w+(?=\s*(?:[({]))/, operator: [/[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/, { pattern: /(^|[^.])\.\.(?!\.)/, lookbehind: !0 }], punctuation: /[\[\](){},;]|\.+|:+/ };

package/dist/prism-magma.min-6b08ba18.js

@@ -1 +0,0 @@
-Prism.languages.magma = { output: { pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m, lookbehind: !0, greedy: !0 }, comment: { pattern: /\/\/.*|\/\*[\s\S]*?\*\//, greedy: !0 }, string: { pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/, lookbehind: !0, greedy: !0 }, keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/, boolean: /\b(?:false|true)\b/, generator: { pattern: /\b[a-z_]\w*(?=\s*<)/i, alias: "class-name" }, function: /\b[a-z_]\w*(?=\s*\()/i, number: { pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/, lookbehind: !0 }, operator: /->|[-+*/^~!|#=]|:=|\.\./, punctuation: /[()[\]{}<>,;.:]/ };

package/dist/prism-makefile.min-10c204c7.js

@@ -1 +0,0 @@
-Prism.languages.makefile = { comment: { pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/, lookbehind: !0 }, string: { pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: !0 }, "builtin-target": { pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/, alias: "builtin" }, target: { pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m, alias: "symbol", inside: { variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/ } }, variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/, keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/, function: { pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/, lookbehind: !0 }, operator: /(?:::|[?:+!])?=|[|@]/, punctuation: /[:;(){}]/ };

package/dist/prism-markdown.min-2fe85287.js

@@ -1,63 +0,0 @@
-(function(n) {
-  function u(e) {
-    return e = e.replace(/<inner>/g, function() {
-      return `(?:\\\\.|[^\\\\
-\r]|(?:
-|\r
-?)(?![\r
-]))`;
-    }), RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + e + ")");
-  }
-  var g = "(?:\\\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\\\|\r\n`])+", d = `\\|?__(?:\\|__)+\\|?(?:(?:
-|\r
-?)|(?![^]))`.replace(/__/g, function() {
-    return g;
-  }), c = `\\|?[ 	]*:?-{3,}:?[ 	]*(?:\\|[ 	]*:?-{3,}:?[ 	]*)+\\|?(?:
-|\r
-?)`;
-  n.languages.markdown = n.languages.extend("markup", {}), n.languages.insertBefore("markdown", "prolog", { "front-matter-block": { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: !0, greedy: !0, inside: { punctuation: /^---|---$/, "front-matter": { pattern: /\S+(?:\s+\S+)*/, alias: ["yaml", "language-yaml"], inside: n.languages.yaml } } }, blockquote: { pattern: /^>(?:[\t ]*>)*/m, alias: "punctuation" }, table: { pattern: RegExp("^" + d + c + "(?:" + d + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + d + c + ")(?:" + d + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(g), inside: n.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + d + ")" + c + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + d + "$"), inside: { "table-header": { pattern: RegExp(g), alias: "important", inside: n.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: !0, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: !0, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: !0 }, "code-language": { pattern: /^(```).+/, lookbehind: !0 }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: !0, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: !0, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: !0, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: u("\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: u("\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: u("(~~?)(?:(?!~)<inner>)+\\2"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: !0, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: !0, greedy: !0, alias: ["code", "keyword"] }, url: { pattern: u('!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[	 ]+"(?:\\\\.|[^"\\\\])*")?\\)|[ 	]?\\[(?:(?!\\])<inner>)+\\])'), lookbehind: !0, greedy: !0, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: !0, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: !0 }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: !0 } } } }), ["url", "bold", "italic", "strike"].forEach(function(e) {
-    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(t) {
-      e !== t && (n.languages.markdown[e].inside.content.inside[t] = n.languages.markdown[t]);
-    });
-  }), n.hooks.add("after-tokenize", function(e) {
-    e.language !== "markdown" && e.language !== "md" || function t(r) {
-      if (r && typeof r != "string")
-        for (var p = 0, b = r.length; p < b; p++) {
-          var l = r[p];
-          if (l.type === "code") {
-            var s = l.content[1], a = l.content[3];
-            if (s && a && s.type === "code-language" && a.type === "code-block" && typeof s.content == "string") {
-              var o = s.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), i = "language-" + (o = (/[a-z][\w-]*/i.exec(o) || [""])[0].toLowerCase());
-              a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, i] : a.alias.push(i) : a.alias = [i];
-            }
-          } else
-            t(l.content);
-        }
-    }(e.tokens);
-  }), n.hooks.add("wrap", function(e) {
-    if (e.type === "code-block") {
-      for (var t = "", r = 0, p = e.classes.length; r < p; r++) {
-        var b = e.classes[r], l = /language-(.+)/.exec(b);
-        if (l) {
-          t = l[1];
-          break;
-        }
-      }
-      var s = n.languages[t];
-      if (s)
-        e.content = n.highlight(e.content.replace(h, "").replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(o, i) {
-          var k;
-          return (i = i.toLowerCase())[0] === "#" ? (k = i[1] === "x" ? parseInt(i.slice(2), 16) : Number(i.slice(1)), f(k)) : m[i] || o;
-        }), s, t);
-      else if (t && t !== "none" && n.plugins.autoloader) {
-        var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random());
-        e.attributes.id = a, n.plugins.autoloader.loadLanguages(t, function() {
-          var o = document.getElementById(a);
-          o && (o.innerHTML = n.highlight(o.textContent, n.languages[t], t));
-        });
-      }
-    }
-  });
-  var h = RegExp(n.languages.markup.tag.pattern.source, "gi"), m = { amp: "&", lt: "<", gt: ">", quot: '"' }, f = String.fromCodePoint || String.fromCharCode;
-  n.languages.md = n.languages.markdown;
-})(Prism);

package/dist/prism-markup-templating.min-c55d1b76.js

@@ -1,37 +0,0 @@
-(function(u) {
-  function f(n, t) {
-    return "___" + n.toUpperCase() + t + "___";
-  }
-  Object.defineProperties(u.languages["markup-templating"] = {}, { buildPlaceholders: { value: function(n, t, l, i) {
-    if (n.language === t) {
-      var c = n.tokenStack = [];
-      n.code = n.code.replace(l, function(a) {
-        if (typeof i == "function" && !i(a))
-          return a;
-        for (var r, e = c.length; n.code.indexOf(r = f(t, e)) !== -1; )
-          ++e;
-        return c[e] = a, r;
-      }), n.grammar = u.languages.markup;
-    }
-  } }, tokenizePlaceholders: { value: function(n, t) {
-    if (n.language === t && n.tokenStack) {
-      n.grammar = u.languages[t];
-      var l = 0, i = Object.keys(n.tokenStack);
-      (function c(a) {
-        for (var r = 0; r < a.length && !(l >= i.length); r++) {
-          var e = a[r];
-          if (typeof e == "string" || e.content && typeof e.content == "string") {
-            var g = i[l], k = n.tokenStack[g], s = typeof e == "string" ? e : e.content, d = f(t, g), p = s.indexOf(d);
-            if (p > -1) {
-              ++l;
-              var m = s.substring(0, p), h = new u.Token(t, u.tokenize(k, n.grammar), "language-" + t, k), y = s.substring(p + d.length), o = [];
-              m && o.push.apply(o, c([m])), o.push(h), y && o.push.apply(o, c([y])), typeof e == "string" ? a.splice.apply(a, [r, 1].concat(o)) : e.content = o;
-            }
-          } else
-            e.content && c(e.content);
-        }
-        return a;
-      })(n.tokens);
-    }
-  } } });
-})(Prism);

package/dist/prism-markup.min-849389d5.js

@@ -1,14 +0,0 @@
-Prism.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: !0 }, prolog: { pattern: /<\?[\s\S]+?\?>/, greedy: !0 }, doctype: { pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i, greedy: !0, inside: { "internal-subset": { pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, lookbehind: !0, greedy: !0, inside: null }, string: { pattern: /"[^"]*"|'[^']*'/, greedy: !0 }, punctuation: /^<!|>$|[[\]]/, "doctype-tag": /^DOCTYPE/i, name: /[^\s<>'"]+/ } }, cdata: { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, greedy: !0 }, tag: { pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/, greedy: !0, inside: { tag: { pattern: /^<\/?[^\s>\/]+/, inside: { punctuation: /^<\/?/, namespace: /^[^\s>\/:]+:/ } }, "special-attr": [], "attr-value": { pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/, inside: { punctuation: [{ pattern: /^=/, alias: "attr-equals" }, { pattern: /^(\s*)["']|["']$/, lookbehind: !0 }] } }, punctuation: /\/?>/, "attr-name": { pattern: /[^\s>\/]+/, inside: { namespace: /^[^\s>\/:]+:/ } } } }, entity: [{ pattern: /&[\da-z]{1,8};/i, alias: "named-entity" }, /&#x?[\da-f]{1,8};/i] }, Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity, Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup, Prism.hooks.add("wrap", function(a) {
-  a.type === "entity" && (a.attributes.title = a.content.replace(/&amp;/, "&"));
-}), Object.defineProperty(Prism.languages.markup.tag, "addInlined", { value: function(a, e) {
-  var s = {};
-  s["language-" + e] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: !0, inside: Prism.languages[e] }, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
-  var t = { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: s } };
-  t["language-" + e] = { pattern: /[\s\S]+/, inside: Prism.languages[e] };
-  var n = {};
-  n[a] = { pattern: RegExp("(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])*?(?=</__>)".replace(/__/g, function() {
-    return a;
-  }), "i"), lookbehind: !0, greedy: !0, inside: t }, Prism.languages.insertBefore("markup", "cdata", n);
-} }), Object.defineProperty(Prism.languages.markup.tag, "addAttribute", { value: function(a, e) {
-  Prism.languages.markup.tag.inside["special-attr"].push({ pattern: RegExp(`(^|["'\\s])(?:` + a + `)\\s*=\\s*(?:"[^"]*"|'[^']*'|[^\\s'">=]+(?=[\\s>]))`, "i"), lookbehind: !0, inside: { "attr-name": /^[^\s=]+/, "attr-value": { pattern: /=[\s\S]+/, inside: { value: { pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/, lookbehind: !0, alias: [e, "language-" + e], inside: Prism.languages[e] }, punctuation: [{ pattern: /^=/, alias: "attr-equals" }, /"|'/] } } } });
-} }), Prism.languages.html = Prism.languages.markup, Prism.languages.mathml = Prism.languages.markup, Prism.languages.svg = Prism.languages.markup, Prism.languages.xml = Prism.languages.extend("markup", {}), Prism.languages.ssml = Prism.languages.xml, Prism.languages.atom = Prism.languages.xml, Prism.languages.rss = Prism.languages.xml;

package/dist/prism-mata.min-1bbaed90.js

@@ -1,4 +0,0 @@
-(function(e) {
-  var t = "\\bvoid\\b|<org>|\\b(?:complex|numeric|pointer(?:\\s*\\([^()]*\\))?|real|string|(?:class|struct)\\s+\\w+|transmorphic)(?:\\s*<org>)?".replace(/<org>/g, "\\b(?:(?:col|row)?vector|matrix|scalar)\\b");
-  e.languages.mata = { comment: { pattern: /\/\/.*|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//, greedy: !0 }, string: { pattern: /"[^"\r\n]*"|[‘`']".*?"[’`']/, greedy: !0 }, "class-name": { pattern: /(\b(?:class|extends|struct)\s+)\w+(?=\s*(?:\{|\bextends\b))/, lookbehind: !0 }, type: { pattern: RegExp(t), alias: "class-name", inside: { punctuation: /[()]/, keyword: /\b(?:class|function|struct|void)\b/ } }, keyword: /\b(?:break|class|continue|do|else|end|extends|external|final|for|function|goto|if|pragma|private|protected|public|return|static|struct|unset|unused|version|virtual|while)\b/, constant: /\bNULL\b/, number: { pattern: /(^|[^\w.])(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|\d[a-f0-9]*(?:\.[a-f0-9]+)?x[+-]?\d+)i?(?![\w.])/i, lookbehind: !0 }, missing: { pattern: /(^|[^\w.])(?:\.[a-z]?)(?![\w.])/, lookbehind: !0, alias: "symbol" }, function: /\b[a-z_]\w*(?=\s*\()/i, operator: /\.\.|\+\+|--|&&|\|\||:?(?:[!=<>]=|[+\-*/^<>&|:])|[!?=\\#’`']/, punctuation: /[()[\]{},;.]/ };
-})(Prism);

package/dist/prism-matlab.min-c787c897.js

@@ -1 +0,0 @@
-Prism.languages.matlab = { comment: [/%\{[\s\S]*?\}%/, /%.+/], string: { pattern: /\B'(?:''|[^'\r\n])*'/, greedy: !0 }, number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b/, keyword: /\b(?:NaN|break|case|catch|continue|else|elseif|end|for|function|if|inf|otherwise|parfor|pause|pi|return|switch|try|while)\b/, function: /\b(?!\d)\w+(?=\s*\()/, operator: /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/, punctuation: /\.{3}|[.,;\[\](){}!]/ };

package/dist/prism-maxscript.min-8ff24836.js

@@ -1,4 +0,0 @@
-(function(e) {
-  var t = /\b(?:about|and|animate|as|at|attributes|by|case|catch|collect|continue|coordsys|do|else|exit|fn|for|from|function|global|if|in|local|macroscript|mapped|max|not|of|off|on|or|parameters|persistent|plugin|rcmenu|return|rollout|set|struct|then|throw|to|tool|try|undo|utility|when|where|while|with)\b/i;
-  e.languages.maxscript = { comment: { pattern: /\/\*[\s\S]*?(?:\*\/|$)|--.*/, greedy: !0 }, string: { pattern: /(^|[^"\\@])(?:"(?:[^"\\]|\\[\s\S])*"|@"[^"]*")/, lookbehind: !0, greedy: !0 }, path: { pattern: /\$(?:[\w/\\.*?]|'[^']*')*/, greedy: !0, alias: "string" }, "function-call": { pattern: RegExp("((?:^|[;=<>+\\-*/^({\\[]|\\b(?:and|by|case|catch|collect|do|else|if|in|not|or|return|then|to|try|where|while|with)\\b)[ 	]*)(?!" + t.source + ")[a-z_]\\w*\\b(?=[ 	]*(?:(?!" + t.source + `)[a-z_]|\\d|-\\.?\\d|[({'"$@#?]))`, "im"), lookbehind: !0, greedy: !0, alias: "function" }, "function-definition": { pattern: /(\b(?:fn|function)\s+)\w+\b/i, lookbehind: !0, alias: "function" }, argument: { pattern: /\b[a-z_]\w*(?=:)/i, alias: "attr-name" }, keyword: t, boolean: /\b(?:false|true)\b/, time: { pattern: /(^|[^\w.])(?:(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?[msft])+|\d+:\d+(?:\.\d*)?)(?![\w.:])/, lookbehind: !0, alias: "number" }, number: [{ pattern: /(^|[^\w.])(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?|0x[a-fA-F0-9]+)(?![\w.:])/, lookbehind: !0 }, /\b(?:e|pi)\b/], constant: /\b(?:dontcollect|ok|silentValue|undefined|unsupplied)\b/, color: { pattern: /\b(?:black|blue|brown|gray|green|orange|red|white|yellow)\b/i, alias: "constant" }, operator: /[-+*/<>=!]=?|[&^?]|#(?!\()/, punctuation: /[()\[\]{}.:,;]|#(?=\()|\\$/m };
-})(Prism);

package/dist/prism-mel.min-e8ff632f.js

@@ -1 +0,0 @@
-Prism.languages.mel = { comment: { pattern: /\/\/.*|\/\*[\s\S]*?\*\//, greedy: !0 }, code: { pattern: /`(?:\\.|[^\\`])*`/, greedy: !0, alias: "italic", inside: { delimiter: { pattern: /^`|`$/, alias: "punctuation" }, statement: { pattern: /[\s\S]+/, inside: null } } }, string: { pattern: /"(?:\\.|[^\\"\r\n])*"/, greedy: !0 }, variable: /\$\w+/, number: /\b0x[\da-fA-F]+\b|\b\d+(?:\.\d*)?|\B\.\d+/, flag: { pattern: /-[^\d\W]\w*/, alias: "operator" }, keyword: /\b(?:break|case|continue|default|do|else|float|for|global|if|in|int|matrix|proc|return|string|switch|vector|while)\b/, function: { pattern: /((?:^|[{;])[ \t]*)[a-z_]\w*\b(?!\s*(?:\.(?!\.)|[[{=]))|\b[a-z_]\w*(?=[ \t]*\()/im, lookbehind: !0, greedy: !0 }, "tensor-punctuation": { pattern: /<<|>>/, alias: "punctuation" }, operator: /\+[+=]?|-[-=]?|&&|\|\||[<>]=?|[*\/!=]=?|[%^]/, punctuation: /[.,:;?\[\](){}]/ }, Prism.languages.mel.code.inside.statement.inside = Prism.languages.mel;

package/dist/prism-mermaid.min-77fee473.js

@@ -1 +0,0 @@
-Prism.languages.mermaid = { comment: { pattern: /%%.*/, greedy: !0 }, style: { pattern: /^([ \t]*(?:classDef|linkStyle|style)[ \t]+[\w$-]+[ \t]+)\w.*[^\s;]/m, lookbehind: !0, inside: { property: /\b\w[\w-]*(?=[ \t]*:)/, operator: /:/, punctuation: /,/ } }, "inter-arrow-label": { pattern: /([^<>ox.=-])(?:-[-.]|==)(?![<>ox.=-])[ \t]*(?:"[^"\r\n]*"|[^\s".=-](?:[^\r\n.=-]*[^\s.=-])?)[ \t]*(?:\.+->?|--+[->]|==+[=>])(?![<>ox.=-])/, lookbehind: !0, greedy: !0, inside: { arrow: { pattern: /(?:\.+->?|--+[->]|==+[=>])$/, alias: "operator" }, label: { pattern: /^([\s\S]{2}[ \t]*)\S(?:[\s\S]*\S)?/, lookbehind: !0, alias: "property" }, "arrow-head": { pattern: /^\S+/, alias: ["arrow", "operator"] } } }, arrow: [{ pattern: /(^|[^{}|o.-])[|}][|o](?:--|\.\.)[|o][|{](?![{}|o.-])/, lookbehind: !0, alias: "operator" }, { pattern: /(^|[^<>ox.=-])(?:[<ox](?:==+|--+|-\.*-)[>ox]?|(?:==+|--+|-\.*-)[>ox]|===+|---+|-\.+-)(?![<>ox.=-])/, lookbehind: !0, alias: "operator" }, { pattern: /(^|[^<>()x-])(?:--?(?:>>|[x>)])(?![<>()x])|(?:<<|[x<(])--?(?!-))/, lookbehind: !0, alias: "operator" }, { pattern: /(^|[^<>|*o.-])(?:[*o]--|--[*o]|<\|?(?:--|\.\.)|(?:--|\.\.)\|?>|--|\.\.)(?![<>|*o.-])/, lookbehind: !0, alias: "operator" }], label: { pattern: /(^|[^|<])\|(?:[^\r\n"|]|"[^"\r\n]*")+\|/, lookbehind: !0, greedy: !0, alias: "property" }, text: { pattern: /(?:[(\[{]+|\b>)(?:[^\r\n"()\[\]{}]|"[^"\r\n]*")+(?:[)\]}]+|>)/, alias: "string" }, string: { pattern: /"[^"\r\n]*"/, greedy: !0 }, annotation: { pattern: /<<(?:abstract|choice|enumeration|fork|interface|join|service)>>|\[\[(?:choice|fork|join)\]\]/i, alias: "important" }, keyword: [{ pattern: /(^[ \t]*)(?:action|callback|class|classDef|classDiagram|click|direction|erDiagram|flowchart|gantt|gitGraph|graph|journey|link|linkStyle|pie|requirementDiagram|sequenceDiagram|stateDiagram|stateDiagram-v2|style|subgraph)(?![\w$-])/m, lookbehind: !0, greedy: !0 }, { pattern: /(^[ \t]*)(?:activate|alt|and|as|autonumber|deactivate|else|end(?:[ \t]+note)?|loop|opt|par|participant|rect|state|note[ \t]+(?:over|(?:left|right)[ \t]+of))(?![\w$-])/im, lookbehind: !0, greedy: !0 }], entity: /#[a-z0-9]+;/, operator: { pattern: /(\w[ \t]*)&(?=[ \t]*\w)|:::|:/, lookbehind: !0 }, punctuation: /[(){};]/ };

package/dist/prism-metafont.min-94223e4b.js

@@ -1 +0,0 @@
-Prism.languages.metafont = { comment: { pattern: /%.*/, greedy: !0 }, string: { pattern: /"[^\r\n"]*"/, greedy: !0 }, number: /\d*\.?\d+/, boolean: /\b(?:false|true)\b/, punctuation: [/[,;()]/, { pattern: /(^|[^{}])(?:\{|\})(?![{}])/, lookbehind: !0 }, { pattern: /(^|[^[])\[(?!\[)/, lookbehind: !0 }, { pattern: /(^|[^\]])\](?!\])/, lookbehind: !0 }], constant: [{ pattern: /(^|[^!?])\?\?\?(?![!?])/, lookbehind: !0 }, { pattern: /(^|[^/*\\])(?:\\|\\\\)(?![/*\\])/, lookbehind: !0 }, /\b(?:_|blankpicture|bp|cc|cm|dd|ditto|down|eps|epsilon|fullcircle|halfcircle|identity|in|infinity|left|mm|nullpen|nullpicture|origin|pc|penrazor|penspeck|pensquare|penstroke|proof|pt|quartercircle|relax|right|smoke|unitpixel|unitsquare|up)\b/], quantity: { pattern: /\b(?:autorounding|blacker|boundarychar|charcode|chardp|chardx|chardy|charext|charht|charic|charwd|currentwindow|day|designsize|displaying|fillin|fontmaking|granularity|hppp|join_radius|month|o_correction|pausing|pen_(?:bot|lft|rt|top)|pixels_per_inch|proofing|showstopping|smoothing|time|tolerance|tracingcapsules|tracingchoices|tracingcommands|tracingedges|tracingequations|tracingmacros|tracingonline|tracingoutput|tracingpens|tracingrestores|tracingspecs|tracingstats|tracingtitles|turningcheck|vppp|warningcheck|xoffset|year|yoffset)\b/, alias: "keyword" }, command: { pattern: /\b(?:addto|batchmode|charlist|cull|display|errhelp|errmessage|errorstopmode|everyjob|extensible|fontdimen|headerbyte|inner|interim|let|ligtable|message|newinternal|nonstopmode|numspecial|openwindow|outer|randomseed|save|scrollmode|shipout|show|showdependencies|showstats|showtoken|showvariable|special)\b/, alias: "builtin" }, operator: [{ pattern: /(^|[^>=<:|])(?:<|<=|=|=:|\|=:|\|=:>|=:\|>|=:\||\|=:\||\|=:\|>|\|=:\|>>|>|>=|:|:=|<>|::|\|\|:)(?![>=<:|])/, lookbehind: !0 }, { pattern: /(^|[^+-])(?:\+|\+\+|-{1,3}|\+-\+)(?![+-])/, lookbehind: !0 }, { pattern: /(^|[^/*\\])(?:\*|\*\*|\/)(?![/*\\])/, lookbehind: !0 }, { pattern: /(^|[^.])(?:\.{2,3})(?!\.)/, lookbehind: !0 }, { pattern: /(^|[^@#&$])&(?![@#&$])/, lookbehind: !0 }, /\b(?:and|not|or)\b/], macro: { pattern: /\b(?:abs|beginchar|bot|byte|capsule_def|ceiling|change_width|clear_pen_memory|clearit|clearpen|clearxy|counterclockwise|cullit|cutdraw|cutoff|decr|define_blacker_pixels|define_corrected_pixels|define_good_x_pixels|define_good_y_pixels|define_horizontal_corrected_pixels|define_pixels|define_whole_blacker_pixels|define_whole_pixels|define_whole_vertical_blacker_pixels|define_whole_vertical_pixels|dir|direction|directionpoint|div|dotprod|downto|draw|drawdot|endchar|erase|fill|filldraw|fix_units|flex|font_coding_scheme|font_extra_space|font_identifier|font_normal_shrink|font_normal_space|font_normal_stretch|font_quad|font_size|font_slant|font_x_height|gfcorners|gobble|gobbled|good\.(?:bot|lft|rt|top|x|y)|grayfont|hide|hround|imagerules|incr|interact|interpath|intersectionpoint|inverse|italcorr|killtext|labelfont|labels|lft|loggingall|lowres_fix|makegrid|makelabel(?:\.(?:bot|lft|rt|top)(?:\.nodot)?)?|max|min|mod|mode_def|mode_setup|nodisplays|notransforms|numtok|openit|penlabels|penpos|pickup|proofoffset|proofrule|proofrulethickness|range|reflectedabout|rotatedabout|rotatedaround|round|rt|savepen|screenchars|screenrule|screenstrokes|shipit|showit|slantfont|softjoin|solve|stop|superellipse|tensepath|thru|titlefont|top|tracingall|tracingnone|undraw|undrawdot|unfill|unfilldraw|upto|vround)\b/, alias: "function" }, builtin: /\b(?:ASCII|angle|char|cosd|decimal|directiontime|floor|hex|intersectiontimes|jobname|known|length|makepath|makepen|mexp|mlog|normaldeviate|oct|odd|pencircle|penoffset|point|postcontrol|precontrol|reverse|rotated|sind|sqrt|str|subpath|substring|totalweight|turningnumber|uniformdeviate|unknown|xpart|xxpart|xypart|ypart|yxpart|yypart)\b/, keyword: /\b(?:also|at|atleast|begingroup|charexists|contour|controls|curl|cycle|def|delimiters|doublepath|dropping|dump|else|elseif|end|enddef|endfor|endgroup|endinput|exitif|exitunless|expandafter|fi|for|forever|forsuffixes|from|if|input|inwindow|keeping|kern|of|primarydef|quote|readstring|scaled|scantokens|secondarydef|shifted|skipto|slanted|step|tension|tertiarydef|to|transformed|until|vardef|withpen|withweight|xscaled|yscaled|zscaled)\b/, type: { pattern: /\b(?:boolean|expr|numeric|pair|path|pen|picture|primary|secondary|string|suffix|tertiary|text|transform)\b/, alias: "property" }, variable: { pattern: /(^|[^@#&$])(?:@#|#@|#|@)(?![@#&$])|\b(?:aspect_ratio|currentpen|currentpicture|currenttransform|d|extra_beginchar|extra_endchar|extra_setup|h|localfont|mag|mode|screen_cols|screen_rows|w|whatever|x|y|z)\b/, lookbehind: !0 } };

package/dist/prism-mizar.min-50230be0.js

@@ -1 +0,0 @@
-Prism.languages.mizar = { comment: /::.+/, keyword: /@proof\b|\b(?:according|aggregate|all|and|antonym|are|as|associativity|assume|asymmetry|attr|be|begin|being|by|canceled|case|cases|clusters?|coherence|commutativity|compatibility|connectedness|consider|consistency|constructors|contradiction|correctness|def|deffunc|define|definitions?|defpred|do|does|end|environ|equals|ex|exactly|existence|for|from|func|given|hence|hereby|holds|idempotence|identity|iff?|implies|involutiveness|irreflexivity|is|it|let|means|mode|non|not|notations?|now|of|or|otherwise|over|per|pred|prefix|projectivity|proof|provided|qua|reconsider|redefine|reduce|reducibility|reflexivity|registrations?|requirements|reserve|sch|schemes?|section|selector|set|sethood|st|struct|such|suppose|symmetry|synonym|take|that|the|then|theorems?|thesis|thus|to|transitivity|uniqueness|vocabular(?:ies|y)|when|where|with|wrt)\b/, parameter: { pattern: /\$(?:10|\d)/, alias: "variable" }, variable: /\b\w+(?=:)/, number: /(?:\b|-)\d+\b/, operator: /\.\.\.|->|&|\.?=/, punctuation: /\(#|#\)|[,:;\[\](){}]/ };

package/dist/prism-mongodb.min-9790bcfd.js

@@ -1,6 +0,0 @@
-(function($) {
-  var e = ["$eq", "$gt", "$gte", "$in", "$lt", "$lte", "$ne", "$nin", "$and", "$not", "$nor", "$or", "$exists", "$type", "$expr", "$jsonSchema", "$mod", "$regex", "$text", "$where", "$geoIntersects", "$geoWithin", "$near", "$nearSphere", "$all", "$elemMatch", "$size", "$bitsAllClear", "$bitsAllSet", "$bitsAnyClear", "$bitsAnySet", "$comment", "$elemMatch", "$meta", "$slice", "$currentDate", "$inc", "$min", "$max", "$mul", "$rename", "$set", "$setOnInsert", "$unset", "$addToSet", "$pop", "$pull", "$push", "$pullAll", "$each", "$position", "$slice", "$sort", "$bit", "$addFields", "$bucket", "$bucketAuto", "$collStats", "$count", "$currentOp", "$facet", "$geoNear", "$graphLookup", "$group", "$indexStats", "$limit", "$listLocalSessions", "$listSessions", "$lookup", "$match", "$merge", "$out", "$planCacheStats", "$project", "$redact", "$replaceRoot", "$replaceWith", "$sample", "$set", "$skip", "$sort", "$sortByCount", "$unionWith", "$unset", "$unwind", "$setWindowFields", "$abs", "$accumulator", "$acos", "$acosh", "$add", "$addToSet", "$allElementsTrue", "$and", "$anyElementTrue", "$arrayElemAt", "$arrayToObject", "$asin", "$asinh", "$atan", "$atan2", "$atanh", "$avg", "$binarySize", "$bsonSize", "$ceil", "$cmp", "$concat", "$concatArrays", "$cond", "$convert", "$cos", "$dateFromParts", "$dateToParts", "$dateFromString", "$dateToString", "$dayOfMonth", "$dayOfWeek", "$dayOfYear", "$degreesToRadians", "$divide", "$eq", "$exp", "$filter", "$first", "$floor", "$function", "$gt", "$gte", "$hour", "$ifNull", "$in", "$indexOfArray", "$indexOfBytes", "$indexOfCP", "$isArray", "$isNumber", "$isoDayOfWeek", "$isoWeek", "$isoWeekYear", "$last", "$last", "$let", "$literal", "$ln", "$log", "$log10", "$lt", "$lte", "$ltrim", "$map", "$max", "$mergeObjects", "$meta", "$min", "$millisecond", "$minute", "$mod", "$month", "$multiply", "$ne", "$not", "$objectToArray", "$or", "$pow", "$push", "$radiansToDegrees", "$range", "$reduce", "$regexFind", "$regexFindAll", "$regexMatch", "$replaceOne", "$replaceAll", "$reverseArray", "$round", "$rtrim", "$second", "$setDifference", "$setEquals", "$setIntersection", "$setIsSubset", "$setUnion", "$size", "$sin", "$slice", "$split", "$sqrt", "$stdDevPop", "$stdDevSamp", "$strcasecmp", "$strLenBytes", "$strLenCP", "$substr", "$substrBytes", "$substrCP", "$subtract", "$sum", "$switch", "$tan", "$toBool", "$toDate", "$toDecimal", "$toDouble", "$toInt", "$toLong", "$toObjectId", "$toString", "$toLower", "$toUpper", "$trim", "$trunc", "$type", "$week", "$year", "$zip", "$count", "$dateAdd", "$dateDiff", "$dateSubtract", "$dateTrunc", "$getField", "$rand", "$sampleRate", "$setField", "$unsetField", "$comment", "$explain", "$hint", "$max", "$maxTimeMS", "$min", "$orderby", "$query", "$returnKey", "$showDiskLoc", "$natural"], t = "(?:" + (e = e.map(function(a) {
-    return a.replace("$", "\\$");
-  })).join("|") + ")\\b";
-  $.languages.mongodb = $.languages.extend("javascript", {}), $.languages.insertBefore("mongodb", "string", { property: { pattern: /(?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)(?=\s*:)/, greedy: !0, inside: { keyword: RegExp(`^(['"])?` + t + "(?:\\1)?$") } } }), $.languages.mongodb.string.inside = { url: { pattern: /https?:\/\/[-\w@:%.+~#=]{1,256}\.[a-z0-9()]{1,6}\b[-\w()@:%+.~#?&/=]*/i, greedy: !0 }, entity: { pattern: /\b(?:(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d\d?|2[0-4]\d|25[0-5])\b/, greedy: !0 } }, $.languages.insertBefore("mongodb", "constant", { builtin: { pattern: RegExp("\\b(?:" + ["ObjectId", "Code", "BinData", "DBRef", "Timestamp", "NumberLong", "NumberDecimal", "MaxKey", "MinKey", "RegExp", "ISODate", "UUID"].join("|") + ")\\b"), alias: "keyword" } });
-})(Prism);

package/dist/prism-monkey.min-5a1eb1ff.js

@@ -1 +0,0 @@
-Prism.languages.monkey = { comment: { pattern: /^#Rem\s[\s\S]*?^#End|'.+/im, greedy: !0 }, string: { pattern: /"[^"\r\n]*"/, greedy: !0 }, preprocessor: { pattern: /(^[ \t]*)#.+/m, lookbehind: !0, greedy: !0, alias: "property" }, function: /\b\w+(?=\()/, "type-char": { pattern: /\b[?%#$]/, alias: "class-name" }, number: { pattern: /((?:\.\.)?)(?:(?:\b|\B-\.?|\B\.)\d+(?:(?!\.\.)\.\d*)?|\$[\da-f]+)/i, lookbehind: !0 }, keyword: /\b(?:Abstract|Array|Bool|Case|Catch|Class|Const|Continue|Default|Eachin|Else|ElseIf|End|EndIf|Exit|Extends|Extern|False|Field|Final|Float|For|Forever|Function|Global|If|Implements|Import|Inline|Int|Interface|Local|Method|Module|New|Next|Null|Object|Private|Property|Public|Repeat|Return|Select|Self|Step|Strict|String|Super|Then|Throw|To|True|Try|Until|Void|Wend|While)\b/i, operator: /\.\.|<[=>]?|>=?|:?=|(?:[+\-*\/&~|]|\b(?:Mod|Shl|Shr)\b)=?|\b(?:And|Not|Or)\b/i, punctuation: /[.,:;()\[\]]/ };

package/dist/prism-moonscript.min-ed957c18.js

@@ -1 +0,0 @@
-Prism.languages.moonscript = { comment: /--.*/, string: [{ pattern: /'[^']*'|\[(=*)\[[\s\S]*?\]\1\]/, greedy: !0 }, { pattern: /"[^"]*"/, greedy: !0, inside: { interpolation: { pattern: /#\{[^{}]*\}/, inside: { moonscript: { pattern: /(^#\{)[\s\S]+(?=\})/, lookbehind: !0, inside: null }, "interpolation-punctuation": { pattern: /#\{|\}/, alias: "punctuation" } } } } }], "class-name": [{ pattern: /(\b(?:class|extends)[ \t]+)\w+/, lookbehind: !0 }, /\b[A-Z]\w*/], keyword: /\b(?:class|continue|do|else|elseif|export|extends|for|from|if|import|in|local|nil|return|self|super|switch|then|unless|using|when|while|with)\b/, variable: /@@?\w*/, property: { pattern: /\b(?!\d)\w+(?=:)|(:)(?!\d)\w+/, lookbehind: !0 }, function: { pattern: /\b(?:_G|_VERSION|assert|collectgarbage|coroutine\.(?:create|resume|running|status|wrap|yield)|debug\.(?:debug|getfenv|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|setfenv|sethook|setlocal|setmetatable|setupvalue|traceback)|dofile|error|getfenv|getmetatable|io\.(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write)|ipairs|load|loadfile|loadstring|math\.(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|ldexp|log|log10|max|min|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh)|module|next|os\.(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname)|package\.(?:cpath|loaded|loadlib|path|preload|seeall)|pairs|pcall|print|rawequal|rawget|rawset|require|select|setfenv|setmetatable|string\.(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|rep|reverse|sub|upper)|table\.(?:concat|insert|maxn|remove|sort)|tonumber|tostring|type|unpack|xpcall)\b/, inside: { punctuation: /\./ } }, boolean: /\b(?:false|true)\b/, number: /(?:\B\.\d+|\b\d+\.\d+|\b\d+(?=[eE]))(?:[eE][-+]?\d+)?\b|\b(?:0x[a-fA-F\d]+|\d+)(?:U?LL)?\b/, operator: /\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\.\.)=?|[:#^]|\b(?:and|or)\b=?|\b(?:not)\b/, punctuation: /[.,()[\]{}\\]/ }, Prism.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = Prism.languages.moonscript, Prism.languages.moon = Prism.languages.moonscript;

package/dist/prism-n1ql.min-f3780067.js

@@ -1 +0,0 @@
-Prism.languages.n1ql = { comment: { pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/, greedy: !0 }, string: { pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\]|\1\1)*\1/, greedy: !0 }, identifier: { pattern: /`(?:\\[\s\S]|[^\\`]|``)*`/, greedy: !0 }, parameter: /\$[\w.]+/, keyword: /\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\b/i, function: /\b[a-z_]\w*(?=\s*\()/i, boolean: /\b(?:FALSE|TRUE)\b/i, number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i, punctuation: /[;[\](),.{}:]/ };

package/dist/prism-n4js.min-d57fb90f.js

@@ -1 +0,0 @@
-Prism.languages.n4js = Prism.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ }), Prism.languages.insertBefore("n4js", "constant", { annotation: { pattern: /@+\w+/, alias: "operator" } }), Prism.languages.n4jsd = Prism.languages.n4js;

package/dist/prism-nand2tetris-hdl.min-8228b246.js

@@ -1 +0,0 @@
-Prism.languages["nand2tetris-hdl"] = { comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/, boolean: /\b(?:false|true)\b/, function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/, number: /\b\d+\b/, operator: /=|\.\./, punctuation: /[{}[\];(),:]/ };