@splunk/react-ui 5.3.0 → 5.5.0

package/Code.js

@@ -1,106 +1,6 @@
 /******/ (() => {
     // webpackBootstrap
     /******/ var e = {
-        /***/ 6283: 
-        /***/ (e, t, n) => {
-            "use strict";
-            // EXPORTS
-                        n.d(t, {
-                default: () => /* reexport */ p
-            });
-            // EXTERNAL MODULE: external "react"
-                        var r = n(9497);
-            // CONCATENATED MODULE: ./src/useResizeObserver/useResizeObserver.ts
-            function a(e, t) {
-                return u(e) || l(e, t) || s(e, t) || i();
-            }
-            function i() {
-                throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-            }
-            function s(e, t) {
-                if (e) {
-                    if ("string" == typeof e) return o(e, t);
-                    var n = {}.toString.call(e).slice(8, -1);
-                    return "Object" === n && e.constructor && (n = e.constructor.name), "Map" === n || "Set" === n ? Array.from(e) : "Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? o(e, t) : void 0;
-                }
-            }
-            function o(e, t) {
-                (null == t || t > e.length) && (t = e.length);
-                for (var n = 0, r = Array(t); n < t; n++) {
-                    r[n] = e[n];
-                }
-                return r;
-            }
-            function l(e, t) {
-                var n = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
-                if (null != n) {
-                    var r, a, i, s, o = [], l = !0, u = !1;
-                    try {
-                        if (i = (n = n.call(e)).next, 0 === t) {
-                            if (Object(n) !== n) return;
-                            l = !1;
-                        } else for (;!(l = (r = i.call(n)).done) && (o.push(r.value), o.length !== t); l = !0) {
-                        }
-                    } catch (e) {
-                        u = !0, a = e;
-                    } finally {
-                        try {
-                            if (!l && null != n["return"] && (s = n["return"](), Object(s) !== s)) return;
-                        } finally {
-                            if (u) throw a;
-                        }
-                    }
-                    return o;
-                }
-            }
-            function u(e) {
-                if (Array.isArray(e)) return e;
-            }
-            /**
- * Watches a React ref element for changes in size.
- *
- * @param ref - The React ref to observe size changes on
- */            var c = function e(t, n) {
-                var i = (0, r.useState)({
-                    width: 0,
-                    height: 0
-                }), s = a(i, 2), o = s[0], l = s[1];
-                (0, r.useEffect)((function() {
-                    var e = t.current;
-                    if (typeof window !== "undefined" && window.ResizeObserver) {
-                        var r = new ResizeObserver((function(e) {
-                            if (e[0]) {
-                                var r, a;
-                                var i = {
-                                    width: (t === null || t === void 0 ? void 0 : (r = t.current) === null || r === void 0 ? void 0 : r.getBoundingClientRect().width) || 0,
-                                    height: (t === null || t === void 0 ? void 0 : (a = t.current) === null || a === void 0 ? void 0 : a.getBoundingClientRect().height) || 0
-                                };
-                                l((function(e) {
-                                    if (e.height !== i.height || e.width !== i.width) {
-                                        n === null || n === void 0 ? void 0 : n(i);
-                                        return i;
-                                    }
-                                    return e;
-                                }));
-                            }
-                        }));
-                        if (e) {
-                            r.observe(e);
-                        }
-                        return function() {
-                            if (e) {
-                                r.unobserve(e);
-                            }
-                        };
-                    }
-                    // Return a no-op function to satisfy consistent-return rule
-                                        return function() {};
-                }), [ n, t ]);
-                return o;
-            };
-            /* harmony default export */            const p = c;
-        } // CONCATENATED MODULE: ./src/useResizeObserver/index.ts
-        /***/ ,
         /***/ 74: 
         /***/ e => {
             (function() {
@@ -121,7 +21,7 @@
                     var r = 0;
                     // The grammar object for plaintext
                                         var a = {};
-                    var i = {
+                    var s = {
                         /**
 		 * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
 		 * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
@@ -177,8 +77,8 @@
 		 */
                         util: {
                             encode: function e(t) {
-                                if (t instanceof s) {
-                                    return new s(t.type, e(t.content), t.alias);
+                                if (t instanceof i) {
+                                    return new i(t.type, e(t.content), t.alias);
                                 } else if (Array.isArray(t)) {
                                     return t.map(e);
                                 } else {
@@ -232,24 +132,24 @@
                                 n = n || {};
                                 var r;
                                 var a;
-                                switch (i.util.type(t)) {
+                                switch (s.util.type(t)) {
                                   case "Object":
-                                    a = i.util.objId(t);
+                                    a = s.util.objId(t);
                                     if (n[a]) {
                                         return n[a];
                                     }
                                     r = /** @type {Record<string, any>} */ {};
                                     n[a] = r;
-                                    for (var s in t) {
-                                        if (t.hasOwnProperty(s)) {
-                                            r[s] = e(t[s], n);
+                                    for (var i in t) {
+                                        if (t.hasOwnProperty(i)) {
+                                            r[i] = e(t[i], n);
                                         }
                                     }
                                     /** @type {any} */
                                     return r;
 
                                   case "Array":
-                                    a = i.util.objId(t);
+                                    a = s.util.objId(t);
                                     if (n[a]) {
                                         return n[a];
                                     }
@@ -414,7 +314,7 @@
 			 * });
 			 */
                             extend: function(e, t) {
-                                var n = i.util.clone(i.languages[e]);
+                                var n = s.util.clone(s.languages[e]);
                                 for (var r in t) {
                                     n[r] = t[r];
                                 }
@@ -496,48 +396,48 @@
 			 * @public
 			 */
                             insertBefore: function(e, t, n, r) {
-                                r = r || /** @type {any} */ i.languages;
+                                r = r || /** @type {any} */ s.languages;
                                 var a = r[e];
-                                /** @type {Grammar} */                                var s = {};
+                                /** @type {Grammar} */                                var i = {};
                                 for (var o in a) {
                                     if (a.hasOwnProperty(o)) {
                                         if (o == t) {
                                             for (var l in n) {
                                                 if (n.hasOwnProperty(l)) {
-                                                    s[l] = n[l];
+                                                    i[l] = n[l];
                                                 }
                                             }
                                         }
                                         // Do not insert token which also occur in insert. See #1525
                                                                                 if (!n.hasOwnProperty(o)) {
-                                            s[o] = a[o];
+                                            i[o] = a[o];
                                         }
                                     }
                                 }
                                 var u = r[e];
-                                r[e] = s;
+                                r[e] = i;
                                 // Update references in other language definitions
-                                                                i.languages.DFS(i.languages, (function(t, n) {
+                                                                s.languages.DFS(s.languages, (function(t, n) {
                                     if (n === u && t != e) {
-                                        this[t] = s;
+                                        this[t] = i;
                                     }
                                 }));
-                                return s;
+                                return i;
                             },
                             // Traverse a language definition with Depth First Search
                             DFS: function e(t, n, r, a) {
                                 a = a || {};
-                                var s = i.util.objId;
+                                var i = s.util.objId;
                                 for (var o in t) {
                                     if (t.hasOwnProperty(o)) {
                                         n.call(t, o, t[o], r || o);
                                         var l = t[o];
-                                        var u = i.util.type(l);
-                                        if (u === "Object" && !a[s(l)]) {
-                                            a[s(l)] = true;
+                                        var u = s.util.type(l);
+                                        if (u === "Object" && !a[i(l)]) {
+                                            a[i(l)] = true;
                                             e(l, n, null, a);
-                                        } else if (u === "Array" && !a[s(l)]) {
-                                            a[s(l)] = true;
+                                        } else if (u === "Array" && !a[i(l)]) {
+                                            a[i(l)] = true;
                                             e(l, n, o, a);
                                         }
                                     }
@@ -558,7 +458,7 @@
 		 * @public
 		 */
                         highlightAll: function(e, t) {
-                            i.highlightAllUnder(document, e, t);
+                            s.highlightAllUnder(document, e, t);
                         },
                         /**
 		 * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
@@ -581,11 +481,11 @@
                                 container: e,
                                 selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
                             };
-                            i.hooks.run("before-highlightall", r);
+                            s.hooks.run("before-highlightall", r);
                             r.elements = Array.prototype.slice.apply(r.container.querySelectorAll(r.selector));
-                            i.hooks.run("before-all-elements-highlight", r);
-                            for (var a = 0, s; s = r.elements[a++]; ) {
-                                i.highlightElement(s, t === true, r.callback);
+                            s.hooks.run("before-all-elements-highlight", r);
+                            for (var a = 0, i; i = r.elements[a++]; ) {
+                                s.highlightElement(i, t === true, r.callback);
                             }
                         },
                         /**
@@ -618,48 +518,48 @@
 		 */
                         highlightElement: function(t, n, r) {
                             // Find language
-                            var a = i.util.getLanguage(t);
-                            var s = i.languages[a];
+                            var a = s.util.getLanguage(t);
+                            var i = s.languages[a];
                             // Set language on the element, if not present
-                                                        i.util.setLanguage(t, a);
+                                                        s.util.setLanguage(t, a);
                             // Set language on the parent, for styling
                                                         var o = t.parentElement;
                             if (o && o.nodeName.toLowerCase() === "pre") {
-                                i.util.setLanguage(o, a);
+                                s.util.setLanguage(o, a);
                             }
                             var l = t.textContent;
                             var u = {
                                 element: t,
                                 language: a,
-                                grammar: s,
+                                grammar: i,
                                 code: l
                             };
                             function c(e) {
                                 u.highlightedCode = e;
-                                i.hooks.run("before-insert", u);
+                                s.hooks.run("before-insert", u);
                                 u.element.innerHTML = u.highlightedCode;
-                                i.hooks.run("after-highlight", u);
-                                i.hooks.run("complete", u);
+                                s.hooks.run("after-highlight", u);
+                                s.hooks.run("complete", u);
                                 r && r.call(u.element);
                             }
-                            i.hooks.run("before-sanity-check", u);
+                            s.hooks.run("before-sanity-check", u);
                             // plugins may change/add the parent/element
                                                         o = u.element.parentElement;
                             if (o && o.nodeName.toLowerCase() === "pre" && !o.hasAttribute("tabindex")) {
                                 o.setAttribute("tabindex", "0");
                             }
                             if (!u.code) {
-                                i.hooks.run("complete", u);
+                                s.hooks.run("complete", u);
                                 r && r.call(u.element);
                                 return;
                             }
-                            i.hooks.run("before-highlight", u);
+                            s.hooks.run("before-highlight", u);
                             if (!u.grammar) {
-                                c(i.util.encode(u.code));
+                                c(s.util.encode(u.code));
                                 return;
                             }
                             if (n && e.Worker) {
-                                var p = new Worker(i.filename);
+                                var p = new Worker(s.filename);
                                 p.onmessage = function(e) {
                                     c(e.data);
                                 };
@@ -669,7 +569,7 @@
                                     immediateClose: true
                                 }));
                             } else {
-                                c(i.highlight(u.code, u.grammar, u.language));
+                                c(s.highlight(u.code, u.grammar, u.language));
                             }
                         },
                         /**
@@ -698,13 +598,13 @@
                                 grammar: t,
                                 language: n
                             };
-                            i.hooks.run("before-tokenize", r);
+                            s.hooks.run("before-tokenize", r);
                             if (!r.grammar) {
                                 throw new Error('The language "' + r.language + '" has no grammar.');
                             }
-                            r.tokens = i.tokenize(r.code, r.grammar);
-                            i.hooks.run("after-tokenize", r);
-                            return s.stringify(i.util.encode(r.tokens), r.language);
+                            r.tokens = s.tokenize(r.code, r.grammar);
+                            s.hooks.run("after-tokenize", r);
+                            return i.stringify(s.util.encode(r.tokens), r.language);
                         },
                         /**
 		 * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
@@ -763,7 +663,7 @@
 			 * @public
 			 */
                             add: function(e, t) {
-                                var n = i.hooks.all;
+                                var n = s.hooks.all;
                                 n[e] = n[e] || [];
                                 n[e].push(t);
                             },
@@ -777,7 +677,7 @@
 			 * @public
 			 */
                             run: function(e, t) {
-                                var n = i.hooks.all[e];
+                                var n = s.hooks.all[e];
                                 if (!n || !n.length) {
                                     return;
                                 }
@@ -786,9 +686,9 @@
                                 }
                             }
                         },
-                        Token: s
+                        Token: i
                     };
-                    e.Prism = i;
+                    e.Prism = s;
                     // Typescript note:
                     // The following can be used to import the Token type in JSDoc:
                     
@@ -803,7 +703,7 @@
 	 * @class
 	 * @global
 	 * @public
-	 */                    function s(e, t, n, r) {
+	 */                    function i(e, t, n, r) {
                         /**
 		 * The type of the token.
 		 *
@@ -858,7 +758,7 @@
 	 * @returns {string} The HTML representation of the token or token stream.
 	 * @memberof Token
 	 * @static
-	 */                    s.stringify = function e(t, n) {
+	 */                    i.stringify = function e(t, n) {
                         if (typeof t == "string") {
                             return t;
                         }
@@ -877,15 +777,15 @@
                             attributes: {},
                             language: n
                         };
-                        var s = t.alias;
-                        if (s) {
-                            if (Array.isArray(s)) {
-                                Array.prototype.push.apply(a.classes, s);
+                        var i = t.alias;
+                        if (i) {
+                            if (Array.isArray(i)) {
+                                Array.prototype.push.apply(a.classes, i);
                             } else {
-                                a.classes.push(s);
+                                a.classes.push(i);
                             }
                         }
-                        i.hooks.run("wrap", a);
+                        s.hooks.run("wrap", a);
                         var o = "";
                         for (var l in a.attributes) {
                             o += " " + l + '="' + (a.attributes[l] || "").replace(/"/g, "&quot;") + '"';
@@ -903,9 +803,9 @@
                         var a = e.exec(n);
                         if (a && r && a[1]) {
                             // change the match to remove the text matched by the Prism lookbehind group
-                            var i = a[1].length;
-                            a.index += i;
-                            a[0] = a[0].slice(i);
+                            var s = a[1].length;
+                            a.index += s;
+                            a[0] = a[0].slice(s);
                         }
                         return a;
                     }
@@ -934,97 +834,97 @@
                                     return;
                                 }
                                 var m = g[f];
-                                var v = m.inside;
+                                var b = m.inside;
                                 var h = !!m.lookbehind;
-                                var E = !!m.greedy;
-                                var b = m.alias;
-                                if (E && !m.pattern.global) {
+                                var v = !!m.greedy;
+                                var E = m.alias;
+                                if (v && !m.pattern.global) {
                                     // Without the global flag, lastIndex won't work
                                     var y = m.pattern.toString().match(/[imsuy]*$/)[0];
                                     m.pattern = RegExp(m.pattern.source, y + "g");
                                 }
                                 /** @type {RegExp} */                                var S = m.pattern || m;
                                 for (// iterate the token list and keep track of the current token/string position
-                                var A = r.next, T = a; A !== t.tail; T += A.value.length, A = A.next) {
-                                    if (u && T >= u.reach) {
+                                var A = r.next, k = a; A !== t.tail; k += A.value.length, A = A.next) {
+                                    if (u && k >= u.reach) {
                                         break;
                                     }
-                                    var I = A.value;
+                                    var x = A.value;
                                     if (t.length > e.length) {
                                         // Something went terribly wrong, ABORT, ABORT!
                                         return;
                                     }
-                                    if (I instanceof s) {
+                                    if (x instanceof i) {
                                         continue;
                                     }
-                                    var O = 1;
+                                    var T = 1;
  // this is the to parameter of removeBetween
-                                                                        var N;
-                                    if (E) {
-                                        N = o(S, T, e, h);
-                                        if (!N || N.index >= e.length) {
+                                                                        var I;
+                                    if (v) {
+                                        I = o(S, k, e, h);
+                                        if (!I || I.index >= e.length) {
                                             break;
                                         }
-                                        var x = N.index;
-                                        var R = N.index + N[0].length;
-                                        var k = T;
+                                        var R = I.index;
+                                        var w = I.index + I[0].length;
+                                        var N = k;
                                         // find the node that contains the match
-                                                                                k += A.value.length;
-                                        while (x >= k) {
+                                                                                N += A.value.length;
+                                        while (R >= N) {
                                             A = A.next;
-                                            k += A.value.length;
+                                            N += A.value.length;
                                         }
                                         // adjust pos (and p)
-                                                                                k -= A.value.length;
-                                        T = k;
+                                                                                N -= A.value.length;
+                                        k = N;
                                         // the current node is a Token, then the match starts inside another Token, which is invalid
-                                                                                if (A.value instanceof s) {
+                                                                                if (A.value instanceof i) {
                                             continue;
                                         }
                                         // find the last node which is affected by this match
-                                                                                for (var L = A; L !== t.tail && (k < R || typeof L.value === "string"); L = L.next) {
-                                            O++;
-                                            k += L.value.length;
+                                                                                for (var O = A; O !== t.tail && (N < w || typeof O.value === "string"); O = O.next) {
+                                            T++;
+                                            N += O.value.length;
                                         }
-                                        O--;
+                                        T--;
                                         // replace with the new match
-                                                                                I = e.slice(T, k);
-                                        N.index -= T;
+                                                                                x = e.slice(k, N);
+                                        I.index -= k;
                                     } else {
-                                        N = o(S, 0, I, h);
-                                        if (!N) {
+                                        I = o(S, 0, x, h);
+                                        if (!I) {
                                             continue;
                                         }
                                     }
                                     // eslint-disable-next-line no-redeclare
-                                                                        var x = N.index;
-                                    var F = N[0];
-                                    var w = I.slice(0, x);
-                                    var C = I.slice(x + F.length);
-                                    var D = T + I.length;
-                                    if (u && D > u.reach) {
-                                        u.reach = D;
+                                                                        var R = I.index;
+                                    var _ = I[0];
+                                    var L = x.slice(0, R);
+                                    var F = x.slice(R + _.length);
+                                    var C = k + x.length;
+                                    if (u && C > u.reach) {
+                                        u.reach = C;
                                     }
-                                    var P = A.prev;
-                                    if (w) {
-                                        P = c(t, P, w);
-                                        T += w.length;
+                                    var D = A.prev;
+                                    if (L) {
+                                        D = c(t, D, L);
+                                        k += L.length;
                                     }
-                                    p(t, P, O);
-                                    var _ = new s(d, v ? i.tokenize(F, v) : F, b, F);
-                                    A = c(t, P, _);
-                                    if (C) {
-                                        c(t, A, C);
+                                    p(t, D, T);
+                                    var P = new i(d, b ? s.tokenize(_, b) : _, E, _);
+                                    A = c(t, D, P);
+                                    if (F) {
+                                        c(t, A, F);
                                     }
-                                    if (O > 1) {
+                                    if (T > 1) {
                                         // at least one Token object was removed, so we have to do some rematching
                                         // this can only happen if the current pattern is greedy
                                         /** @type {RematchOptions} */
                                         var $ = {
                                             cause: d + "," + f,
-                                            reach: D
+                                            reach: C
                                         };
-                                        l(e, t, n, A.prev, T, $);
+                                        l(e, t, n, A.prev, k, $);
                                         // the reach might have been extended because of the rematching
                                                                                 if (u && $.reach > u.reach) {
                                             u.reach = $.reach;
@@ -1115,37 +1015,37 @@
                     if (!e.document) {
                         if (!e.addEventListener) {
                             // in Node.js
-                            return i;
+                            return s;
                         }
-                        if (!i.disableWorkerMessageHandler) {
+                        if (!s.disableWorkerMessageHandler) {
                             // In worker
                             e.addEventListener("message", (function(t) {
                                 var n = JSON.parse(t.data);
                                 var r = n.language;
                                 var a = n.code;
-                                var s = n.immediateClose;
-                                e.postMessage(i.highlight(a, i.languages[r], r));
-                                if (s) {
+                                var i = n.immediateClose;
+                                e.postMessage(s.highlight(a, s.languages[r], r));
+                                if (i) {
                                     e.close();
                                 }
                             }), false);
                         }
-                        return i;
+                        return s;
                     }
                     // Get current script and highlight
-                                        var g = i.util.currentScript();
+                                        var g = s.util.currentScript();
                     if (g) {
-                        i.filename = g.src;
+                        s.filename = g.src;
                         if (g.hasAttribute("data-manual")) {
-                            i.manual = true;
+                            s.manual = true;
                         }
                     }
                     function f() {
-                        if (!i.manual) {
-                            i.highlightAll();
+                        if (!s.manual) {
+                            s.highlightAll();
                         }
                     }
-                    if (!i.manual) {
+                    if (!s.manual) {
                         // If the document state is "loading", then we'll use DOMContentLoaded.
                         // If the document state is "interactive" and the prism.js script is deferred, then we'll also use the
                         // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they
@@ -1163,7 +1063,7 @@
                             }
                         }
                     }
-                    return i;
+                    return s;
                 }(r);
                 if (true && e.exports) {
                     e.exports = a;
@@ -1341,26 +1241,26 @@
                             inside: a.languages[n]
                         };
                         r["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
-                        var i = {
+                        var s = {
                             "included-cdata": {
                                 pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
                                 inside: r
                             }
                         };
-                        i["language-" + n] = {
+                        s["language-" + n] = {
                             pattern: /[\s\S]+/,
                             inside: a.languages[n]
                         };
-                        var s = {};
-                        s[t] = {
+                        var i = {};
+                        i[t] = {
                             pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, (function() {
                                 return t;
                             })), "i"),
                             lookbehind: true,
                             greedy: true,
-                            inside: i
+                            inside: s
                         };
-                        a.languages.insertBefore("markup", "cdata", s);
+                        a.languages.insertBefore("markup", "cdata", i);
                     }
                 });
                 Object.defineProperty(a.languages.markup.tag, "addAttribute", {
@@ -1577,7 +1477,7 @@
                     /**
 	 * @param {string} source
 	 * @param {string} [flags]
-	 */                    function i(e, t) {
+	 */                    function s(e, t) {
                         e = e.replace(/<S>/g, (function() {
                             return n;
                         })).replace(/<BRACES>/g, (function() {
@@ -1587,23 +1487,23 @@
                         }));
                         return RegExp(e, t);
                     }
-                    a = i(a).source;
+                    a = s(a).source;
                     e.languages.jsx = e.languages.extend("markup", t);
-                    e.languages.jsx.tag.pattern = i(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source);
+                    e.languages.jsx.tag.pattern = s(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source);
                     e.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
                     e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
                     e.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
                     e.languages.jsx.tag.inside["comment"] = t["comment"];
                     e.languages.insertBefore("inside", "attr-name", {
                         spread: {
-                            pattern: i(/<SPREAD>/.source),
+                            pattern: s(/<SPREAD>/.source),
                             inside: e.languages.jsx
                         }
                     }, e.languages.jsx.tag);
                     e.languages.insertBefore("inside", "special-attr", {
                         script: {
                             // Allow for two levels of nesting
-                            pattern: i(/=<BRACES>/.source),
+                            pattern: s(/=<BRACES>/.source),
                             alias: "language-javascript",
                             inside: {
                                 "script-punctuation": {
@@ -1615,7 +1515,7 @@
                         }
                     }, e.languages.jsx.tag);
                     // The following will handle plain text inside tags
-                                        var s = function(e) {
+                                        var i = function(e) {
                         if (!e) {
                             return "";
                         }
@@ -1625,19 +1525,19 @@
                         if (typeof e.content === "string") {
                             return e.content;
                         }
-                        return e.content.map(s).join("");
+                        return e.content.map(i).join("");
                     };
                     var o = function(t) {
                         var n = [];
                         for (var r = 0; r < t.length; r++) {
                             var a = t[r];
-                            var i = false;
+                            var s = false;
                             if (typeof a !== "string") {
                                 if (a.type === "tag" && a.content[0] && a.content[0].type === "tag") {
                                     // We found a tag, now find its kind
                                     if (a.content[0].content[0].content === "</") {
                                         // Closing tag
-                                        if (n.length > 0 && n[n.length - 1].tagName === s(a.content[0].content[1])) {
+                                        if (n.length > 0 && n[n.length - 1].tagName === i(a.content[0].content[1])) {
                                             // Pop matching opening tag
                                             n.pop();
                                         }
@@ -1647,7 +1547,7 @@
                                         } else {
                                             // Opening tag
                                             n.push({
-                                                tagName: s(a.content[0].content[1]),
+                                                tagName: i(a.content[0].content[1]),
                                                 openedBraces: 0
                                             });
                                         }
@@ -1659,21 +1559,21 @@
                                     // Here we might have left a JSX context inside a tag
                                     n[n.length - 1].openedBraces--;
                                 } else {
-                                    i = true;
+                                    s = true;
                                 }
                             }
-                            if (i || typeof a === "string") {
+                            if (s || typeof a === "string") {
                                 if (n.length > 0 && n[n.length - 1].openedBraces === 0) {
                                     // Here we are inside a tag, and not inside a JSX context.
                                     // That's plain text: drop any tokens matched.
-                                    var l = s(a);
+                                    var l = i(a);
                                     // And merge text with adjacent text
                                                                         if (r < t.length - 1 && (typeof t[r + 1] === "string" || t[r + 1].type === "plain-text")) {
-                                        l += s(t[r + 1]);
+                                        l += i(t[r + 1]);
                                         t.splice(r + 1, 1);
                                     }
                                     if (r > 0 && (typeof t[r - 1] === "string" || t[r - 1].type === "plain-text")) {
-                                        l = s(t[r - 1]) + l;
+                                        l = i(t[r - 1]) + l;
                                         t.splice(r - 1, 1);
                                         r--;
                                     }
@@ -2010,9 +1910,9 @@
                     };
                     n.inside = e.languages.bash;
                     /* Patterns in command substitution. */                    var a = [ "comment", "function-name", "for-or-select", "assign-left", "parameter", "string", "environment", "function", "keyword", "builtin", "boolean", "file-descriptor", "operator", "punctuation", "number" ];
-                    var i = r.variable[1].inside;
-                    for (var s = 0; s < a.length; s++) {
-                        i[a[s]] = e.languages.bash[a[s]];
+                    var s = r.variable[1].inside;
+                    for (var i = 0; i < a.length; i++) {
+                        s[a[i]] = e.languages.bash[a[i]];
                     }
                     e.languages.sh = e.languages.bash;
                     e.languages.shell = e.languages.bash;
@@ -2031,13 +1931,13 @@
                                         var a = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, (function() {
                         return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
                     }));
-                    var i = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+                    var s = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
                     /**
 	 *
 	 * @param {string} value
 	 * @param {string} [flags]
 	 * @returns {RegExp}
-	 */                    function s(e, t) {
+	 */                    function i(e, t) {
                         t = (t || "").replace(/m/g, "") + "m";
  // add m flag
                                                 var n = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, (function() {
@@ -2060,7 +1960,7 @@
                             pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, (function() {
                                 return r;
                             })).replace(/<<key>>/g, (function() {
-                                return "(?:" + a + "|" + i + ")";
+                                return "(?:" + a + "|" + s + ")";
                             }))),
                             lookbehind: true,
                             greedy: true,
@@ -2072,27 +1972,27 @@
                             alias: "important"
                         },
                         datetime: {
-                            pattern: s(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
+                            pattern: i(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
                             lookbehind: true,
                             alias: "number"
                         },
                         boolean: {
-                            pattern: s(/false|true/.source, "i"),
+                            pattern: i(/false|true/.source, "i"),
                             lookbehind: true,
                             alias: "important"
                         },
                         null: {
-                            pattern: s(/null|~/.source, "i"),
+                            pattern: i(/null|~/.source, "i"),
                             lookbehind: true,
                             alias: "important"
                         },
                         string: {
-                            pattern: s(i),
+                            pattern: i(s),
                             lookbehind: true,
                             greedy: true
                         },
                         number: {
-                            pattern: s(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
+                            pattern: i(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
                             lookbehind: true
                         },
                         tag: n,
@@ -2155,12 +2055,604 @@
                     operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
                     punctuation: /[;[\]()`,.]/
                 };
+                a.languages.c = a.languages.extend("clike", {
+                    comment: {
+                        pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+                        greedy: true
+                    },
+                    string: {
+                        // https://en.cppreference.com/w/c/language/string_literal
+                        pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+                        greedy: true
+                    },
+                    "class-name": {
+                        pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+                        lookbehind: true
+                    },
+                    keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+                    function: /\b[a-z_]\w*(?=\s*\()/i,
+                    number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+                    operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+                });
+                a.languages.insertBefore("c", "string", {
+                    char: {
+                        // https://en.cppreference.com/w/c/language/character_constant
+                        pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+                        greedy: true
+                    }
+                });
+                a.languages.insertBefore("c", "string", {
+                    macro: {
+                        // allow for multiline macro definitions
+                        // spaces after the # character compile fine with gcc
+                        pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+                        lookbehind: true,
+                        greedy: true,
+                        alias: "property",
+                        inside: {
+                            string: [ {
+                                // highlight the path of the include statement as a string
+                                pattern: /^(#\s*include\s*)<[^>]+>/,
+                                lookbehind: true
+                            }, a.languages.c["string"] ],
+                            char: a.languages.c["char"],
+                            comment: a.languages.c["comment"],
+                            "macro-name": [ {
+                                pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+                                lookbehind: true
+                            }, {
+                                pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+                                lookbehind: true,
+                                alias: "function"
+                            } ],
+                            // highlight macro directives as keywords
+                            directive: {
+                                pattern: /^(#\s*)[a-z]+/,
+                                lookbehind: true,
+                                alias: "keyword"
+                            },
+                            "directive-hash": /^#/,
+                            punctuation: /##|\\(?=[\r\n])/,
+                            expression: {
+                                pattern: /\S[\s\S]*/,
+                                inside: a.languages.c
+                            }
+                        }
+                    }
+                });
+                a.languages.insertBefore("c", "function", {
+                    // highlight predefined macros as constants
+                    constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
+                });
+                delete a.languages.c["boolean"];
+                (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/;
+                    var n = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.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+/.source.replace(/<keyword>/g, (function() {
+                                return t.source;
+                            }))),
+                            lookbehind: true
+                        }, 
+                        // This is intended to capture the class name of method implementations like:
+                        //   void foo::bar() const {}
+                        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+                        // it starts with an uppercase letter. This approximation should give decent results.
+                        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, 
+                        // This will capture the class name before destructors like:
+                        //   Foo::~Foo() {}
+                        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, 
+                        // This also intends to capture the class name of method implementations but here the class has template
+                        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+                        /\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: true
+                        },
+                        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: {
+                            // https://en.cppreference.com/w/cpp/language/modules
+                            pattern: RegExp(/(\b(?:import|module)\s+)/.source + "(?:" + 
+                            // header-name
+                            /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + 
+                            // module name or partition or both
+                            /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, (function() {
+                                return n;
+                            })) + ")"),
+                            lookbehind: true,
+                            greedy: true,
+                            inside: {
+                                string: /^[<"][\s\S]+/,
+                                operator: /:/,
+                                punctuation: /\./
+                            }
+                        },
+                        "raw-string": {
+                            pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+                            alias: "string",
+                            greedy: true
+                        }
+                    });
+                    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", {
+                        // the base clause is an optional list of parent classes
+                        // https://en.cppreference.com/w/cpp/language/class
+                        "base-clause": {
+                            pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+                            lookbehind: true,
+                            greedy: true,
+                            inside: e.languages.extend("cpp", {})
+                        }
+                    });
+                    e.languages.insertBefore("inside", "double-colon", {
+                        // All untokenized words that are not namespaces should be class names
+                        "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
+                    }, e.languages.cpp["base-clause"]);
+                })(a);
+                (function(e) {
+                    /**
+	 * Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
+	 *
+	 * Note: This is a simple text based replacement. Be careful when using backreferences!
+	 *
+	 * @param {string} pattern the given pattern.
+	 * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
+	 * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
+	 * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
+	 */
+                    function t(e, t) {
+                        return e.replace(/<<(\d+)>>/g, (function(e, n) {
+                            return "(?:" + t[+n] + ")";
+                        }));
+                    }
+                    /**
+	 * @param {string} pattern
+	 * @param {string[]} replacements
+	 * @param {string} [flags]
+	 * @returns {RegExp}
+	 */                    function n(e, n, r) {
+                        return RegExp(t(e, n), r || "");
+                    }
+                    /**
+	 * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+	 *
+	 * @param {string} pattern
+	 * @param {number} depthLog2
+	 * @returns {string}
+	 */                    function r(e, t) {
+                        for (var n = 0; n < t; n++) {
+                            e = e.replace(/<<self>>/g, (function() {
+                                return "(?:" + e + ")";
+                            }));
+                        }
+                        return e.replace(/<<self>>/g, "[^\\s\\S]");
+                    }
+                    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
+                                        var a = {
+                        // keywords which represent a return or variable type
+                        type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+                        // keywords which are used to declare a type
+                        typeDeclaration: "class enum interface record struct",
+                        // contextual keywords
+                        // ("var" and "dynamic" are missing because they are used like types)
+                        contextual: "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*{)",
+                        // all other keywords
+                        other: "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"
+                    };
+                    // keywords
+                                        function s(e) {
+                        return "\\b(?:" + e.trim().replace(/ /g, "|") + ")\\b";
+                    }
+                    var i = s(a.typeDeclaration);
+                    var o = RegExp(s(a.type + " " + a.typeDeclaration + " " + a.contextual + " " + a.other));
+                    var l = s(a.typeDeclaration + " " + a.contextual + " " + a.other);
+                    var u = s(a.type + " " + a.typeDeclaration + " " + a.other);
+                    // types
+                                        var c = r(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
+ // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.
+                                        var p = r(/\((?:[^()]|<<self>>)*\)/.source, 2);
+                    var d = /@?\b[A-Za-z_]\w*\b/.source;
+                    var g = t(/<<0>>(?:\s*<<1>>)?/.source, [ d, c ]);
+                    var f = t(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [ l, g ]);
+                    var m = /\[\s*(?:,\s*)*\]/.source;
+                    var b = t(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [ f, m ]);
+                    var h = t(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [ c, p, m ]);
+                    var v = t(/\(<<0>>+(?:,<<0>>+)+\)/.source, [ h ]);
+                    var E = t(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [ v, f, m ]);
+                    var y = {
+                        keyword: o,
+                        punctuation: /[<>()?,.:[\]]/
+                    };
+                    // strings & characters
+                    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals
+                    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals
+                                        var S = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
+ // simplified pattern
+                                        var A = /"(?:\\.|[^\\"\r\n])*"/.source;
+                    var k = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+                    e.languages.csharp = e.languages.extend("clike", {
+                        string: [ {
+                            pattern: n(/(^|[^$\\])<<0>>/.source, [ k ]),
+                            lookbehind: true,
+                            greedy: true
+                        }, {
+                            pattern: n(/(^|[^@$\\])<<0>>/.source, [ A ]),
+                            lookbehind: true,
+                            greedy: true
+                        } ],
+                        "class-name": [ {
+                            // Using static
+                            // using static System.Math;
+                            pattern: n(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [ f ]),
+                            lookbehind: true,
+                            inside: y
+                        }, {
+                            // Using alias (type)
+                            // using Project = PC.MyCompany.Project;
+                            pattern: n(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [ d, E ]),
+                            lookbehind: true,
+                            inside: y
+                        }, {
+                            // Using alias (alias)
+                            // using Project = PC.MyCompany.Project;
+                            pattern: n(/(\busing\s+)<<0>>(?=\s*=)/.source, [ d ]),
+                            lookbehind: true
+                        }, {
+                            // Type declarations
+                            // class Foo<A, B>
+                            // interface Foo<out A, B>
+                            pattern: n(/(\b<<0>>\s+)<<1>>/.source, [ i, g ]),
+                            lookbehind: true,
+                            inside: y
+                        }, {
+                            // Single catch exception declaration
+                            // catch(Foo)
+                            // (things like catch(Foo e) is covered by variable declaration)
+                            pattern: n(/(\bcatch\s*\(\s*)<<0>>/.source, [ f ]),
+                            lookbehind: true,
+                            inside: y
+                        }, {
+                            // Name of the type parameter of generic constraints
+                            // where Foo : class
+                            pattern: n(/(\bwhere\s+)<<0>>/.source, [ d ]),
+                            lookbehind: true
+                        }, {
+                            // Casts and checks via as and is.
+                            // as Foo<A>, is Bar<B>
+                            // (things like if(a is Foo b) is covered by variable declaration)
+                            pattern: n(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [ b ]),
+                            lookbehind: true,
+                            inside: y
+                        }, {
+                            // Variable, field and parameter declaration
+                            // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+                            pattern: n(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [ E, u, d ]),
+                            inside: y
+                        } ],
+                        keyword: o,
+                        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+                        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: /\?\.?|::|[{}[\];(),.:]/
+                    });
+                    e.languages.insertBefore("csharp", "number", {
+                        range: {
+                            pattern: /\.\./,
+                            alias: "operator"
+                        }
+                    });
+                    e.languages.insertBefore("csharp", "punctuation", {
+                        "named-parameter": {
+                            pattern: n(/([(,]\s*)<<0>>(?=\s*:)/.source, [ d ]),
+                            lookbehind: true,
+                            alias: "punctuation"
+                        }
+                    });
+                    e.languages.insertBefore("csharp", "class-name", {
+                        namespace: {
+                            // namespace Foo.Bar {}
+                            // using Foo.Bar;
+                            pattern: n(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [ d ]),
+                            lookbehind: true,
+                            inside: {
+                                punctuation: /\./
+                            }
+                        },
+                        "type-expression": {
+                            // default(Foo), typeof(Foo<Bar>), sizeof(int)
+                            pattern: n(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [ p ]),
+                            lookbehind: true,
+                            alias: "class-name",
+                            inside: y
+                        },
+                        "return-type": {
+                            // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+                            // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+                            // int Foo => 0; int Foo { get; set } = 0;
+                            pattern: n(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [ E, f ]),
+                            inside: y,
+                            alias: "class-name"
+                        },
+                        "constructor-invocation": {
+                            // new List<Foo<Bar[]>> { }
+                            pattern: n(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [ E ]),
+                            lookbehind: true,
+                            inside: y,
+                            alias: "class-name"
+                        },
+                        /*'explicit-implementation': {
+			// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+			pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
+			inside: classNameInside,
+			alias: 'class-name'
+		},*/
+                        "generic-method": {
+                            // foo<Bar>()
+                            pattern: n(/<<0>>\s*<<1>>(?=\s*\()/.source, [ d, c ]),
+                            inside: {
+                                function: n(/^<<0>>/.source, [ d ]),
+                                generic: {
+                                    pattern: RegExp(c),
+                                    alias: "class-name",
+                                    inside: y
+                                }
+                            }
+                        },
+                        "type-list": {
+                            // The list of types inherited or of generic constraints
+                            // class Foo<F> : Bar, IList<FooBar>
+                            // where F : Bar, IList<int>
+                            pattern: n(/\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|[{;]|=>|$))/.source, [ i, g, d, E, o.source, p, /\bnew\s*\(\s*\)/.source ]),
+                            lookbehind: true,
+                            inside: {
+                                "record-arguments": {
+                                    pattern: n(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [ g, p ]),
+                                    lookbehind: true,
+                                    greedy: true,
+                                    inside: e.languages.csharp
+                                },
+                                keyword: o,
+                                "class-name": {
+                                    pattern: RegExp(E),
+                                    greedy: true,
+                                    inside: y
+                                },
+                                punctuation: /[,()]/
+                            }
+                        },
+                        preprocessor: {
+                            pattern: /(^[\t ]*)#.*/m,
+                            lookbehind: true,
+                            alias: "property",
+                            inside: {
+                                // highlight preprocessor directives as keywords
+                                directive: {
+                                    pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+                                    lookbehind: true,
+                                    alias: "keyword"
+                                }
+                            }
+                        }
+                    });
+                    // attributes
+                                        var x = A + "|" + S;
+                    var T = t(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [ x ]);
+                    var I = r(t(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [ T ]), 2);
+                    // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets
+                                        var R = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
+                    var w = t(/<<0>>(?:\s*\(<<1>>*\))?/.source, [ f, I ]);
+                    e.languages.insertBefore("csharp", "class-name", {
+                        attribute: {
+                            // Attributes
+                            // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+                            pattern: n(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [ R, w ]),
+                            lookbehind: true,
+                            greedy: true,
+                            inside: {
+                                target: {
+                                    pattern: n(/^<<0>>(?=\s*:)/.source, [ R ]),
+                                    alias: "keyword"
+                                },
+                                "attribute-arguments": {
+                                    pattern: n(/\(<<0>>*\)/.source, [ I ]),
+                                    inside: e.languages.csharp
+                                },
+                                "class-name": {
+                                    pattern: RegExp(f),
+                                    inside: {
+                                        punctuation: /\./
+                                    }
+                                },
+                                punctuation: /[:,]/
+                            }
+                        }
+                    });
+                    // string interpolation
+                                        var N = /:[^}\r\n]+/.source;
+                    // multi line
+                                        var O = r(t(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [ T ]), 2);
+                    var _ = t(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [ O, N ]);
+                    // single line
+                                        var L = r(t(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [ x ]), 2);
+                    var F = t(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [ L, N ]);
+                    function C(t, r) {
+                        return {
+                            interpolation: {
+                                pattern: n(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [ t ]),
+                                lookbehind: true,
+                                inside: {
+                                    "format-string": {
+                                        pattern: n(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [ r, N ]),
+                                        lookbehind: true,
+                                        inside: {
+                                            punctuation: /^:/
+                                        }
+                                    },
+                                    punctuation: /^\{|\}$/,
+                                    expression: {
+                                        pattern: /[\s\S]+/,
+                                        alias: "language-csharp",
+                                        inside: e.languages.csharp
+                                    }
+                                }
+                            },
+                            string: /[\s\S]+/
+                        };
+                    }
+                    e.languages.insertBefore("csharp", "string", {
+                        "interpolation-string": [ {
+                            pattern: n(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [ _ ]),
+                            lookbehind: true,
+                            greedy: true,
+                            inside: C(_, O)
+                        }, {
+                            pattern: n(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [ F ]),
+                            lookbehind: true,
+                            greedy: true,
+                            inside: C(F, L)
+                        } ],
+                        char: {
+                            pattern: RegExp(S),
+                            greedy: true
+                        }
+                    });
+                    e.languages.dotnet = e.languages.cs = e.languages.csharp;
+                })(a);
+                (function(e) {
+                    var t = e.languages.powershell = {
+                        comment: [ {
+                            pattern: /(^|[^`])<#[\s\S]*?#>/,
+                            lookbehind: true
+                        }, {
+                            pattern: /(^|[^`])#.*/,
+                            lookbehind: true
+                        } ],
+                        string: [ {
+                            pattern: /"(?:`[\s\S]|[^`"])*"/,
+                            greedy: true,
+                            inside: null
+                        }, {
+                            pattern: /'(?:[^']|'')*'/,
+                            greedy: true
+                        } ],
+                        // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+                        // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+                        namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+                        boolean: /\$(?:false|true)\b/i,
+                        variable: /\$\w+\b/,
+                        // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+                        // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+                        // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+                        function: [ /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i, /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i ],
+                        // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+                        keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+                        operator: {
+                            pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+                            lookbehind: true
+                        },
+                        punctuation: /[|{}[\];(),.]/
+                    };
+                    // Variable interpolation inside strings, and nested expressions
+                                        t.string[0].inside = {
+                        function: {
+                            // Allow for one level of nesting
+                            pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+                            lookbehind: true,
+                            inside: t
+                        },
+                        boolean: t.boolean,
+                        variable: t.variable
+                    };
+                })(a);
+                a.languages.python = {
+                    comment: {
+                        pattern: /(^|[^\\])#.*/,
+                        lookbehind: true,
+                        greedy: true
+                    },
+                    "string-interpolation": {
+                        pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+                        greedy: true,
+                        inside: {
+                            interpolation: {
+                                // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+                                pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+                                lookbehind: true,
+                                inside: {
+                                    "format-spec": {
+                                        pattern: /(:)[^:(){}]+(?=\}$)/,
+                                        lookbehind: true
+                                    },
+                                    "conversion-option": {
+                                        pattern: /![sra](?=[:}]$)/,
+                                        alias: "punctuation"
+                                    },
+                                    rest: null
+                                }
+                            },
+                            string: /[\s\S]+/
+                        }
+                    },
+                    "triple-quoted-string": {
+                        pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+                        greedy: true,
+                        alias: "string"
+                    },
+                    string: {
+                        pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+                        greedy: true
+                    },
+                    function: {
+                        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+                        lookbehind: true
+                    },
+                    "class-name": {
+                        pattern: /(\bclass\s+)\w+/i,
+                        lookbehind: true
+                    },
+                    decorator: {
+                        pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+                        lookbehind: true,
+                        alias: [ "annotation", "punctuation" ],
+                        inside: {
+                            punctuation: /\./
+                        }
+                    },
+                    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+                    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+                    boolean: /\b(?:False|None|True)\b/,
+                    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+                    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+                    punctuation: /[{}[\];(),.:]/
+                };
+                a.languages.python["string-interpolation"].inside["interpolation"].inside.rest = a.languages.python;
+                a.languages.py = a.languages.python;
             })();
-            /***/        },
-        /***/ 9497: 
-        /***/ e => {
-            "use strict";
-            e.exports = require("react");
             /***/
             /******/        }
     };
@@ -2176,17 +2668,17 @@
             /******/ return a.exports;
             /******/        }
         /******/ // Create a new module (and put it into the cache)
-        /******/        var i = t[r] = {
+        /******/        var s = t[r] = {
             /******/ // no module.id needed
             /******/ // no module.loaded needed
             /******/ exports: {}
             /******/        };
         /******/
         /******/ // Execute the module function
-        /******/        e[r](i, i.exports, n);
+        /******/        e[r](s, s.exports, n);
         /******/
         /******/ // Return the exports of the module
-        /******/        return i.exports;
+        /******/        return s.exports;
         /******/    }
     /******/
     /************************************************************************/
@@ -2249,17 +2741,17 @@
                 n.r(r);
         // EXPORTS
                 n.d(r, {
-            default: () => /* reexport */ ae
+            default: () => /* reexport */ se
         });
-        // EXTERNAL MODULE: external "react"
-                var e = n(9497);
+        // CONCATENATED MODULE: external "react"
+        const e = require("react");
         var t =  n.n(e);
         // CONCATENATED MODULE: external "lodash/castArray"
         const a = require("lodash/castArray");
-        var i =  n.n(a);
+        var s =  n.n(a);
         // CONCATENATED MODULE: external "lodash/flatten"
-        const s = require("lodash/flatten");
-        var o =  n.n(s);
+        const i = require("lodash/flatten");
+        var o =  n.n(i);
         // CONCATENATED MODULE: external "lodash/indexOf"
         const l = require("lodash/indexOf");
         var u =  n.n(l);
@@ -2272,68 +2764,71 @@
         // CONCATENATED MODULE: external "prop-types"
         const f = require("prop-types");
         var m =  n.n(f);
+        // CONCATENATED MODULE: external "@splunk/react-ui/useResizeObserver"
+        const b = require("@splunk/react-ui/useResizeObserver");
+        var h =  n.n(b);
         // CONCATENATED MODULE: external "styled-components"
         const v = require("styled-components");
-        var h =  n.n(v);
+        var E =  n.n(v);
         // CONCATENATED MODULE: external "@splunk/themes"
-        const E = require("@splunk/themes");
+        const y = require("@splunk/themes");
         // CONCATENATED MODULE: ./src/Code/CodeStyles.ts
-        var b = "lineHeightSpacious";
-        var y = "spacingLarge";
-        var S = h().code.withConfig({
+        var S = "lineHeightSpacious";
+        var A = "spacingLarge";
+        var k = E().code.withConfig({
             displayName: "CodeStyles__StyledCode",
             componentId: "sc-1eq4k68-0"
-        })([ "font-family:", ";position:relative;z-index:1;", ";" ], E.variables.monoFontFamily, (function(e) {
+        })([ "font-family:", ";position:relative;z-index:1;", ";" ], y.variables.monoFontFamily, (function(e) {
             var t = e.$isPlaintext;
-            return !t && (0, v.css)([ "color:", ";" ], E.variables.syntaxTeal);
+            return !t && (0, v.css)([ "color:", ";" ], y.variables.syntaxTeal);
         }));
-        var A = h().pre.withConfig({
+        var x = E().pre.withConfig({
             displayName: "CodeStyles__StyledPre",
             componentId: "sc-1eq4k68-1"
-        })([ "", ";", ";line-height:", ";position:relative;text-align:left;tab-size:4;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;hyphens:none;overflow-x:auto;&:focus-visible{box-shadow:", ";}", " ", ";" ], E.mixins.reset("grid"), E.mixins.typography("monoBody"), E.variables[b], E.variables.focusShadow, (function(e) {
+        })([ "", ";", ";line-height:", ";position:relative;text-align:left;tab-size:4;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;hyphens:none;overflow-x:auto;&:focus-visible{box-shadow:", ";}", " ", ";" ], y.mixins.reset("grid"), y.mixins.typography("monoBody"), y.variables[S], y.variables.focusShadow, (function(e) {
             var t = e.$showLineNumbers, n = e.$counterReset;
             return t && (0, v.css)([ "grid-template-columns:min-content auto;counter-reset:linenumber ", ";" ], n);
         }), (function(e) {
             var t = e.$containerAppearance;
-            return t === "none" ? (0, v.css)([ "gap:", ";" ], E.variables.spacingMedium) : (0, 
-            v.css)([ "background-color:", ";border-radius:", ";", "{margin:", ";}" ], E.variables.neutral50, E.variables.borderRadius, /* sc-sel */ S, E.variables[y]);
+            return t === "none" ? (0, v.css)([ "gap:", ";" ], y.variables.spacingMedium) : (0, 
+            v.css)([ "background-color:", ";border-radius:", ";", "{margin:", ";}" ], y.variables.neutral50, y.variables.borderRadius, /* sc-sel */ k, y.variables[A]);
         }));
-        var T = h().span.withConfig({
+        var T = E().span.withConfig({
             displayName: "CodeStyles__StyledIndent",
             componentId: "sc-1eq4k68-2"
-        })([ "&:not(:last-child){background-image:linear-gradient( to left,", " 1px,transparent 1px,transparent );}" ], E.variables.syntaxGray);
+        })([ "&:not(:last-child){background-image:linear-gradient( to left,", " 1px,transparent 1px,transparent );}" ], y.variables.syntaxGray);
         var I = {
-            comment: E.variables.syntaxGray,
-            prolog: E.variables.syntaxGray,
-            doctype: E.variables.syntaxGray,
-            cdata: E.variables.syntaxGray,
-            punctuation: E.variables.syntaxGray,
-            property: E.variables.syntaxPurple,
-            tag: E.variables.syntaxPurple,
-            boolean: E.variables.syntaxPurple,
-            number: E.variables.syntaxPurple,
-            constant: E.variables.syntaxPurple,
-            symbol: E.variables.syntaxPurple,
-            deleted: E.variables.syntaxPurple,
-            key: E.variables.syntaxPurple,
-            selector: E.variables.syntaxGreen,
-            "attr-name": E.variables.syntaxGreen,
-            string: E.variables.syntaxGreen,
-            char: E.variables.syntaxGreen,
-            builtin: E.variables.syntaxGreen,
-            inserted: E.variables.syntaxGreen,
-            operator: E.variables.syntaxBrown,
-            entity: E.variables.syntaxBrown,
-            url: E.variables.syntaxBrown,
-            atrule: E.variables.syntaxBlue,
-            "attr-value": E.variables.syntaxBlue,
-            keyword: E.variables.syntaxBlue,
-            function: E.variables.syntaxRed,
-            regex: E.variables.syntaxOrange,
-            important: E.variables.syntaxOrange,
-            variable: E.variables.syntaxOrange
+            comment: y.variables.syntaxGray,
+            prolog: y.variables.syntaxGray,
+            doctype: y.variables.syntaxGray,
+            cdata: y.variables.syntaxGray,
+            punctuation: y.variables.syntaxGray,
+            property: y.variables.syntaxPurple,
+            tag: y.variables.syntaxPurple,
+            boolean: y.variables.syntaxPurple,
+            number: y.variables.syntaxPurple,
+            constant: y.variables.syntaxPurple,
+            symbol: y.variables.syntaxPurple,
+            deleted: y.variables.syntaxPurple,
+            key: y.variables.syntaxPurple,
+            selector: y.variables.syntaxGreen,
+            "attr-name": y.variables.syntaxGreen,
+            string: y.variables.syntaxGreen,
+            char: y.variables.syntaxGreen,
+            builtin: y.variables.syntaxGreen,
+            inserted: y.variables.syntaxGreen,
+            operator: y.variables.syntaxBrown,
+            entity: y.variables.syntaxBrown,
+            url: y.variables.syntaxBrown,
+            atrule: y.variables.syntaxBlue,
+            "attr-value": y.variables.syntaxBlue,
+            keyword: y.variables.syntaxBlue,
+            function: y.variables.syntaxRed,
+            regex: y.variables.syntaxOrange,
+            important: y.variables.syntaxOrange,
+            variable: y.variables.syntaxOrange
         };
-        var O = h().span.withConfig({
+        var R = E().span.withConfig({
             displayName: "CodeStyles__StyledToken",
             componentId: "sc-1eq4k68-3"
         })([ "color:", ";cursor:", ";opacity:", ";font-style:", ";font-weight:", ";" ], (function(e) {
@@ -2350,28 +2845,28 @@
             return t === "italic" ? "italic" : null;
         }), (function(e) {
             var t = e.partType;
-            return t === "important" || t === "bold" ? E.variables.fontWeightBold : null;
+            return t === "important" || t === "bold" ? y.variables.fontWeightBold : null;
         }));
         // CONCATENATED MODULE: ./src/Code/LineHighlightsStyles.ts
-        var N = h().div.withConfig({
+        var w = E().div.withConfig({
             displayName: "LineHighlightsStyles__StyledLineHighlight",
             componentId: "sc-1x2b02z-0"
-        })([ "position:absolute;left:0;height:1lh;background:", ";border-left:2px solid ", ";pointer-events:none;line-height:inherit;width:", "px;", ";" ], E.variables.notificationColorInfoWeak, E.variables.notificationColorInfo, (function(e) {
+        })([ "position:absolute;left:0;height:1lh;background:", ";border-left:2px solid ", ";pointer-events:none;line-height:inherit;width:", "px;", ";" ], y.variables.notificationColorInfoWeak, y.variables.notificationColorInfo, (function(e) {
             var t = e.$width;
             return t;
         }), (function(e) {
             var t = e.$containerAppearance, n = e.$lineNum;
-            return t === "none" ? (0, v.css)([ "top:calc(", " * ", "em);" ], n - 1, E.variables[b]) : (0, 
-            v.css)([ "top:calc( ", " * ", "em + ", " );" ], n - 1, E.variables[b], E.variables[y]);
+            return t === "none" ? (0, v.css)([ "top:calc(", " * ", "em);" ], n - 1, y.variables[S]) : (0, 
+            v.css)([ "top:calc( ", " * ", "em + ", " );" ], n - 1, y.variables[S], y.variables[A]);
         }));
         // CONCATENATED MODULE: ./src/Code/LineHighlights.tsx
-        function x(e, t) {
-            return w(e) || F(e, t) || k(e, t) || R();
+        function N(e, t) {
+            return C(e) || F(e, t) || _(e, t) || O();
         }
-        function R() {
+        function O() {
             throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
         }
-        function k(e, t) {
+        function _(e, t) {
             if (e) {
                 if ("string" == typeof e) return L(e, t);
                 var n = {}.toString.call(e).slice(8, -1);
@@ -2388,18 +2883,18 @@
         function F(e, t) {
             var n = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
             if (null != n) {
-                var r, a, i, s, o = [], l = !0, u = !1;
+                var r, a, s, i, o = [], l = !0, u = !1;
                 try {
-                    if (i = (n = n.call(e)).next, 0 === t) {
+                    if (s = (n = n.call(e)).next, 0 === t) {
                         if (Object(n) !== n) return;
                         l = !1;
-                    } else for (;!(l = (r = i.call(n)).done) && (o.push(r.value), o.length !== t); l = !0) {
+                    } else for (;!(l = (r = s.call(n)).done) && (o.push(r.value), o.length !== t); l = !0) {
                     }
                 } catch (e) {
                     u = !0, a = e;
                 } finally {
                     try {
-                        if (!l && null != n["return"] && (s = n["return"](), Object(s) !== s)) return;
+                        if (!l && null != n["return"] && (i = n["return"](), Object(i) !== i)) return;
                     } finally {
                         if (u) throw a;
                     }
@@ -2407,21 +2902,21 @@
                 return o;
             }
         }
-        function w(e) {
+        function C(e) {
             if (Array.isArray(e)) return e;
         }
         // parseHighlightLines will turn a string like "2,4-5" into an array of ranges like [[2, 2], [4, 5]]
-                var C = function e(t) {
+                var D = function e(t) {
             return t.replace(/\s+/g, "").split(",").filter(Boolean).map((function(e) {
-                var t = e.split("-").map(Number), n = x(t, 2), r = n[0], a = n[1];
+                var t = e.split("-").map(Number), n = N(t, 2), r = n[0], a = n[1];
                 return [ r, a || r ];
             }));
         };
         // Flatten the array of ranges into a single array of line numbers
         // example: [[2, 2], [4, 5]] will become [2, 4, 5]
-                var D = function e(t) {
+                var P = function e(t) {
             var n = t.map((function(e) {
-                var t = x(e, 2), n = t[0], r = t[1];
+                var t = N(e, 2), n = t[0], r = t[1];
                 return Array.from({
                     length: r - n + 1
                 }, (function(e, t) {
@@ -2433,43 +2928,43 @@
             return Array.from(new Set(n));
  // Remove duplicates
                 };
-        var P = function e(n) {
-            var r = n.containerAppearance, a = n.highlight, i = n.width;
-            var s = C(a);
-            var o = D(s);
+        var $ = function e(n) {
+            var r = n.containerAppearance, a = n.highlight, s = n.width;
+            var i = D(a);
+            var o = P(i);
             
             return t().createElement(t().Fragment, null, o.map((function(e) {
                 
-                return t().createElement(N, {
+                return t().createElement(w, {
                     key: e,
                     className: "line-highlight",
                     "aria-hidden": "true",
                     $containerAppearance: r,
                     $lineNum: e,
-                    $width: i
+                    $width: s
                 });
             })));
         };
-        /* harmony default export */        const _ = P;
+        /* harmony default export */        const U = $;
         // CONCATENATED MODULE: ./src/Code/LineNumbersStyles.ts
-        var $ = h().span.withConfig({
+        var B = E().span.withConfig({
             displayName: "LineNumbersStyles__StyledLineNumberRows",
             componentId: "sc-1h4k3dh-0"
         })([ "pointer-events:none;user-select:none;", ";& > span{display:block;counter-increment:linenumber;position:relative;z-index:1;&::before{display:block;content:counter(linenumber);color:", ";text-align:right;", "}}" ], (function(e) {
             var t = e.$containerAppearance;
-            return t === "none" ? (0, v.css)([ "border-right:1px solid ", ";z-index:1;" ], E.variables.borderColor) : (0, 
-            v.css)([ "padding:", ";background-color:", ";" ], E.variables[y], E.variables.neutral200);
-        }), E.variables.contentColorDefault, (function(e) {
+            return t === "none" ? (0, v.css)([ "border-right:1px solid ", ";z-index:1;" ], y.variables.borderColor) : (0, 
+            v.css)([ "padding:", ";background-color:", ";" ], y.variables[A], y.variables.neutral200);
+        }), y.variables.contentColorDefault, (function(e) {
             var t = e.$containerAppearance;
-            return t === "none" && (0, v.css)([ "padding-inline-end:", ";" ], E.variables.spacingSmall);
+            return t === "none" && (0, v.css)([ "padding-inline-end:", ";" ], y.variables.spacingSmall);
         }));
         // CONCATENATED MODULE: ./src/Code/LineNumbers.tsx
-        function U(e) {
-            var n = e.containerAppearance, r = n === void 0 ? "none" : n, a = e.value, i = a === void 0 ? "" : a;
+        function M(e) {
+            var n = e.containerAppearance, r = n === void 0 ? "none" : n, a = e.value, s = a === void 0 ? "" : a;
             // Use a regex to see how many lines there are in the value, then output an
             // empty span for each line.  The numbers themselves are handled by the CSS counter.
-                        var s = i.match(/\n(?!$)/g);
-            var o = s ? s.length + 1 : 1;
+                        var i = s.match(/\n(?!$)/g);
+            var o = i ? i.length + 1 : 1;
             var l = Array.from({
                 length: o
             }, (function(e, n) {
@@ -2479,17 +2974,15 @@
                 });
             }));
             
-            return t().createElement($, {
+            return t().createElement(B, {
                 $containerAppearance: r,
                 "aria-hidden": true
             }, l);
         }
-        /* harmony default export */        const M = U;
-        // EXTERNAL MODULE: ./src/useResizeObserver/index.ts + 1 modules
-                var B = n(6283);
+        /* harmony default export */        const G = M;
         // EXTERNAL MODULE: ./src/Code/prism/prism.empty
-                var G = n(74);
-        var j =  n.n(G);
+                var j = n(74);
+        var H =  n.n(j);
         // CONCATENATED MODULE: ./src/utils/updateReactRef.ts
         /**
  * Updates a React ref. Callback refs and object refs (from `createRef` and `useRef`) are supported.
@@ -2497,7 +2990,7 @@
  * @param ref - The React callback or object ref. Can be `null` or `undefined`.
  * @param current - The new value of the ref.
  */
-        function H(e, t) {
+        function z(e, t) {
             if (e) {
                 if (typeof e === "function") {
                     e(t);
@@ -2510,8 +3003,8 @@
             }
         }
         // CONCATENATED MODULE: ./src/Code/Code.tsx
-        function z() {
-            return z = Object.assign ? Object.assign.bind() : function(e) {
+        function W() {
+            return W = Object.assign ? Object.assign.bind() : function(e) {
                 for (var t = 1; t < arguments.length; t++) {
                     var n = arguments[t];
                     for (var r in n) {
@@ -2519,43 +3012,43 @@
                     }
                 }
                 return e;
-            }, z.apply(null, arguments);
+            }, W.apply(null, arguments);
         }
         function Y(e, t) {
-            return V(e) || K(e, t) || W(e, t) || X();
+            return V(e) || Z(e, t) || X(e, t) || q();
         }
-        function X() {
+        function q() {
             throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
         }
-        function W(e, t) {
+        function X(e, t) {
             if (e) {
-                if ("string" == typeof e) return q(e, t);
+                if ("string" == typeof e) return K(e, t);
                 var n = {}.toString.call(e).slice(8, -1);
-                return "Object" === n && e.constructor && (n = e.constructor.name), "Map" === n || "Set" === n ? Array.from(e) : "Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? q(e, t) : void 0;
+                return "Object" === n && e.constructor && (n = e.constructor.name), "Map" === n || "Set" === n ? Array.from(e) : "Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? K(e, t) : void 0;
             }
         }
-        function q(e, t) {
+        function K(e, t) {
             (null == t || t > e.length) && (t = e.length);
             for (var n = 0, r = Array(t); n < t; n++) {
                 r[n] = e[n];
             }
             return r;
         }
-        function K(e, t) {
+        function Z(e, t) {
             var n = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
             if (null != n) {
-                var r, a, i, s, o = [], l = !0, u = !1;
+                var r, a, s, i, o = [], l = !0, u = !1;
                 try {
-                    if (i = (n = n.call(e)).next, 0 === t) {
+                    if (s = (n = n.call(e)).next, 0 === t) {
                         if (Object(n) !== n) return;
                         l = !1;
-                    } else for (;!(l = (r = i.call(n)).done) && (o.push(r.value), o.length !== t); l = !0) {
+                    } else for (;!(l = (r = s.call(n)).done) && (o.push(r.value), o.length !== t); l = !0) {
                     }
                 } catch (e) {
                     u = !0, a = e;
                 } finally {
                     try {
-                        if (!l && null != n["return"] && (s = n["return"](), Object(s) !== s)) return;
+                        if (!l && null != n["return"] && (i = n["return"](), Object(i) !== i)) return;
                     } finally {
                         if (u) throw a;
                     }
@@ -2566,13 +3059,13 @@
         function V(e) {
             if (Array.isArray(e)) return e;
         }
-        function Z(e, t) {
+        function J(e, t) {
             if (null == e) return {};
             var n, r, a = Q(e, t);
             if (Object.getOwnPropertySymbols) {
-                var i = Object.getOwnPropertySymbols(e);
-                for (r = 0; r < i.length; r++) {
-                    n = i[r], -1 === t.indexOf(n) && {}.propertyIsEnumerable.call(e, n) && (a[n] = e[n]);
+                var s = Object.getOwnPropertySymbols(e);
+                for (r = 0; r < s.length; r++) {
+                    n = s[r], -1 === t.indexOf(n) && {}.propertyIsEnumerable.call(e, n) && (a[n] = e[n]);
                 }
             }
             return a;
@@ -2592,74 +3085,74 @@
         // auto formatting. The import below points to an empty file which is replaced at build
         // time, see ./prism/build-isolated-prism.js for details.
         // typed as 'prismjs'
-                var J = [ "bash", "clike", "css", "html", "json", "javascript", "js", "jsx", "typescript", "ts", "tsx", "markup", "mathml", "plain", "plaintext", "splunk-spl", "sql", "svg", "text", "txt", "xml", "yaml", "yml" ];
-        function ee(e) {
+                var ee = [ "bash", "c", "clike", "cpp", "cs", "csharp", "css", "html", "javascript", "js", "json", "jsx", "markup", "mathml", "plain", "plaintext", "powershell", "py", "python", "sh", "shell", "splunk-spl", "sql", "svg", "text", "ts", "tsx", "txt", "typescript", "xml", "yaml", "yml" ];
+        function te(e) {
             return [ "plain", "plaintext", "text", "txt" ].includes(e);
         }
-        function te(e, t) {
-            if (ee(t)) {
-                return j().tokenize(e, {});
+        function ne(e, t) {
+            if (te(t)) {
+                return H().tokenize(e, {});
             }
-            return j().tokenize(e, j().languages[t]);
+            return H().tokenize(e, H().languages[t]);
         }
-        var ne = {
+        var re = {
             containerAppearance: m().oneOf([ "none", "section" ]),
             elementRef: m().oneOfType([ m().func, m().object ]),
             indentChars: m().number,
-            language: m().oneOf(J),
-            languageFallback: m().oneOf(J),
+            language: m().oneOf(ee),
+            languageFallback: m().oneOf(ee),
             lineHighlights: m().string,
             lineNumberStart: m().number,
             showIndentGuide: m().bool,
             showLineNumbers: m().bool,
             value: m().string
         };
-        function re(n) {
-            var r = n.containerAppearance, a = r === void 0 ? "none" : r, s = n.elementRef, l = n.indentChars, c = l === void 0 ? 4 : l, d = n.language, f = n.languageFallback, m = f === void 0 ? "javascript" : f, v = n.lineHighlights, h = n.lineNumberStart, E = n.showIndentGuide, b = E === void 0 ? true : E, y = n.showLineNumbers, I = n.value, N = I === void 0 ? "" : I, x = Z(n, [ "containerAppearance", "elementRef", "indentChars", "language", "languageFallback", "lineHighlights", "lineNumberStart", "showIndentGuide", "showLineNumbers", "value" ]);
+        function ae(n) {
+            var r = n.containerAppearance, a = r === void 0 ? "none" : r, i = n.elementRef, l = n.indentChars, c = l === void 0 ? 4 : l, d = n.language, f = n.languageFallback, m = f === void 0 ? "javascript" : f, b = n.lineHighlights, v = n.lineNumberStart, E = n.showIndentGuide, y = E === void 0 ? true : E, S = n.showLineNumbers, A = n.value, I = A === void 0 ? "" : A, w = J(n, [ "containerAppearance", "elementRef", "indentChars", "language", "languageFallback", "lineHighlights", "lineNumberStart", "showIndentGuide", "showLineNumbers", "value" ]);
             // @docs-props-type CodePropsBase
-                        var R = (0, e.useRef)(null);
-            var k = (0, e.useState)(undefined), L = Y(k, 2), F = L[0], w = L[1];
-            var C = (0, B["default"])(R), D = C.width, P = C.height;
+                        var N = (0, e.useRef)(null);
+            var O = (0, e.useState)(undefined), _ = Y(O, 2), L = _[0], F = _[1];
+            var C = h()(N), D = C.width, P = C.height;
             var $ = (0, e.useCallback)((function(e) {
-                H(R, e);
-                H(s, e);
-            }), [ s ]);
+                z(N, e);
+                z(i, e);
+            }), [ i ]);
             (0, e.useEffect)((function() {
-                var e = R.current;
+                var e = N.current;
                 if (e) {
                     var t = e.scrollHeight > Math.round(P);
                     var n = e.scrollWidth > Math.round(D);
                     var r = t || n;
-                    w(r ? 0 : undefined);
+                    F(r ? 0 : undefined);
                 }
-            }), [ R, D, P ]);
-            var U = p()(" ", c);
-            var G = function e(n) {
+            }), [ N, D, P ]);
+            var B = p()(" ", c);
+            var M = function e(n) {
                 var r = Math.floor(n / c);
                 var a = n % c;
-                var i = g()(r, (function(e) {
+                var s = g()(r, (function(e) {
                     
                     return t().createElement(T, {
                         key: e.toString()
-                    }, U);
+                    }, B);
                 }));
                 if (a) {
-                    i.push(p()(" ", a));
+                    s.push(p()(" ", a));
                 }
-                return i;
+                return s;
             };
-            var j = u()(J, d) > -1;
+            var j = d ? u()(ee, d) > -1 : true;
             (0, e.useEffect)((function() {
                 // a fix for SUI-5425, where the Markdown component doesn't pass a valid language in some circumstances
                 if (false) {}
             }), [ j, d, m ]);
-            var X = j && d ? d : m;
-            var W = te(N, X);
-            var q = ee(X);
+            var H = j && d ? d : m;
+            var q = ne(I, H);
+            var X = te(H);
             var K = function e(n) {
-                return i()(n).map((function(n, r) {
+                return s()(n).map((function(n, r) {
                     if (typeof n === "string") {
-                        if (!b) {
+                        if (!y) {
                             return n;
                         }
                         var a = n.split("\n");
@@ -2668,50 +3161,50 @@
                         }
                         return o()(a.map((function(e, n) {
                             var a = n === 0 ? [] : [ "\n" ];
-                            var i = e.match(/^(\s+)(.*)/);
-                            if (!i) {
+                            var s = e.match(/^(\s+)(.*)/);
+                            if (!s) {
                                 a.push(e);
                             } else {
                                 a.push( t().createElement("span", {
                                     key: "".concat(r.toString(), ":").concat(n.toString())
-                                }, G(i[1].length)), i[2]);
+                                }, M(s[1].length)), s[2]);
                             }
                             return a;
                         })));
                     }
-                    var i = typeof n.content === "string" ? n.content : e(n.content);
+                    var s = typeof n.content === "string" ? n.content : e(n.content);
                     
                     // eslint-disable-next-line react/no-array-index-key
-                    return t().createElement(O, {
+                    return t().createElement(R, {
                         "data-part-type": n.type,
                         partType: n.type,
                         key: r.toString()
-                    }, i);
+                    }, s);
                 }));
             };
-            var V = K(W);
+            var Z = K(q);
             
-            return t().createElement(A, z({
+            return t().createElement(x, W({
                 "data-test": "code",
                 ref: $,
-                tabIndex: F,
+                tabIndex: L,
                 $containerAppearance: a,
-                $showLineNumbers: y,
-                $counterReset: h && h - 1
-            }, x), y &&  t().createElement(M, {
+                $showLineNumbers: S,
+                $counterReset: v && v - 1
+            }, w), S &&  t().createElement(G, {
                 containerAppearance: a,
-                value: N
-            }),  t().createElement(S, {
-                className: "language-".concat(X),
-                $isPlaintext: q
-            }, V), v &&  t().createElement(_, {
+                value: I
+            }),  t().createElement(k, {
+                className: "language-".concat(H),
+                $isPlaintext: X
+            }, Z), b &&  t().createElement(U, {
                 containerAppearance: a,
                 width: D,
-                highlight: v
+                highlight: b
             }));
         }
-        re.propTypes = ne;
-        /* harmony default export */        const ae = re;
+        ae.propTypes = re;
+        /* harmony default export */        const se = ae;
     }) // CONCATENATED MODULE: ./src/Code/index.ts
     ();
     module.exports = r;