@useknest/widget-core 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/index.js

@@ -1,43 +1,71 @@
-import { createClient as R } from "@supabase/supabase-js";
-import { marked as S } from "marked";
-import * as p from "@sentry/browser";
-const b = "https://useknest.com", I = "/api/v1";
-function C(e = b) {
-  return `${e}${I}/chat-messages`;
+import { createClient as he } from "@supabase/supabase-js";
+import { marked as H } from "marked";
+import * as j from "@sentry/browser";
+const le = "https://useknest.com", ce = "/api/v1", Ge = "https://lghrsugmhzpccpriqhrx.supabase.co", Be = "sb_publishable_-KUwilDA78QM849gk662FA_kEzMezNS";
+function me(a = le) {
+  return `${a}${ce}/chat-messages`;
 }
-function U(e = b) {
-  return `${e}${I}/widget-config`;
+function Ae(a = le) {
+  return `${a}${ce}/widget-config`;
 }
-const L = "Sorry, I didn't get a response.", m = "Unknown error occurred", W = "This domain is not authorized. Please add it to your allowed origins in the Knest dashboard.", N = "https://useknest.com/default-avatar.svg", P = "#0d7a7f", v = "Hi! I'm your AI assistant. I'm trained to answer questions about your documentation. How can I help you today?", G = [
+const Se = "Sorry, I didn't get a response.", Q = "Unknown error occurred", Te = "This domain is not authorized. Please add it to your allowed origins in the Knest dashboard.", be = "This chatbot has reached its usage limit. Please contact the site owner to upgrade their plan.", He = "https://useknest.com/default-avatar.svg", Ye = "#3b82f6", We = "Hi! I'm your AI assistant. I'm trained to answer questions about your documentation. How can I help you today?", ze = [
   "How do I get started?",
   "What features are available?",
   "How do I integrate this?"
-];
-async function H(e, o) {
+], Ie = "knest-widget-config-", ye = 1440 * 60 * 1e3;
+function K(a) {
+  return Ie + a;
+}
+function Re(a, g) {
+  try {
+    const e = localStorage.getItem(K(a));
+    if (!e) return null;
+    const { config: u, cachedAt: c } = JSON.parse(e);
+    return Date.now() - c > ye ? (localStorage.removeItem(K(a)), null) : (g && u.updatedAt, u);
+  } catch {
+    return null;
+  }
+}
+function Oe(a, g) {
+  try {
+    const e = { config: g, cachedAt: Date.now() };
+    localStorage.setItem(K(a), JSON.stringify(e));
+  } catch {
+  }
+}
+async function ee(a, g) {
   try {
-    const t = await fetch(U(o), {
+    const e = await fetch(Ae(g), {
       method: "GET",
       headers: {
-        "X-Api-Key": e
+        "X-Api-Key": a
       }
     });
-    if (t.ok)
-      return { config: await t.json(), error: null };
-    if (t.status === 401 || t.status === 403) {
-      const n = await t.json().catch(() => ({}));
-      return console.warn("Widget config auth error:", t.status, n), { config: null, error: "auth" };
+    if (e.ok) {
+      const c = await e.json();
+      return Oe(a, c), { config: c, error: null };
     }
-    const s = await t.text();
-    return console.warn("Failed to fetch widget config:", t.status, s), { config: null, error: "network" };
-  } catch (t) {
-    return console.error("Error fetching widget config:", t), { config: null, error: "network" };
+    if (e.status === 401 || e.status === 403) {
+      const c = await e.json().catch(() => ({}));
+      return console.warn("Widget config auth error:", e.status, c), { config: null, error: "auth" };
+    }
+    const u = await e.text();
+    return console.warn("Failed to fetch widget config:", e.status, u), { config: null, error: "network" };
+  } catch (e) {
+    return console.error("Error fetching widget config:", e), { config: null, error: "network" };
   }
 }
-let a = null, d = !1, u = null;
-async function K(e, o) {
-  return u || (d && a ? !0 : (u = (async () => {
+async function Xe(a, g, e) {
+  const u = Re(a);
+  return u ? (e && ee(a, g).then((c) => {
+    c.config && c.config.updatedAt !== u.updatedAt && e(c.config);
+  }), { config: u, error: null }) : ee(a, g);
+}
+let k = null, B = !1, x = null;
+async function je(a, g) {
+  return x || (B && k ? !0 : (x = (async () => {
     try {
-      a = R(e, o, {
+      k = he(a, g, {
         auth: {
           // Persist session in localStorage for cross-page persistence.
           persistSession: !0,
@@ -46,112 +74,1934 @@ async function K(e, o) {
         }
       });
       const {
-        data: { session: t }
-      } = await a.auth.getSession();
-      if (t)
-        return d = !0, !0;
-      const { error: s } = await a.auth.signInAnonymously();
-      return s ? (console.error("Widget auth error:", s.message), !1) : (d = !0, !0);
-    } catch (t) {
-      return console.error("Widget auth initialization failed:", t), !1;
+        data: { session: e }
+      } = await k.auth.getSession();
+      if (e)
+        return B = !0, !0;
+      const { error: u } = await k.auth.signInAnonymously();
+      return u ? (console.error("Widget auth error:", u.message), !1) : (B = !0, !0);
+    } catch (e) {
+      return console.error("Widget auth initialization failed:", e), !1;
     } finally {
-      u = null;
+      x = null;
     }
-  })(), u));
+  })(), x));
 }
-async function D() {
-  if (!a)
+async function ve() {
+  if (!k)
     return null;
   const {
-    data: { session: e }
-  } = await a.auth.getSession();
-  return e?.access_token || null;
+    data: { session: a }
+  } = await k.auth.getSession();
+  return a?.access_token || null;
 }
-function O() {
-  return d;
+function Ne() {
+  return B;
 }
-function j() {
-  return a;
+function Fe() {
+  return k;
 }
-async function z(e) {
-  const { publishableApiKey: o, content: t, threadId: s, callbacks: n, baseUrl: T } = e;
+async function Ke(a) {
+  const { publishableApiKey: g, content: e, threadId: u, callbacks: c, baseUrl: h } = a;
   try {
-    if (!O())
+    if (!Ne())
       throw new Error("Widget not authenticated. Call initWidgetAuth() first.");
-    const i = await D();
-    if (!i)
+    const S = await ve();
+    if (!S)
       throw new Error("No access token available. Please refresh and try again.");
-    const l = { content: t };
-    s && (l.threadId = s);
-    const c = await fetch(C(T), {
+    const o = { content: e };
+    u && (o.threadId = u);
+    const m = await fetch(me(h), {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-Api-Key": o,
-        Authorization: `Bearer ${i}`
+        "X-Api-Key": g,
+        Authorization: `Bearer ${S}`
       },
       credentials: "include",
-      body: JSON.stringify(l)
+      body: JSON.stringify(o)
     });
-    if (!c.ok) {
-      if (c.status === 401 || c.status === 403)
-        throw new Error(W);
-      const h = await c.json();
-      throw new Error(h.error || "Failed to send message");
+    if (!m.ok) {
+      if (m.status === 401 || m.status === 403)
+        throw new Error(Te);
+      if (m.status === 429) {
+        const N = await m.json();
+        throw N.code === "USAGE_LIMIT_EXCEEDED" ? new Error(be) : new Error(N.error || "Rate limited");
+      }
+      const C = await m.json();
+      throw new Error(C.error || "Failed to send message");
     }
-    const w = c.body?.getReader();
-    if (!w)
+    const F = m.body?.getReader();
+    if (!F)
       throw new Error("Response body is not readable");
-    const _ = new TextDecoder();
-    let f = "", E = !1;
+    const D = new TextDecoder();
+    let v = "", R = !1;
     for (; ; ) {
-      const { done: h, value: k } = await w.read();
-      if (h) break;
-      f += _.decode(k, { stream: !0 });
-      const y = f.split(`
+      const { done: C, value: N } = await F.read();
+      if (C) break;
+      v += D.decode(N, { stream: !0 });
+      const T = v.split(`
 `);
-      f = y.pop() || "";
-      for (const g of y)
-        if (g.startsWith("data: "))
+      v = T.pop() || "";
+      for (const E of T)
+        if (E.startsWith("data: "))
           try {
-            const r = JSON.parse(g.slice(6));
-            if (r.type === "init")
-              r.threadId && n.onInit && n.onInit(r.threadId);
-            else if (r.type === "content")
-              r.content && (E = !0, n.onContent(r.content));
-            else if (r.type === "complete")
-              n.onComplete && n.onComplete(r.sources || []);
-            else if (r.type === "error")
-              throw new Error(r.error || m);
-          } catch (r) {
-            console.error("Error parsing SSE data:", r, g);
+            const p = JSON.parse(E.slice(6));
+            if (p.type === "init")
+              p.threadId && c.onInit && c.onInit(p.threadId);
+            else if (p.type === "content")
+              p.content && (R = !0, c.onContent(p.content));
+            else if (p.type === "complete")
+              c.onComplete && c.onComplete(p.sources || []);
+            else if (p.type === "done")
+              p.humanTakeover && (R = !0), c.onDone && c.onDone({ humanTakeover: p.humanTakeover });
+            else if (p.type === "error")
+              throw new Error(p.error || Q);
+          } catch (p) {
+            console.error("Error parsing SSE data:", p, E);
           }
     }
-    E || n.onError(L);
-  } catch (i) {
-    const l = i instanceof Error ? i.message : m;
-    n.onError(l);
+    R || c.onError(Se);
+  } catch (S) {
+    const o = S instanceof Error ? S.message : Q;
+    c.onError(o);
   }
 }
-S.setOptions({
+var te = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Le(a) {
+  return a && a.__esModule && Object.prototype.hasOwnProperty.call(a, "default") ? a.default : a;
+}
+var X = { exports: {} }, ne;
+function we() {
+  return ne || (ne = 1, (function(a) {
+    var g = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {};
+    /**
+     * Prism: Lightweight, robust, elegant syntax highlighting
+     *
+     * @license MIT <https://opensource.org/licenses/MIT>
+     * @author Lea Verou <https://lea.verou.me>
+     * @namespace
+     * @public
+     */
+    var e = (function(u) {
+      var c = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, h = 0, S = {}, o = {
+        /**
+         * 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
+         * additional languages or plugins yourself.
+         *
+         * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
+         *
+         * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.manual = true;
+         * // add a new <script> to load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        manual: u.Prism && u.Prism.manual,
+        /**
+         * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
+         * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
+         * own worker, you don't want it to do this.
+         *
+         * By setting this value to `true`, Prism will not add its own listeners to the worker.
+         *
+         * You obviously have to change this value before Prism executes. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.disableWorkerMessageHandler = true;
+         * // Load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        disableWorkerMessageHandler: u.Prism && u.Prism.disableWorkerMessageHandler,
+        /**
+         * A namespace for utility methods.
+         *
+         * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+         * change or disappear at any time.
+         *
+         * @namespace
+         * @memberof Prism
+         */
+        util: {
+          encode: function n(t) {
+            return t instanceof m ? new m(t.type, n(t.content), t.alias) : Array.isArray(t) ? t.map(n) : t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+          },
+          /**
+           * Returns the name of the type of the given value.
+           *
+           * @param {any} o
+           * @returns {string}
+           * @example
+           * type(null)      === 'Null'
+           * type(undefined) === 'Undefined'
+           * type(123)       === 'Number'
+           * type('foo')     === 'String'
+           * type(true)      === 'Boolean'
+           * type([1, 2])    === 'Array'
+           * type({})        === 'Object'
+           * type(String)    === 'Function'
+           * type(/abc+/)    === 'RegExp'
+           */
+          type: function(n) {
+            return Object.prototype.toString.call(n).slice(8, -1);
+          },
+          /**
+           * Returns a unique number for the given object. Later calls will still return the same number.
+           *
+           * @param {Object} obj
+           * @returns {number}
+           */
+          objId: function(n) {
+            return n.__id || Object.defineProperty(n, "__id", { value: ++h }), n.__id;
+          },
+          /**
+           * Creates a deep clone of the given object.
+           *
+           * The main intended use of this function is to clone language definitions.
+           *
+           * @param {T} o
+           * @param {Record<number, any>} [visited]
+           * @returns {T}
+           * @template T
+           */
+          clone: function n(t, r) {
+            r = r || {};
+            var s, i;
+            switch (o.util.type(t)) {
+              case "Object":
+                if (i = o.util.objId(t), r[i])
+                  return r[i];
+                s = /** @type {Record<string, any>} */
+                {}, r[i] = s;
+                for (var d in t)
+                  t.hasOwnProperty(d) && (s[d] = n(t[d], r));
+                return (
+                  /** @type {any} */
+                  s
+                );
+              case "Array":
+                return i = o.util.objId(t), r[i] ? r[i] : (s = [], r[i] = s, /** @type {Array} */
+                /** @type {any} */
+                t.forEach(function(f, l) {
+                  s[l] = n(f, r);
+                }), /** @type {any} */
+                s);
+              default:
+                return t;
+            }
+          },
+          /**
+           * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
+           *
+           * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
+           *
+           * @param {Element} element
+           * @returns {string}
+           */
+          getLanguage: function(n) {
+            for (; n; ) {
+              var t = c.exec(n.className);
+              if (t)
+                return t[1].toLowerCase();
+              n = n.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(n, t) {
+            n.className = n.className.replace(RegExp(c, "gi"), ""), n.classList.add("language-" + t);
+          },
+          /**
+           * Returns the script element that is currently executing.
+           *
+           * This does __not__ work for line script element.
+           *
+           * @returns {HTMLScriptElement | null}
+           */
+          currentScript: function() {
+            if (typeof document > "u")
+              return null;
+            if (document.currentScript && document.currentScript.tagName === "SCRIPT")
+              return (
+                /** @type {any} */
+                document.currentScript
+              );
+            try {
+              throw new Error();
+            } catch (s) {
+              var n = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(s.stack) || [])[1];
+              if (n) {
+                var t = document.getElementsByTagName("script");
+                for (var r in t)
+                  if (t[r].src == n)
+                    return t[r];
+              }
+              return null;
+            }
+          },
+          /**
+           * Returns whether a given class is active for `element`.
+           *
+           * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
+           * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
+           * given class is just the given class with a `no-` prefix.
+           *
+           * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
+           * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
+           * ancestors have the given class or the negated version of it, then the default activation will be returned.
+           *
+           * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
+           * version of it, the class is considered active.
+           *
+           * @param {Element} element
+           * @param {string} className
+           * @param {boolean} [defaultActivation=false]
+           * @returns {boolean}
+           */
+          isActive: function(n, t, r) {
+            for (var s = "no-" + t; n; ) {
+              var i = n.classList;
+              if (i.contains(t))
+                return !0;
+              if (i.contains(s))
+                return !1;
+              n = n.parentElement;
+            }
+            return !!r;
+          }
+        },
+        /**
+         * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+         *
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        languages: {
+          /**
+           * The grammar for plain, unformatted text.
+           */
+          plain: S,
+          plaintext: S,
+          text: S,
+          txt: S,
+          /**
+           * Creates a deep copy of the language with the given id and appends the given tokens.
+           *
+           * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+           * will be overwritten at its original position.
+           *
+           * ## Best practices
+           *
+           * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+           * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+           * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+           *
+           * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+           * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+           *
+           * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+           * @param {Grammar} redef The new tokens to append.
+           * @returns {Grammar} The new language created.
+           * @public
+           * @example
+           * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+           *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+           *     // at its original position
+           *     'comment': { ... },
+           *     // CSS doesn't have a 'color' token, so this token will be appended
+           *     'color': /\b(?:red|green|blue)\b/
+           * });
+           */
+          extend: function(n, t) {
+            var r = o.util.clone(o.languages[n]);
+            for (var s in t)
+              r[s] = t[s];
+            return r;
+          },
+          /**
+           * Inserts tokens _before_ another token in a language definition or any other grammar.
+           *
+           * ## Usage
+           *
+           * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+           * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+           * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+           * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+           * this:
+           *
+           * ```js
+           * Prism.languages.markup.style = {
+           *     // token
+           * };
+           * ```
+           *
+           * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+           * before existing tokens. For the CSS example above, you would use it like this:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'cdata', {
+           *     'style': {
+           *         // token
+           *     }
+           * });
+           * ```
+           *
+           * ## Special cases
+           *
+           * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+           * will be ignored.
+           *
+           * This behavior can be used to insert tokens after `before`:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'comment', {
+           *     'comment': Prism.languages.markup.comment,
+           *     // tokens after 'comment'
+           * });
+           * ```
+           *
+           * ## Limitations
+           *
+           * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+           * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+           * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+           * deleting properties which is necessary to insert at arbitrary positions.
+           *
+           * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+           * Instead, it will create a new object and replace all references to the target object with the new one. This
+           * can be done without temporarily deleting properties, so the iteration order is well-defined.
+           *
+           * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+           * you hold the target object in a variable, then the value of the variable will not change.
+           *
+           * ```js
+           * var oldMarkup = Prism.languages.markup;
+           * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+           *
+           * assert(oldMarkup !== Prism.languages.markup);
+           * assert(newMarkup === Prism.languages.markup);
+           * ```
+           *
+           * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+           * object to be modified.
+           * @param {string} before The key to insert before.
+           * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+           * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+           * object to be modified.
+           *
+           * Defaults to `Prism.languages`.
+           * @returns {Grammar} The new grammar object.
+           * @public
+           */
+          insertBefore: function(n, t, r, s) {
+            s = s || /** @type {any} */
+            o.languages;
+            var i = s[n], d = {};
+            for (var f in i)
+              if (i.hasOwnProperty(f)) {
+                if (f == t)
+                  for (var l in r)
+                    r.hasOwnProperty(l) && (d[l] = r[l]);
+                r.hasOwnProperty(f) || (d[f] = i[f]);
+              }
+            var A = s[n];
+            return s[n] = d, o.languages.DFS(o.languages, function(b, L) {
+              L === A && b != n && (this[b] = d);
+            }), d;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function n(t, r, s, i) {
+            i = i || {};
+            var d = o.util.objId;
+            for (var f in t)
+              if (t.hasOwnProperty(f)) {
+                r.call(t, f, t[f], s || f);
+                var l = t[f], A = o.util.type(l);
+                A === "Object" && !i[d(l)] ? (i[d(l)] = !0, n(l, r, null, i)) : A === "Array" && !i[d(l)] && (i[d(l)] = !0, n(l, r, f, i));
+              }
+          }
+        },
+        plugins: {},
+        /**
+         * This is the most high-level function in Prism’s API.
+         * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
+         * each one of them.
+         *
+         * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
+         *
+         * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
+         * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
+         * @memberof Prism
+         * @public
+         */
+        highlightAll: function(n, t) {
+          o.highlightAllUnder(document, n, t);
+        },
+        /**
+         * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
+         * {@link Prism.highlightElement} on each one of them.
+         *
+         * The following hooks will be run:
+         * 1. `before-highlightall`
+         * 2. `before-all-elements-highlight`
+         * 3. All hooks of {@link Prism.highlightElement} for each element.
+         *
+         * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
+         * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
+         * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
+         * @memberof Prism
+         * @public
+         */
+        highlightAllUnder: function(n, t, r) {
+          var s = {
+            callback: r,
+            container: n,
+            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+          };
+          o.hooks.run("before-highlightall", s), s.elements = Array.prototype.slice.apply(s.container.querySelectorAll(s.selector)), o.hooks.run("before-all-elements-highlight", s);
+          for (var i = 0, d; d = s.elements[i++]; )
+            o.highlightElement(d, t === !0, s.callback);
+        },
+        /**
+         * Highlights the code inside a single element.
+         *
+         * The following hooks will be run:
+         * 1. `before-sanity-check`
+         * 2. `before-highlight`
+         * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
+         * 4. `before-insert`
+         * 5. `after-highlight`
+         * 6. `complete`
+         *
+         * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
+         * the element's language.
+         *
+         * @param {Element} element The element containing the code.
+         * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
+         * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
+         * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
+         * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
+         *
+         * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
+         * asynchronous highlighting to work. You can build your own bundle on the
+         * [Download page](https://prismjs.com/download.html).
+         * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
+         * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
+         * @memberof Prism
+         * @public
+         */
+        highlightElement: function(n, t, r) {
+          var s = o.util.getLanguage(n), i = o.languages[s];
+          o.util.setLanguage(n, s);
+          var d = n.parentElement;
+          d && d.nodeName.toLowerCase() === "pre" && o.util.setLanguage(d, s);
+          var f = n.textContent, l = {
+            element: n,
+            language: s,
+            grammar: i,
+            code: f
+          };
+          function A(L) {
+            l.highlightedCode = L, o.hooks.run("before-insert", l), l.element.innerHTML = l.highlightedCode, o.hooks.run("after-highlight", l), o.hooks.run("complete", l), r && r.call(l.element);
+          }
+          if (o.hooks.run("before-sanity-check", l), d = l.element.parentElement, d && d.nodeName.toLowerCase() === "pre" && !d.hasAttribute("tabindex") && d.setAttribute("tabindex", "0"), !l.code) {
+            o.hooks.run("complete", l), r && r.call(l.element);
+            return;
+          }
+          if (o.hooks.run("before-highlight", l), !l.grammar) {
+            A(o.util.encode(l.code));
+            return;
+          }
+          if (t && u.Worker) {
+            var b = new Worker(o.filename);
+            b.onmessage = function(L) {
+              A(L.data);
+            }, b.postMessage(JSON.stringify({
+              language: l.language,
+              code: l.code,
+              immediateClose: !0
+            }));
+          } else
+            A(o.highlight(l.code, l.grammar, l.language));
+        },
+        /**
+         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+         * and the language definitions to use, and returns a string with the HTML produced.
+         *
+         * The following hooks will be run:
+         * 1. `before-tokenize`
+         * 2. `after-tokenize`
+         * 3. `wrap`: On each {@link Token}.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @param {string} language The name of the language definition passed to `grammar`.
+         * @returns {string} The highlighted HTML.
+         * @memberof Prism
+         * @public
+         * @example
+         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+         */
+        highlight: function(n, t, r) {
+          var s = {
+            code: n,
+            grammar: t,
+            language: r
+          };
+          if (o.hooks.run("before-tokenize", s), !s.grammar)
+            throw new Error('The language "' + s.language + '" has no grammar.');
+          return s.tokens = o.tokenize(s.code, s.grammar), o.hooks.run("after-tokenize", s), m.stringify(o.util.encode(s.tokens), s.language);
+        },
+        /**
+         * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+         * and the language definitions to use, and returns an array with the tokenized code.
+         *
+         * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+         *
+         * This method could be useful in other contexts as well, as a very crude parser.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @returns {TokenStream} An array of strings and tokens, a token stream.
+         * @memberof Prism
+         * @public
+         * @example
+         * let code = `var foo = 0;`;
+         * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+         * tokens.forEach(token => {
+         *     if (token instanceof Prism.Token && token.type === 'number') {
+         *         console.log(`Found numeric literal: ${token.content}`);
+         *     }
+         * });
+         */
+        tokenize: function(n, t) {
+          var r = t.rest;
+          if (r) {
+            for (var s in r)
+              t[s] = r[s];
+            delete t.rest;
+          }
+          var i = new v();
+          return R(i, i.head, n), D(n, i, t, i.head, 0), N(i);
+        },
+        /**
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        hooks: {
+          all: {},
+          /**
+           * Adds the given callback to the list of callbacks for the given hook.
+           *
+           * The callback will be invoked when the hook it is registered for is run.
+           * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+           *
+           * One callback function can be registered to multiple hooks and the same hook multiple times.
+           *
+           * @param {string} name The name of the hook.
+           * @param {HookCallback} callback The callback function which is given environment variables.
+           * @public
+           */
+          add: function(n, t) {
+            var r = o.hooks.all;
+            r[n] = r[n] || [], r[n].push(t);
+          },
+          /**
+           * Runs a hook invoking all registered callbacks with the given environment variables.
+           *
+           * Callbacks will be invoked synchronously and in the order in which they were registered.
+           *
+           * @param {string} name The name of the hook.
+           * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+           * @public
+           */
+          run: function(n, t) {
+            var r = o.hooks.all[n];
+            if (!(!r || !r.length))
+              for (var s = 0, i; i = r[s++]; )
+                i(t);
+          }
+        },
+        Token: m
+      };
+      u.Prism = o;
+      function m(n, t, r, s) {
+        this.type = n, this.content = t, this.alias = r, this.length = (s || "").length | 0;
+      }
+      m.stringify = function n(t, r) {
+        if (typeof t == "string")
+          return t;
+        if (Array.isArray(t)) {
+          var s = "";
+          return t.forEach(function(A) {
+            s += n(A, r);
+          }), s;
+        }
+        var i = {
+          type: t.type,
+          content: n(t.content, r),
+          tag: "span",
+          classes: ["token", t.type],
+          attributes: {},
+          language: r
+        }, d = t.alias;
+        d && (Array.isArray(d) ? Array.prototype.push.apply(i.classes, d) : i.classes.push(d)), o.hooks.run("wrap", i);
+        var f = "";
+        for (var l in i.attributes)
+          f += " " + l + '="' + (i.attributes[l] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + i.tag + ' class="' + i.classes.join(" ") + '"' + f + ">" + i.content + "</" + i.tag + ">";
+      };
+      function F(n, t, r, s) {
+        n.lastIndex = t;
+        var i = n.exec(r);
+        if (i && s && i[1]) {
+          var d = i[1].length;
+          i.index += d, i[0] = i[0].slice(d);
+        }
+        return i;
+      }
+      function D(n, t, r, s, i, d) {
+        for (var f in r)
+          if (!(!r.hasOwnProperty(f) || !r[f])) {
+            var l = r[f];
+            l = Array.isArray(l) ? l : [l];
+            for (var A = 0; A < l.length; ++A) {
+              if (d && d.cause == f + "," + A)
+                return;
+              var b = l[A], L = b.inside, q = !!b.lookbehind, V = !!b.greedy, ge = b.alias;
+              if (V && !b.pattern.global) {
+                var pe = b.pattern.toString().match(/[imsuy]*$/)[0];
+                b.pattern = RegExp(b.pattern.source, pe + "g");
+              }
+              for (var Z = b.pattern || b, I = s.next, O = i; I !== t.tail && !(d && O >= d.reach); O += I.value.length, I = I.next) {
+                var _ = I.value;
+                if (t.length > n.length)
+                  return;
+                if (!(_ instanceof m)) {
+                  var U = 1, y;
+                  if (V) {
+                    if (y = F(Z, O, n, q), !y || y.index >= n.length)
+                      break;
+                    var M = y.index, fe = y.index + y[0].length, w = O;
+                    for (w += I.value.length; M >= w; )
+                      I = I.next, w += I.value.length;
+                    if (w -= I.value.length, O = w, I.value instanceof m)
+                      continue;
+                    for (var P = I; P !== t.tail && (w < fe || typeof P.value == "string"); P = P.next)
+                      U++, w += P.value.length;
+                    U--, _ = n.slice(O, w), y.index -= O;
+                  } else if (y = F(Z, 0, _, q), !y)
+                    continue;
+                  var M = y.index, $ = y[0], Y = _.slice(0, M), J = _.slice(M + $.length), W = O + _.length;
+                  d && W > d.reach && (d.reach = W);
+                  var G = I.prev;
+                  Y && (G = R(t, G, Y), O += Y.length), C(t, G, U);
+                  var Ee = new m(f, L ? o.tokenize($, L) : $, ge, $);
+                  if (I = R(t, G, Ee), J && R(t, I, J), U > 1) {
+                    var z = {
+                      cause: f + "," + A,
+                      reach: W
+                    };
+                    D(n, t, r, I.prev, O, z), d && z.reach > d.reach && (d.reach = z.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function v() {
+        var n = { value: null, prev: null, next: null }, t = { value: null, prev: n, next: null };
+        n.next = t, this.head = n, this.tail = t, this.length = 0;
+      }
+      function R(n, t, r) {
+        var s = t.next, i = { value: r, prev: t, next: s };
+        return t.next = i, s.prev = i, n.length++, i;
+      }
+      function C(n, t, r) {
+        for (var s = t.next, i = 0; i < r && s !== n.tail; i++)
+          s = s.next;
+        t.next = s, s.prev = t, n.length -= i;
+      }
+      function N(n) {
+        for (var t = [], r = n.head.next; r !== n.tail; )
+          t.push(r.value), r = r.next;
+        return t;
+      }
+      if (!u.document)
+        return u.addEventListener && (o.disableWorkerMessageHandler || u.addEventListener("message", function(n) {
+          var t = JSON.parse(n.data), r = t.language, s = t.code, i = t.immediateClose;
+          u.postMessage(o.highlight(s, o.languages[r], r)), i && u.close();
+        }, !1)), o;
+      var T = o.util.currentScript();
+      T && (o.filename = T.src, T.hasAttribute("data-manual") && (o.manual = !0));
+      function E() {
+        o.manual || o.highlightAll();
+      }
+      if (!o.manual) {
+        var p = document.readyState;
+        p === "loading" || p === "interactive" && T && T.defer ? document.addEventListener("DOMContentLoaded", E) : window.requestAnimationFrame ? window.requestAnimationFrame(E) : window.setTimeout(E, 16);
+      }
+      return o;
+    })(g);
+    a.exports && (a.exports = e), typeof te < "u" && (te.Prism = e), e.languages.markup = {
+      comment: {
+        pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+        greedy: !0
+      },
+      prolog: {
+        pattern: /<\?[\s\S]+?\?>/,
+        greedy: !0
+      },
+      doctype: {
+        // https://www.w3.org/TR/xml/#NT-doctypedecl
+        pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+        greedy: !0,
+        inside: {
+          "internal-subset": {
+            pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: null
+            // see below
+          },
+          string: {
+            pattern: /"[^"]*"|'[^']*'/,
+            greedy: !0
+          },
+          punctuation: /^<!|>$|[[\]]/,
+          "doctype-tag": /^DOCTYPE/i,
+          name: /[^\s<>'"]+/
+        }
+      },
+      cdata: {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        greedy: !0
+      },
+      tag: {
+        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+        greedy: !0,
+        inside: {
+          tag: {
+            pattern: /^<\/?[^\s>\/]+/,
+            inside: {
+              punctuation: /^<\/?/,
+              namespace: /^[^\s>\/:]+:/
+            }
+          },
+          "special-attr": [],
+          "attr-value": {
+            pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+            inside: {
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                {
+                  pattern: /^(\s*)["']|["']$/,
+                  lookbehind: !0
+                }
+              ]
+            }
+          },
+          punctuation: /\/?>/,
+          "attr-name": {
+            pattern: /[^\s>\/]+/,
+            inside: {
+              namespace: /^[^\s>\/:]+:/
+            }
+          }
+        }
+      },
+      entity: [
+        {
+          pattern: /&[\da-z]{1,8};/i,
+          alias: "named-entity"
+        },
+        /&#x?[\da-f]{1,8};/i
+      ]
+    }, e.languages.markup.tag.inside["attr-value"].inside.entity = e.languages.markup.entity, e.languages.markup.doctype.inside["internal-subset"].inside = e.languages.markup, e.hooks.add("wrap", function(u) {
+      u.type === "entity" && (u.attributes.title = u.content.replace(/&amp;/, "&"));
+    }), Object.defineProperty(e.languages.markup.tag, "addInlined", {
+      /**
+       * Adds an inlined language to markup.
+       *
+       * An example of an inlined language is CSS with `<style>` tags.
+       *
+       * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addInlined('style', 'css');
+       */
+      value: function(c, h) {
+        var S = {};
+        S["language-" + h] = {
+          pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+          lookbehind: !0,
+          inside: e.languages[h]
+        }, S.cdata = /^<!\[CDATA\[|\]\]>$/i;
+        var o = {
+          "included-cdata": {
+            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+            inside: S
+          }
+        };
+        o["language-" + h] = {
+          pattern: /[\s\S]+/,
+          inside: e.languages[h]
+        };
+        var m = {};
+        m[c] = {
+          pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+            return c;
+          }), "i"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: o
+        }, e.languages.insertBefore("markup", "cdata", m);
+      }
+    }), Object.defineProperty(e.languages.markup.tag, "addAttribute", {
+      /**
+       * Adds an pattern to highlight languages embedded in HTML attributes.
+       *
+       * An example of an inlined language is CSS with `style` attributes.
+       *
+       * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addAttribute('style', 'css');
+       */
+      value: function(u, c) {
+        e.languages.markup.tag.inside["special-attr"].push({
+          pattern: RegExp(
+            /(^|["'\s])/.source + "(?:" + u + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+            "i"
+          ),
+          lookbehind: !0,
+          inside: {
+            "attr-name": /^[^\s=]+/,
+            "attr-value": {
+              pattern: /=[\s\S]+/,
+              inside: {
+                value: {
+                  pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                  lookbehind: !0,
+                  alias: [c, "language-" + c],
+                  inside: e.languages[c]
+                },
+                punctuation: [
+                  {
+                    pattern: /^=/,
+                    alias: "attr-equals"
+                  },
+                  /"|'/
+                ]
+              }
+            }
+          }
+        });
+      }
+    }), e.languages.html = e.languages.markup, e.languages.mathml = e.languages.markup, e.languages.svg = e.languages.markup, e.languages.xml = e.languages.extend("markup", {}), e.languages.ssml = e.languages.xml, e.languages.atom = e.languages.xml, e.languages.rss = e.languages.xml, (function(u) {
+      var c = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+      u.languages.css = {
+        comment: /\/\*[\s\S]*?\*\//,
+        atrule: {
+          pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + c.source + ")*?" + /(?:;|(?=\s*\{))/.source),
+          inside: {
+            rule: /^@[\w-]+/,
+            "selector-function-argument": {
+              pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+              lookbehind: !0,
+              alias: "selector"
+            },
+            keyword: {
+              pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+              lookbehind: !0
+            }
+            // See rest below
+          }
+        },
+        url: {
+          // https://drafts.csswg.org/css-values-3/#urls
+          pattern: RegExp("\\burl\\((?:" + c.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+          greedy: !0,
+          inside: {
+            function: /^url/i,
+            punctuation: /^\(|\)$/,
+            string: {
+              pattern: RegExp("^" + c.source + "$"),
+              alias: "url"
+            }
+          }
+        },
+        selector: {
+          pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + c.source + ")*(?=\\s*\\{)"),
+          lookbehind: !0
+        },
+        string: {
+          pattern: c,
+          greedy: !0
+        },
+        property: {
+          pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+          lookbehind: !0
+        },
+        important: /!important\b/i,
+        function: {
+          pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+          lookbehind: !0
+        },
+        punctuation: /[(){};:,]/
+      }, u.languages.css.atrule.inside.rest = u.languages.css;
+      var h = u.languages.markup;
+      h && (h.tag.addInlined("style", "css"), h.tag.addAttribute("style", "css"));
+    })(e), e.languages.clike = {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[.\\]/
+        }
+      },
+      keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: /\b\w+(?=\()/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+      punctuation: /[{}[\];(),.:]/
+    }, e.languages.javascript = e.languages.extend("clike", {
+      "class-name": [
+        e.languages.clike["class-name"],
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+          lookbehind: !0
+        }
+      ],
+      keyword: [
+        {
+          pattern: /((?:^|\})\s*)catch\b/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+          lookbehind: !0
+        }
+      ],
+      // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+      function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+      number: {
+        pattern: RegExp(
+          /(^|[^\w$])/.source + "(?:" + // constant
+          (/NaN|Infinity/.source + "|" + // binary integer
+          /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
+          /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
+          /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
+          /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
+          /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
+        ),
+        lookbehind: !0
+      },
+      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+    }), e.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, e.languages.insertBefore("javascript", "keyword", {
+      regex: {
+        pattern: RegExp(
+          // lookbehind
+          // eslint-disable-next-line regexp/no-dupe-characters-character-class
+          /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
+          // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
+          // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
+          // with the only syntax, so we have to define 2 different regex patterns.
+          /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
+          /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
+          /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          "regex-source": {
+            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: e.languages.regex
+          },
+          "regex-delimiter": /^\/|\/$/,
+          "regex-flags": /^[a-z]+$/
+        }
+      },
+      // This must be declared before keyword because we use "function" inside the look-forward
+      "function-variable": {
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+        alias: "function"
+      },
+      parameter: [
+        {
+          pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        {
+          pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        }
+      ],
+      constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+    }), e.languages.insertBefore("javascript", "string", {
+      hashbang: {
+        pattern: /^#!.*/,
+        greedy: !0,
+        alias: "comment"
+      },
+      "template-string": {
+        pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+        greedy: !0,
+        inside: {
+          "template-punctuation": {
+            pattern: /^`|`$/,
+            alias: "string"
+          },
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              },
+              rest: e.languages.javascript
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      "string-property": {
+        pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      }
+    }), e.languages.insertBefore("javascript", "operator", {
+      "literal-property": {
+        pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+        lookbehind: !0,
+        alias: "property"
+      }
+    }), e.languages.markup && (e.languages.markup.tag.addInlined("script", "javascript"), e.languages.markup.tag.addAttribute(
+      /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
+      "javascript"
+    )), e.languages.js = e.languages.javascript, (function() {
+      if (typeof e > "u" || typeof document > "u")
+        return;
+      Element.prototype.matches || (Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector);
+      var u = "Loading…", c = function(T, E) {
+        return "✖ Error " + T + " while fetching file: " + E;
+      }, h = "✖ Error: File does not exist or is empty", S = {
+        js: "javascript",
+        py: "python",
+        rb: "ruby",
+        ps1: "powershell",
+        psm1: "powershell",
+        sh: "bash",
+        bat: "batch",
+        h: "c",
+        tex: "latex"
+      }, o = "data-src-status", m = "loading", F = "loaded", D = "failed", v = "pre[data-src]:not([" + o + '="' + F + '"]):not([' + o + '="' + m + '"])';
+      function R(T, E, p) {
+        var n = new XMLHttpRequest();
+        n.open("GET", T, !0), n.onreadystatechange = function() {
+          n.readyState == 4 && (n.status < 400 && n.responseText ? E(n.responseText) : n.status >= 400 ? p(c(n.status, n.statusText)) : p(h));
+        }, n.send(null);
+      }
+      function C(T) {
+        var E = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(T || "");
+        if (E) {
+          var p = Number(E[1]), n = E[2], t = E[3];
+          return n ? t ? [p, Number(t)] : [p, void 0] : [p, p];
+        }
+      }
+      e.hooks.add("before-highlightall", function(T) {
+        T.selector += ", " + v;
+      }), e.hooks.add("before-sanity-check", function(T) {
+        var E = (
+          /** @type {HTMLPreElement} */
+          T.element
+        );
+        if (E.matches(v)) {
+          T.code = "", E.setAttribute(o, m);
+          var p = E.appendChild(document.createElement("CODE"));
+          p.textContent = u;
+          var n = E.getAttribute("data-src"), t = T.language;
+          if (t === "none") {
+            var r = (/\.(\w+)$/.exec(n) || [, "none"])[1];
+            t = S[r] || r;
+          }
+          e.util.setLanguage(p, t), e.util.setLanguage(E, t);
+          var s = e.plugins.autoloader;
+          s && s.loadLanguages(t), R(
+            n,
+            function(i) {
+              E.setAttribute(o, F);
+              var d = C(E.getAttribute("data-range"));
+              if (d) {
+                var f = i.split(/\r\n?|\n/g), l = d[0], A = d[1] == null ? f.length : d[1];
+                l < 0 && (l += f.length), l = Math.max(0, Math.min(l - 1, f.length)), A < 0 && (A += f.length), A = Math.max(0, Math.min(A, f.length)), i = f.slice(l, A).join(`
+`), E.hasAttribute("data-start") || E.setAttribute("data-start", String(l + 1));
+              }
+              p.textContent = i, e.highlightElement(p);
+            },
+            function(i) {
+              E.setAttribute(o, D), p.textContent = i;
+            }
+          );
+        }
+      }), e.plugins.fileHighlight = {
+        /**
+         * Executes the File Highlight plugin for all matching `pre` elements under the given container.
+         *
+         * Note: Elements which are already loaded or currently loading will not be touched by this method.
+         *
+         * @param {ParentNode} [container=document]
+         */
+        highlight: function(E) {
+          for (var p = (E || document).querySelectorAll(v), n = 0, t; t = p[n++]; )
+            e.highlightElement(t);
+        }
+      };
+      var N = !1;
+      e.fileHighlight = function() {
+        N || (console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."), N = !0), e.plugins.fileHighlight.highlight.apply(this, arguments);
+      };
+    })();
+  })(X)), X.exports;
+}
+var Ce = we();
+const ae = /* @__PURE__ */ Le(Ce);
+var re = {}, se;
+function ke() {
+  return se || (se = 1, Prism.languages.python = {
+    comment: {
+      pattern: /(^|[^\\])#.*/,
+      lookbehind: !0,
+      greedy: !0
+    },
+    "string-interpolation": {
+      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+          lookbehind: !0,
+          inside: {
+            "format-spec": {
+              pattern: /(:)[^:(){}]+(?=\}$)/,
+              lookbehind: !0
+            },
+            "conversion-option": {
+              pattern: /![sra](?=[:}]$)/,
+              alias: "punctuation"
+            },
+            rest: null
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    "triple-quoted-string": {
+      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+      greedy: !0,
+      alias: "string"
+    },
+    string: {
+      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+      greedy: !0
+    },
+    function: {
+      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+      lookbehind: !0
+    },
+    "class-name": {
+      pattern: /(\bclass\s+)\w+/i,
+      lookbehind: !0
+    },
+    decorator: {
+      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+      lookbehind: !0,
+      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: /[{}[\];(),.:]/
+  }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python), re;
+}
+ke();
+var ie = {}, oe;
+function De() {
+  return oe || (oe = 1, (function(a) {
+    a.languages.typescript = a.languages.extend("javascript", {
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+    }), a.languages.typescript.keyword.push(
+      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+      // keywords that have to be followed by an identifier
+      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+      // This is for `import type *, {}`
+      /\btype\b(?=\s*(?:[\{*]|$))/
+    ), delete a.languages.typescript.parameter, delete a.languages.typescript["literal-property"];
+    var g = a.languages.extend("typescript", {});
+    delete g["class-name"], a.languages.typescript["class-name"].inside = g, a.languages.insertBefore("typescript", "function", {
+      decorator: {
+        pattern: /@[$\w\xA0-\uFFFF]+/,
+        inside: {
+          at: {
+            pattern: /^@/,
+            alias: "operator"
+          },
+          function: /^[\s\S]+/
+        }
+      },
+      "generic-function": {
+        // e.g. foo<T extends "bar" | "baz">( ...
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+        greedy: !0,
+        inside: {
+          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+          generic: {
+            pattern: /<[\s\S]+/,
+            // everything after the first <
+            alias: "class-name",
+            inside: g
+          }
+        }
+      }
+    }), a.languages.ts = a.languages.typescript;
+  })(Prism)), ie;
+}
+De();
+(function(a) {
+  var g = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", e = {
+    pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+    lookbehind: !0,
+    alias: "punctuation",
+    // this looks reasonably well in all themes
+    inside: null
+    // see below
+  }, u = {
+    bash: e,
+    environment: {
+      pattern: RegExp("\\$" + g),
+      alias: "constant"
+    },
+    variable: [
+      // [0]: Arithmetic Environment
+      {
+        pattern: /\$?\(\([\s\S]+?\)\)/,
+        greedy: !0,
+        inside: {
+          // If there is a $ sign at the beginning highlight $(( and )) as variable
+          variable: [
+            {
+              pattern: /(^\$\(\([\s\S]+)\)\)/,
+              lookbehind: !0
+            },
+            /^\$\(\(/
+          ],
+          number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+          // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+          operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+          // If there is no $ sign at the beginning highlight (( and )) as punctuation
+          punctuation: /\(\(?|\)\)?|,|;/
+        }
+      },
+      // [1]: Command Substitution
+      {
+        pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+        greedy: !0,
+        inside: {
+          variable: /^\$\(|^`|\)$|`$/
+        }
+      },
+      // [2]: Brace expansion
+      {
+        pattern: /\$\{[^}]+\}/,
+        greedy: !0,
+        inside: {
+          operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+          punctuation: /[\[\]]/,
+          environment: {
+            pattern: RegExp("(\\{)" + g),
+            lookbehind: !0,
+            alias: "constant"
+          }
+        }
+      },
+      /\$(?:\w+|[#?*!@$])/
+    ],
+    // Escape sequences from echo and printf's manuals, and escaped quotes.
+    entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+  };
+  a.languages.bash = {
+    shebang: {
+      pattern: /^#!\s*\/.*/,
+      alias: "important"
+    },
+    comment: {
+      pattern: /(^|[^"{\\$])#.*/,
+      lookbehind: !0
+    },
+    "function-name": [
+      // a) function foo {
+      // b) foo() {
+      // c) function foo() {
+      // but not “foo {”
+      {
+        // a) and c)
+        pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      {
+        // b)
+        pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+        alias: "function"
+      }
+    ],
+    // Highlight variable names as variables in for and select beginnings.
+    "for-or-select": {
+      pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+      alias: "variable",
+      lookbehind: !0
+    },
+    // Highlight variable names as variables in the left-hand part
+    // of assignments (“=” and “+=”).
+    "assign-left": {
+      pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+      inside: {
+        environment: {
+          pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + g),
+          lookbehind: !0,
+          alias: "constant"
+        }
+      },
+      alias: "variable",
+      lookbehind: !0
+    },
+    // Highlight parameter names as variables
+    parameter: {
+      pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
+      alias: "variable",
+      lookbehind: !0
+    },
+    string: [
+      // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+      {
+        pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: u
+      },
+      // Here-document with quotes around the tag
+      // → No expansion (so no “inside”).
+      {
+        pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          bash: e
+        }
+      },
+      // “Normal” string
+      {
+        // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+        pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: u
+      },
+      {
+        // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+        pattern: /(^|[^$\\])'[^']*'/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      {
+        // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+        pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+        greedy: !0,
+        inside: {
+          entity: u.entity
+        }
+      }
+    ],
+    environment: {
+      pattern: RegExp("\\$?" + g),
+      alias: "constant"
+    },
+    variable: u.variable,
+    function: {
+      pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+      lookbehind: !0
+    },
+    keyword: {
+      pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+      lookbehind: !0
+    },
+    // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+    builtin: {
+      pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+      lookbehind: !0,
+      // Alias added to make those easier to distinguish from strings.
+      alias: "class-name"
+    },
+    boolean: {
+      pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+      lookbehind: !0
+    },
+    "file-descriptor": {
+      pattern: /\B&\d\b/,
+      alias: "important"
+    },
+    operator: {
+      // Lots of redirections here, but not just that.
+      pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+      inside: {
+        "file-descriptor": {
+          pattern: /^\d/,
+          alias: "important"
+        }
+      }
+    },
+    punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+    number: {
+      pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+      lookbehind: !0
+    }
+  }, e.inside = a.languages.bash;
+  for (var c = [
+    "comment",
+    "function-name",
+    "for-or-select",
+    "assign-left",
+    "parameter",
+    "string",
+    "environment",
+    "function",
+    "keyword",
+    "builtin",
+    "boolean",
+    "file-descriptor",
+    "operator",
+    "punctuation",
+    "number"
+  ], h = u.variable[1].inside, S = 0; S < c.length; S++)
+    h[c[S]] = a.languages.bash[c[S]];
+  a.languages.sh = a.languages.bash, a.languages.shell = a.languages.bash;
+})(Prism);
+Prism.languages.json = {
+  property: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+    lookbehind: !0,
+    greedy: !0
+  },
+  string: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+    lookbehind: !0,
+    greedy: !0
+  },
+  comment: {
+    pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+    greedy: !0
+  },
+  number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+  punctuation: /[{}[\],]/,
+  operator: /:/,
+  boolean: /\b(?:false|true)\b/,
+  null: {
+    pattern: /\bnull\b/,
+    alias: "keyword"
+  }
+};
+Prism.languages.webmanifest = Prism.languages.json;
+(function(a) {
+  var g = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+  a.languages.css = {
+    comment: /\/\*[\s\S]*?\*\//,
+    atrule: {
+      pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + g.source + ")*?" + /(?:;|(?=\s*\{))/.source),
+      inside: {
+        rule: /^@[\w-]+/,
+        "selector-function-argument": {
+          pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+          lookbehind: !0,
+          alias: "selector"
+        },
+        keyword: {
+          pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+          lookbehind: !0
+        }
+        // See rest below
+      }
+    },
+    url: {
+      // https://drafts.csswg.org/css-values-3/#urls
+      pattern: RegExp("\\burl\\((?:" + g.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+      greedy: !0,
+      inside: {
+        function: /^url/i,
+        punctuation: /^\(|\)$/,
+        string: {
+          pattern: RegExp("^" + g.source + "$"),
+          alias: "url"
+        }
+      }
+    },
+    selector: {
+      pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + g.source + ")*(?=\\s*\\{)"),
+      lookbehind: !0
+    },
+    string: {
+      pattern: g,
+      greedy: !0
+    },
+    property: {
+      pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+      lookbehind: !0
+    },
+    important: /!important\b/i,
+    function: {
+      pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+      lookbehind: !0
+    },
+    punctuation: /[(){};:,]/
+  }, a.languages.css.atrule.inside.rest = a.languages.css;
+  var e = a.languages.markup;
+  e && (e.tag.addInlined("style", "css"), e.tag.addAttribute("style", "css"));
+})(Prism);
+Prism.languages.markup = {
+  comment: {
+    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+    greedy: !0
+  },
+  prolog: {
+    pattern: /<\?[\s\S]+?\?>/,
+    greedy: !0
+  },
+  doctype: {
+    // https://www.w3.org/TR/xml/#NT-doctypedecl
+    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+    greedy: !0,
+    inside: {
+      "internal-subset": {
+        pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: !0
+      },
+      punctuation: /^<!|>$|[[\]]/,
+      "doctype-tag": /^DOCTYPE/i,
+      name: /[^\s<>'"]+/
+    }
+  },
+  cdata: {
+    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+    greedy: !0
+  },
+  tag: {
+    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+    greedy: !0,
+    inside: {
+      tag: {
+        pattern: /^<\/?[^\s>\/]+/,
+        inside: {
+          punctuation: /^<\/?/,
+          namespace: /^[^\s>\/:]+:/
+        }
+      },
+      "special-attr": [],
+      "attr-value": {
+        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+        inside: {
+          punctuation: [
+            {
+              pattern: /^=/,
+              alias: "attr-equals"
+            },
+            {
+              pattern: /^(\s*)["']|["']$/,
+              lookbehind: !0
+            }
+          ]
+        }
+      },
+      punctuation: /\/?>/,
+      "attr-name": {
+        pattern: /[^\s>\/]+/,
+        inside: {
+          namespace: /^[^\s>\/:]+:/
+        }
+      }
+    }
+  },
+  entity: [
+    {
+      pattern: /&[\da-z]{1,8};/i,
+      alias: "named-entity"
+    },
+    /&#x?[\da-f]{1,8};/i
+  ]
+};
+Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity;
+Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup;
+Prism.hooks.add("wrap", function(a) {
+  a.type === "entity" && (a.attributes.title = a.content.replace(/&amp;/, "&"));
+});
+Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
+  /**
+   * Adds an inlined language to markup.
+   *
+   * An example of an inlined language is CSS with `<style>` tags.
+   *
+   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+   * case insensitive.
+   * @param {string} lang The language key.
+   * @example
+   * addInlined('style', 'css');
+   */
+  value: function(g, e) {
+    var u = {};
+    u["language-" + e] = {
+      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+      lookbehind: !0,
+      inside: Prism.languages[e]
+    }, u.cdata = /^<!\[CDATA\[|\]\]>$/i;
+    var c = {
+      "included-cdata": {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        inside: u
+      }
+    };
+    c["language-" + e] = {
+      pattern: /[\s\S]+/,
+      inside: Prism.languages[e]
+    };
+    var h = {};
+    h[g] = {
+      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+        return g;
+      }), "i"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: c
+    }, Prism.languages.insertBefore("markup", "cdata", h);
+  }
+});
+Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
+  /**
+   * Adds an pattern to highlight languages embedded in HTML attributes.
+   *
+   * An example of an inlined language is CSS with `style` attributes.
+   *
+   * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+   * case insensitive.
+   * @param {string} lang The language key.
+   * @example
+   * addAttribute('style', 'css');
+   */
+  value: function(a, g) {
+    Prism.languages.markup.tag.inside["special-attr"].push({
+      pattern: RegExp(
+        /(^|["'\s])/.source + "(?:" + a + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+        "i"
+      ),
+      lookbehind: !0,
+      inside: {
+        "attr-name": /^[^\s=]+/,
+        "attr-value": {
+          pattern: /=[\s\S]+/,
+          inside: {
+            value: {
+              pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+              lookbehind: !0,
+              alias: [g, "language-" + g],
+              inside: Prism.languages[g]
+            },
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              /"|'/
+            ]
+          }
+        }
+      }
+    });
+  }
+});
+Prism.languages.html = Prism.languages.markup;
+Prism.languages.mathml = Prism.languages.markup;
+Prism.languages.svg = Prism.languages.markup;
+Prism.languages.xml = Prism.languages.extend("markup", {});
+Prism.languages.ssml = Prism.languages.xml;
+Prism.languages.atom = Prism.languages.xml;
+Prism.languages.rss = Prism.languages.xml;
+Prism.languages.sql = {
+  comment: {
+    pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+    lookbehind: !0
+  },
+  variable: [
+    {
+      pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+      greedy: !0
+    },
+    /@[\w.$]+/
+  ],
+  string: {
+    pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+    greedy: !0,
+    lookbehind: !0
+  },
+  identifier: {
+    pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+    greedy: !0,
+    lookbehind: !0,
+    inside: {
+      punctuation: /^`|`$/
+    }
+  },
+  function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+  // Should we highlight user defined functions too?
+  keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+  boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+  number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+  operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+  punctuation: /[;[\]()`,.]/
+};
+const _e = {
+  js: "javascript",
+  ts: "typescript",
+  shell: "bash",
+  sh: "bash",
+  html: "markup",
+  xml: "markup"
+};
+H.setOptions({
   breaks: !0,
   gfm: !0
 });
-function B(e) {
-  return e.split(/\n\s*\n/).map((t) => t.trim()).filter((t) => t).map((t) => ({
-    html: S.parseInline(t)
-  }));
-}
-const F = "https://005d25250a41bd0071570b0c0a2b2c4d@o4510467570073600.ingest.us.sentry.io/4510472944156672";
-let A = !1;
-function $() {
-  A || (p.init({
-    dsn: F,
+const de = new H.Renderer();
+de.code = ({ text: a, lang: g }) => {
+  const e = g ? _e[g] || g : "plaintext", u = ae.languages[e];
+  if (u) {
+    const h = ae.highlight(a, u, e);
+    return `<pre><code class="language-${e}">${h}</code></pre>`;
+  }
+  return `<pre><code>${a.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</code></pre>`;
+};
+H.use({ renderer: de });
+function qe(a) {
+  return H.parse(a);
+}
+const Pe = "https://005d25250a41bd0071570b0c0a2b2c4d@o4510467570073600.ingest.us.sentry.io/4510472944156672", xe = [
+  "@useknest",
+  "useknest",
+  "widget-core",
+  "widget-web",
+  "widget-react",
+  "widget.umd.js",
+  "widget.js",
+  "knest"
+];
+function Ue(a) {
+  if (a.tags?.source === "knest-widget") return !0;
+  const g = a.exception?.values?.[0]?.stacktrace?.frames;
+  return !g || g.length === 0 ? !1 : g.some((e) => {
+    const u = e.filename || "";
+    return xe.some((c) => u.includes(c));
+  });
+}
+let ue = !1;
+function Ve() {
+  ue || (j.init({
+    dsn: Pe,
     // Only capture errors, not performance data.
     tracesSampleRate: 0,
-    // Minimal breadcrumbs to reduce noise.
     integrations: [
-      p.breadcrumbsIntegration({
+      j.breadcrumbsIntegration({
         console: !1,
         dom: !0,
         fetch: !0,
@@ -164,35 +2014,55 @@ function $() {
       tags: {
         source: "knest-widget"
       }
+    },
+    // Filter out errors that don't originate from our widget code.
+    beforeSend(a) {
+      return Ue(a) ? a : null;
     }
-  }), A = !0);
+  }), ue = !0);
 }
-function X(e, o) {
-  const t = typeof e == "string" ? new Error(e) : e;
-  p.captureException(t, {
+function Ze(a, g) {
+  const e = typeof a == "string" ? new Error(a) : a;
+  j.captureException(e, {
     tags: { source: "knest-widget" },
-    extra: o
+    extra: g
   });
 }
+function Je(a, g) {
+  const e = Fe();
+  if (!e)
+    return () => {
+    };
+  const u = e.channel(`thread:${a}`).on("broadcast", { event: "new-message" }, (c) => {
+    g(c.payload);
+  }).subscribe();
+  return () => {
+    u.unsubscribe();
+  };
+}
 export {
-  I as API_PATH,
-  W as AUTH_ERROR_MESSAGE,
-  N as DEFAULT_AVATAR_URL,
-  b as DEFAULT_BASE_URL,
-  P as DEFAULT_BRAND_COLOR,
-  m as DEFAULT_ERROR_MESSAGE,
-  G as DEFAULT_EXAMPLE_QUESTIONS,
-  v as DEFAULT_WELCOME_MESSAGE,
-  L as FALLBACK_ERROR_MESSAGE,
-  X as captureWidgetException,
-  H as fetchWidgetConfig,
-  B as formatContent,
-  D as getAccessToken,
-  C as getChatApiUrl,
-  U as getConfigApiUrl,
-  j as getSupabaseClient,
-  K as initWidgetAuth,
-  $ as initWidgetSentry,
-  O as isAuthenticated,
-  z as streamChatMessage
+  ce as API_PATH,
+  Te as AUTH_ERROR_MESSAGE,
+  He as DEFAULT_AVATAR_URL,
+  le as DEFAULT_BASE_URL,
+  Ye as DEFAULT_BRAND_COLOR,
+  Q as DEFAULT_ERROR_MESSAGE,
+  ze as DEFAULT_EXAMPLE_QUESTIONS,
+  We as DEFAULT_WELCOME_MESSAGE,
+  Se as FALLBACK_ERROR_MESSAGE,
+  Be as PUBLIC_SUPABASE_ANON_KEY,
+  Ge as PUBLIC_SUPABASE_URL,
+  be as USAGE_LIMIT_MESSAGE,
+  Ze as captureWidgetException,
+  Xe as fetchWidgetConfig,
+  qe as formatContent,
+  ve as getAccessToken,
+  me as getChatApiUrl,
+  Ae as getConfigApiUrl,
+  Fe as getSupabaseClient,
+  je as initWidgetAuth,
+  Ve as initWidgetSentry,
+  Ne as isAuthenticated,
+  Ke as streamChatMessage,
+  Je as subscribeToThread
 };