@andares/pdeditor 0.2.0

package/dist/index.js

@@ -0,0 +1,2174 @@
+function ye(n, a, { signal: e, edges: t } = {}) {
+  let l, c = null;
+  const v = t != null && t.includes("leading"), o = t == null || t.includes("trailing"), p = () => {
+    c !== null && (n.apply(l, c), l = void 0, c = null);
+  }, A = () => {
+    o && p(), S();
+  };
+  let b = null;
+  const k = () => {
+    b != null && clearTimeout(b), b = setTimeout(() => {
+      b = null, A();
+    }, a);
+  }, $ = () => {
+    b !== null && (clearTimeout(b), b = null);
+  }, S = () => {
+    $(), l = void 0, c = null;
+  }, w = () => {
+    p();
+  }, y = function(...f) {
+    if (e != null && e.aborted) return;
+    l = this, c = f;
+    const x = b == null;
+    k(), v && x && p();
+  };
+  return y.schedule = k, y.cancel = S, y.flush = w, e == null || e.addEventListener("abort", S, { once: !0 }), y;
+}
+const ne = { position: "relative", boxSizing: "border-box", overflow: "hidden", fontSize: "16px", fontFamily: 'Menlo, Consolas, "Liberation Mono", Monaco, "Lucida Console", monospace' }, be = { lineHeight: "inherit", whiteSpace: "pre-wrap", wordBreak: "keep-all", overflowWrap: "break-word", background: "none", position: "absolute", width: "100%", height: "100%", zIndex: "1", resize: "none", caretColor: "currentColor", padding: "inherit", outline: "none", fontSize: "inherit", fontFamily: "inherit", letterSpacing: "inherit", boxSizing: "border-box", border: "none", top: "0px", left: "0px", color: "inherit", overflow: "hidden", "-webkit-font-smoothing": "antialiased", "-webkit-text-fill-color": "transparent" }, xe = { lineHeight: "inherit", position: "relative", whiteSpace: "pre-wrap", wordBreak: "keep-all", padding: "0", width: "100%", margin: "0", pointerEvents: "none", boxSizing: "border-box", overflowWrap: "break-word", fontFamily: "inherit" }, ke = { lineHeight: "inherit", position: "absolute", width: "100%", height: "100%", whiteSpace: "pre-wrap", wordBreak: "keep-all", padding: "inherit", margin: "0", top: "0px", left: "0px", pointerEvents: "none", boxSizing: "border-box", overflowWrap: "break-word", fontFamily: "inherit" }, ge = (n) => pe(n);
+function re(n) {
+  const a = Array.isArray(n) ? n : [n];
+  return a.length === 0 ? ge : (e) => a.reduce((t, l, c) => l(t, { html: c > 0 }), e);
+}
+class we {
+  constructor(a, e = {}) {
+    if (this.lines = null, !a) throw new Error("selector is not defined");
+    if (this.root = a instanceof Node ? a : document.querySelector(a), !this.root) throw new Error(`element with "${a}" selector is not exist`);
+    const t = { value: "", styles: {}, plugins: [], highlighter: ge }, { highlighters: l, ...c } = e;
+    this.options = { ...t, ...c, highlighter: l ? re(l) : t.highlighter }, this.options.value = this.options.value == null ? "" : String(this.options.value), this.init();
+  }
+  init() {
+    this.textarea = document.createElement("textarea"), this.textarea.setAttribute("spellcheck", "false"), this.textarea.setAttribute("autocapitalize", "off"), this.textarea.setAttribute("autocorrect", "off"), this.textarea.setAttribute("autocomplete", "off"), this.pre = document.createElement("pre");
+    const a = Object.keys(ne).concat(Object.keys(this.options.styles)).concat(["paddingLeft"]);
+    this.initialRootStyles = {};
+    const e = this.root.style;
+    a.forEach((t) => {
+      this.initialRootStyles[t] = e[t] || "";
+    }), Object.assign(this.root.style, ne, this.options.styles), Object.assign(this.textarea.style, be), Object.assign(this.pre.style, xe), this.basePaddingLeft = this.root.style.paddingLeft || "", this.root.appendChild(this.textarea), this.root.appendChild(this.pre), this.addTextareaEvents(), this.update({ value: this.options.value }), this.updateLines();
+  }
+  addTextareaEvents() {
+    this.handleEvent = (a) => {
+      if (a.type === "keydown" && this.textarea.readOnly) return;
+      const e = a;
+      if (e.isComposing || e.keyCode === 229) return;
+      const t = (function(l, c) {
+        const { value: v, selectionStart: o, selectionEnd: p } = c.target;
+        return l.reduce((A, b) => ({ ...A, ...b(A, c) }), { value: v, selectionStart: o, selectionEnd: p });
+      })(this.options.plugins, a);
+      this.update(t);
+    }, this.textarea.addEventListener("input", this.handleEvent), this.textarea.addEventListener("keydown", this.handleEvent), this.textarea.addEventListener("compositionend", this.handleEvent);
+  }
+  update(a) {
+    if (!this.textarea) return;
+    let { value: e, selectionStart: t, selectionEnd: l } = a;
+    e != null && (e = String(e), t == null && (t = this.textarea.selectionStart), l == null && (l = this.textarea.selectionEnd), this.textarea.value !== e && (this.textarea.value = e)), t != null && (this.textarea.selectionStart = t), l != null && (this.textarea.selectionEnd = l), e !== this.value && e != null && (this.value = e, this.render(), this.updateCallback && this.updateCallback(e));
+  }
+  updateOptions(a) {
+    if (!this.textarea) return;
+    const { highlighters: e, ...t } = a;
+    if (this.options = { ...this.options, ...t, highlighter: e ? re(e) : this.options.highlighter }, a.styles) {
+      const l = this.root.style;
+      Object.keys(a.styles).forEach((c) => {
+        c in this.initialRootStyles || (this.initialRootStyles[c] = l[c] || "");
+      }), Object.assign(this.root.style, a.styles), ("paddingLeft" in a.styles || "padding" in a.styles) && (this.basePaddingLeft = this.root.style.paddingLeft || "");
+    }
+    this.lines && !this.options.lineNumbers && (N(this.lines), this.lines = null, this.root.style.paddingLeft = this.basePaddingLeft), a.value != null && this.update({ value: a.value }), this.render();
+  }
+  render() {
+    const a = this.options.highlighter(this.value);
+    this.pre.innerHTML = a + "<br/>", this.updateLines();
+  }
+  updateLines() {
+    if (!this.options.lineNumbers) return;
+    this.lines || (this.lines = document.createElement("pre"), this.root.appendChild(this.lines), Object.assign(this.lines.style, ke));
+    const a = this.value.split(`
+`), e = a.length.toString().length;
+    this.root.style.paddingLeft = `${e + 1}ch`, this.lines.innerHTML = a.map((t, l) => `${`<span class="yace-line" style="position: absolute; opacity: .3; left: 0; width: ${e}ch; text-align: right">${1 + l}</span>`}${`<span style="color: transparent; pointer-events: none">${pe(t)}</span>`}`).join(`
+`);
+  }
+  destroy() {
+    this.textarea && (this.textarea.removeEventListener("input", this.handleEvent), this.textarea.removeEventListener("keydown", this.handleEvent), this.textarea.removeEventListener("compositionend", this.handleEvent), N(this.textarea), N(this.pre), N(this.lines), Object.assign(this.root.style, this.initialRootStyles), Object.assign(this, { textarea: null, pre: null, lines: null, updateCallback: null, handleEvent: null, initialRootStyles: null, options: null, root: null }));
+  }
+  onUpdate(a) {
+    this.updateCallback = a;
+  }
+}
+function N(n) {
+  n && n.parentNode && n.parentNode.removeChild(n);
+}
+function pe(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function B(n, a) {
+  const e = n, t = e.key.toLowerCase(), l = a.split("+"), c = l.slice(0, -1), v = l[l.length - 1];
+  return !(t !== v || c.includes("shift") !== e.shiftKey || c.includes("ctrl") !== e.ctrlKey || c.includes("alt") !== e.altKey || c.includes("meta") !== e.metaKey);
+}
+function ae(n, a) {
+  var l;
+  const t = n.slice(0, a).split(`
+`);
+  return { line: t.length - 1, col: ((l = t[t.length - 1]) == null ? void 0 : l.length) ?? 0 };
+}
+function W(n, a, e) {
+  var l;
+  let t = 0;
+  for (let c = 0; c < a; c++) t += (((l = n[c]) == null ? void 0 : l.length) ?? 0) + 1;
+  return t + e;
+}
+function Se() {
+  return (n, a) => {
+    var A;
+    if (a.type !== "keydown" || !B(a, "enter")) return;
+    const { value: e, selectionStart: t, selectionEnd: l } = n, c = e.slice(0, t).split(`
+`).pop() ?? "", v = ((A = /^\s*/.exec(c)) == null ? void 0 : A[0]) ?? "";
+    a.preventDefault();
+    const o = /^(\s*)-(?=\s|$)/.test(c), p = `
+${v}${o ? "- " : ""}`;
+    return {
+      value: e.slice(0, t) + p + e.slice(l),
+      selectionStart: t + p.length,
+      selectionEnd: t + p.length
+    };
+  };
+}
+function Ee(n) {
+  return /^(\s*)-(?=\s|$)/.test(n);
+}
+function ie(n, a) {
+  return n.startsWith(a) ? a.length : n.startsWith("	") ? 1 : 0;
+}
+function $e(n) {
+  return (a, e) => {
+    if (e.type !== "keydown") return;
+    const { value: t, selectionStart: l, selectionEnd: c } = a, v = t.split(`
+`), o = t.slice(0, l).split(`
+`).length - 1, p = t.slice(0, c).split(`
+`).length - 1, A = ae(t, l), b = ae(t, c);
+    if (B(e, "shift+tab")) {
+      e.preventDefault();
+      const k = v.map(
+        (f, x) => x >= o && x <= p ? f.slice(ie(f, n)) : f
+      ), $ = k.join(`
+`);
+      if ($ === t) return;
+      const S = (f) => {
+        const x = ie(v[f.line] ?? "", n);
+        return { line: f.line, col: Math.max(0, f.col - x) };
+      }, w = S(A), y = S(b);
+      return {
+        value: $,
+        selectionStart: W(k, w.line, w.col),
+        selectionEnd: W(k, y.line, y.col)
+      };
+    }
+    if (B(e, "tab")) {
+      e.preventDefault();
+      const k = v.map((w, y) => ({ l: w, i: y })).filter(({ i: w }) => w >= o && w <= p);
+      if (k.length > 0 && k.every(({ l: w }) => Ee(w)) || l !== c) {
+        const w = v.map(
+          (r, u) => u >= o && u <= p && r !== "" ? n + r : r
+        ), y = w.join(`
+`), f = (r) => {
+          const u = v[r.line] ?? "", d = r.line >= o && r.line <= p;
+          return {
+            line: r.line,
+            col: d && u !== "" ? r.col + n.length : r.col
+          };
+        }, x = f(A), i = f(b);
+        return {
+          value: y,
+          selectionStart: W(w, x.line, x.col),
+          selectionEnd: W(w, i.line, i.col)
+        };
+      }
+      const S = l + n.length;
+      return {
+        value: t.slice(0, l) + n + t.slice(c),
+        selectionStart: S,
+        selectionEnd: S
+      };
+    }
+  };
+}
+function Ae(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function Fe(n, a) {
+  const e = Math.min(n.length, a.length);
+  let t = 0;
+  for (; t < e && n.charCodeAt(t) === a.charCodeAt(t); ) t++;
+  return t;
+}
+function Le(n, a, e) {
+  let t = a.language ?? "pd";
+  const l = a.onValueChange;
+  let c = !1;
+  const v = a.indentUnit ?? "  ", o = new we(n, {
+    value: a.value ?? "",
+    lineNumbers: a.lineNumbers ?? !1,
+    styles: a.styles ?? {},
+    highlighters: [
+      a.highlight ? (s) => {
+        var g;
+        return ((g = a.highlight) == null ? void 0 : g.call(a, s, t)) ?? "";
+      } : e(t)
+    ],
+    // 编辑行为：pd 语义插件（续行补 `- `/保留缩进、序列项行 Tab 整行缩进/缩出）。
+    // 撤销/重做不在此接入 Yace history 插件（初始快照缺陷），由组件自实现（见下）。
+    plugins: [Se(), $e(v)]
+  });
+  o.onUpdate((s) => {
+    c || (r(s), l == null || l(s));
+  });
+  const p = o.textarea;
+  let A = !1;
+  const b = () => {
+    A = !0;
+  }, k = () => {
+    A = !1;
+  }, $ = () => {
+    A && (c = !0, o.update({
+      value: p.value,
+      selectionStart: p.selectionStart,
+      selectionEnd: p.selectionEnd
+    }), c = !1);
+  };
+  p.addEventListener("compositionstart", b), p.addEventListener("compositionend", k), p.addEventListener("input", $);
+  const S = 5, w = [
+    { value: o.value, selStart: -1, selEnd: -1 }
+  ], y = [], f = () => {
+    w.length > S + 1 && w.splice(1, 1);
+  }, i = ye((s) => {
+    const g = w[0];
+    if (g !== void 0 && g.selStart < 0 && g.value !== s.value) {
+      const h = Fe(g.value, s.value);
+      g.selStart = h, g.selEnd = h;
+    }
+    const m = w.at(-1);
+    m !== void 0 && m.value === s.value || (y.length = 0, w.push(s), f());
+  }, 1e3), r = (s) => {
+    const g = p.selectionStart, m = p.selectionEnd;
+    i({ value: s, selStart: g, selEnd: m });
+  }, u = (s) => {
+    const g = s.selStart >= 0 ? s.selStart : s.value.length, m = s.selEnd >= 0 ? s.selEnd : s.value.length;
+    c = !0, o.update({
+      value: s.value,
+      selectionStart: g,
+      selectionEnd: m
+    }), p.value === s.value && p.setSelectionRange(g, m), c = !1;
+  }, d = (s) => {
+    const g = s.ctrlKey || s.metaKey, m = s.key.toLowerCase();
+    if (!g || m !== "z" && m !== "y") return;
+    if (m === "y" || m === "z" && s.shiftKey) {
+      if (i.flush(), y.length === 0) return;
+      s.preventDefault();
+      const E = y.pop();
+      E !== void 0 && (w.push(E), f(), u(E));
+    } else {
+      if (i.flush(), w.length <= 1) return;
+      s.preventDefault();
+      const E = w.pop();
+      E !== void 0 && y.push(E);
+      const F = w.at(-1);
+      F !== void 0 && u(F);
+    }
+  };
+  return p.addEventListener("keydown", d), {
+    setValue(s) {
+      c = !0, o.update({ value: s }), c = !1;
+    },
+    getValue() {
+      return o.value;
+    },
+    setLanguage(s) {
+      t = s, o.updateOptions({
+        highlighters: [
+          a.highlight ? (g) => {
+            var m;
+            return ((m = a.highlight) == null ? void 0 : m.call(a, g, t)) ?? "";
+          } : e(t)
+        ]
+      });
+    },
+    destroy() {
+      i.cancel(), p.removeEventListener("compositionstart", b), p.removeEventListener("compositionend", k), p.removeEventListener("input", $), p.removeEventListener("keydown", d), o.destroy();
+    },
+    textarea: p
+  };
+}
+function X(n) {
+  const a = [];
+  let e = "", t = !1;
+  for (const l of n)
+    l === "`" ? t ? (a.push({ code: !0, seg: e + "`" }), e = "", t = !1) : (e && a.push({ code: !1, seg: e }), e = "`", t = !0) : e += l;
+  return e && a.push({ code: !1, seg: e }), a;
+}
+function Y(n) {
+  for (const { code: a, seg: e } of X(n))
+    if (!a && (e.includes(":-") || e.includes("：-")))
+      return !0;
+  return !1;
+}
+function V(n) {
+  let a = 0;
+  for (const { code: e, seg: t } of X(n)) {
+    if (!e) {
+      const l = t.indexOf(":");
+      if (l !== -1) return a + l;
+    }
+    a += t.length;
+  }
+  return -1;
+}
+function se(n) {
+  if (Y(n)) return null;
+  const a = V(n);
+  if (a <= 0) return null;
+  const e = n.slice(0, a), t = n.slice(a + 1);
+  if (/\s$/.test(e) || t !== "" && !/^\s/.test(t)) return null;
+  const l = t.trim();
+  return { key: e.trim(), value: l === "" ? void 0 : l };
+}
+function C(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+const T = {
+  key: "pd-key",
+  keyPunct: "pd-key-punct",
+  item: "pd-item",
+  section: "pd-section",
+  sep: "pd-sep",
+  ref: "pd-ref",
+  inlineCode: "pd-inline-code",
+  fence: "pd-fence"
+};
+function Ce(n) {
+  return `<span class="${T.inlineCode}">${C(n)}</span>`;
+}
+const le = /(?:^|\s):([^\s-][^\s]*)(?=\s|$)/g;
+function _e(n) {
+  let a = "", e = 0;
+  le.lastIndex = 0;
+  let t;
+  for (; (t = le.exec(n)) !== null; ) {
+    const l = /^\s/.test(t[0]) ? 1 : 0, c = t.index + l;
+    a += C(n.slice(e, c)), a += `<span class="${T.ref}">${C(n.slice(c, t.index + t[0].length))}</span>`, e = t.index + t[0].length;
+  }
+  return a += C(n.slice(e)), a;
+}
+function D(n) {
+  let a = "";
+  for (const { code: e, seg: t } of X(n))
+    a += e ? Ce(t) : _e(t);
+  return a;
+}
+function oe(n, a, e, t) {
+  const l = `<span class="${T.key}">${D(e)}</span>`, c = `<span class="${T.keyPunct}">:</span>`;
+  return `${n}${a}${l}${c}${D(t)}`;
+}
+function Pe(n) {
+  const a = n.trim();
+  if (/^\/\/!pd(?:\s+[^\s]+)?$/.test(a)) {
+    const t = /^(\s*)(\/\/!pd)(\s*.*)$/.exec(n), l = (t == null ? void 0 : t[1]) ?? "", c = (t == null ? void 0 : t[2]) ?? "//!pd", v = (t == null ? void 0 : t[3]) ?? "";
+    return `${C(l)}<span class="${T.section}">${C(c)}</span>${D(v)}`;
+  }
+  if (a === "---")
+    return `<span class="${T.sep}">${C(n)}</span>`;
+  const e = /^(\s*)(-)(?=\s|$)/.exec(n);
+  if (e) {
+    const t = C(e[1] ?? ""), l = (e[1] ?? "").length + 1, c = n.slice(l), v = c.trimStart(), o = c.slice(0, c.length - v.length), p = `<span class="${T.item}">-</span>`;
+    if (!Y(v) && se(v)) {
+      const b = V(v), k = v.slice(0, b), $ = v.slice(b + 1);
+      return `${t}${p}${C(o)}${oe("", "", k, $)}`;
+    }
+    return `${t}${p}${C(o)}${D(v)}`;
+  }
+  if (!Y(a) && se(a)) {
+    const l = n.length - n.trimStart().length, c = n.slice(l), v = V(c), o = c.slice(0, v).trim(), p = c.slice(v + 1);
+    return oe(C(n.slice(0, l)), "", o, p);
+  }
+  return D(n);
+}
+function Te(n) {
+  const a = n.split(`
+`);
+  let e = !1;
+  const t = [];
+  for (const l of a) {
+    const c = l.trimStart();
+    if (e) {
+      c.startsWith("```") ? (e = !1, t.push(`<span class="${T.fence}">${C(l)}</span>`)) : t.push(C(l));
+      continue;
+    }
+    if (c.startsWith("```")) {
+      e = !0, t.push(`<span class="${T.fence}">${C(l)}</span>`);
+      continue;
+    }
+    t.push(Pe(l));
+  }
+  return t.join(`
+`);
+}
+var ue = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Ie(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var U = { exports: {} }, ce;
+function Re() {
+  return ce || (ce = 1, (function(n) {
+    var a = 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(t) {
+      var l = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, c = 0, v = {}, 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: t.Prism && t.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: t.Prism && t.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 i(r) {
+            return r instanceof p ? new p(r.type, i(r.content), r.alias) : Array.isArray(r) ? r.map(i) : r.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(i) {
+            return Object.prototype.toString.call(i).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(i) {
+            return i.__id || Object.defineProperty(i, "__id", { value: ++c }), i.__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 i(r, u) {
+            u = u || {};
+            var d, s;
+            switch (o.util.type(r)) {
+              case "Object":
+                if (s = o.util.objId(r), u[s])
+                  return u[s];
+                d = /** @type {Record<string, any>} */
+                {}, u[s] = d;
+                for (var g in r)
+                  r.hasOwnProperty(g) && (d[g] = i(r[g], u));
+                return (
+                  /** @type {any} */
+                  d
+                );
+              case "Array":
+                return s = o.util.objId(r), u[s] ? u[s] : (d = [], u[s] = d, /** @type {Array} */
+                /** @type {any} */
+                r.forEach(function(m, h) {
+                  d[h] = i(m, u);
+                }), /** @type {any} */
+                d);
+              default:
+                return r;
+            }
+          },
+          /**
+           * 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(i) {
+            for (; i; ) {
+              var r = l.exec(i.className);
+              if (r)
+                return r[1].toLowerCase();
+              i = i.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(i, r) {
+            i.className = i.className.replace(RegExp(l, "gi"), ""), i.classList.add("language-" + r);
+          },
+          /**
+           * 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 (d) {
+              var i = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(d.stack) || [])[1];
+              if (i) {
+                var r = document.getElementsByTagName("script");
+                for (var u in r)
+                  if (r[u].src == i)
+                    return r[u];
+              }
+              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(i, r, u) {
+            for (var d = "no-" + r; i; ) {
+              var s = i.classList;
+              if (s.contains(r))
+                return !0;
+              if (s.contains(d))
+                return !1;
+              i = i.parentElement;
+            }
+            return !!u;
+          }
+        },
+        /**
+         * 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: v,
+          plaintext: v,
+          text: v,
+          txt: v,
+          /**
+           * 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(i, r) {
+            var u = o.util.clone(o.languages[i]);
+            for (var d in r)
+              u[d] = r[d];
+            return u;
+          },
+          /**
+           * 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(i, r, u, d) {
+            d = d || /** @type {any} */
+            o.languages;
+            var s = d[i], g = {};
+            for (var m in s)
+              if (s.hasOwnProperty(m)) {
+                if (m == r)
+                  for (var h in u)
+                    u.hasOwnProperty(h) && (g[h] = u[h]);
+                u.hasOwnProperty(m) || (g[m] = s[m]);
+              }
+            var E = d[i];
+            return d[i] = g, o.languages.DFS(o.languages, function(F, I) {
+              I === E && F != i && (this[F] = g);
+            }), g;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function i(r, u, d, s) {
+            s = s || {};
+            var g = o.util.objId;
+            for (var m in r)
+              if (r.hasOwnProperty(m)) {
+                u.call(r, m, r[m], d || m);
+                var h = r[m], E = o.util.type(h);
+                E === "Object" && !s[g(h)] ? (s[g(h)] = !0, i(h, u, null, s)) : E === "Array" && !s[g(h)] && (s[g(h)] = !0, i(h, u, m, s));
+              }
+          }
+        },
+        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(i, r) {
+          o.highlightAllUnder(document, i, r);
+        },
+        /**
+         * 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(i, r, u) {
+          var d = {
+            callback: u,
+            container: i,
+            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+          };
+          o.hooks.run("before-highlightall", d), d.elements = Array.prototype.slice.apply(d.container.querySelectorAll(d.selector)), o.hooks.run("before-all-elements-highlight", d);
+          for (var s = 0, g; g = d.elements[s++]; )
+            o.highlightElement(g, r === !0, d.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(i, r, u) {
+          var d = o.util.getLanguage(i), s = o.languages[d];
+          o.util.setLanguage(i, d);
+          var g = i.parentElement;
+          g && g.nodeName.toLowerCase() === "pre" && o.util.setLanguage(g, d);
+          var m = i.textContent, h = {
+            element: i,
+            language: d,
+            grammar: s,
+            code: m
+          };
+          function E(I) {
+            h.highlightedCode = I, o.hooks.run("before-insert", h), h.element.innerHTML = h.highlightedCode, o.hooks.run("after-highlight", h), o.hooks.run("complete", h), u && u.call(h.element);
+          }
+          if (o.hooks.run("before-sanity-check", h), g = h.element.parentElement, g && g.nodeName.toLowerCase() === "pre" && !g.hasAttribute("tabindex") && g.setAttribute("tabindex", "0"), !h.code) {
+            o.hooks.run("complete", h), u && u.call(h.element);
+            return;
+          }
+          if (o.hooks.run("before-highlight", h), !h.grammar) {
+            E(o.util.encode(h.code));
+            return;
+          }
+          if (r && t.Worker) {
+            var F = new Worker(o.filename);
+            F.onmessage = function(I) {
+              E(I.data);
+            }, F.postMessage(JSON.stringify({
+              language: h.language,
+              code: h.code,
+              immediateClose: !0
+            }));
+          } else
+            E(o.highlight(h.code, h.grammar, h.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(i, r, u) {
+          var d = {
+            code: i,
+            grammar: r,
+            language: u
+          };
+          if (o.hooks.run("before-tokenize", d), !d.grammar)
+            throw new Error('The language "' + d.language + '" has no grammar.');
+          return d.tokens = o.tokenize(d.code, d.grammar), o.hooks.run("after-tokenize", d), p.stringify(o.util.encode(d.tokens), d.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(i, r) {
+          var u = r.rest;
+          if (u) {
+            for (var d in u)
+              r[d] = u[d];
+            delete r.rest;
+          }
+          var s = new k();
+          return $(s, s.head, i), b(i, s, r, s.head, 0), w(s);
+        },
+        /**
+         * @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(i, r) {
+            var u = o.hooks.all;
+            u[i] = u[i] || [], u[i].push(r);
+          },
+          /**
+           * 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(i, r) {
+            var u = o.hooks.all[i];
+            if (!(!u || !u.length))
+              for (var d = 0, s; s = u[d++]; )
+                s(r);
+          }
+        },
+        Token: p
+      };
+      t.Prism = o;
+      function p(i, r, u, d) {
+        this.type = i, this.content = r, this.alias = u, this.length = (d || "").length | 0;
+      }
+      p.stringify = function i(r, u) {
+        if (typeof r == "string")
+          return r;
+        if (Array.isArray(r)) {
+          var d = "";
+          return r.forEach(function(E) {
+            d += i(E, u);
+          }), d;
+        }
+        var s = {
+          type: r.type,
+          content: i(r.content, u),
+          tag: "span",
+          classes: ["token", r.type],
+          attributes: {},
+          language: u
+        }, g = r.alias;
+        g && (Array.isArray(g) ? Array.prototype.push.apply(s.classes, g) : s.classes.push(g)), o.hooks.run("wrap", s);
+        var m = "";
+        for (var h in s.attributes)
+          m += " " + h + '="' + (s.attributes[h] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + s.tag + ' class="' + s.classes.join(" ") + '"' + m + ">" + s.content + "</" + s.tag + ">";
+      };
+      function A(i, r, u, d) {
+        i.lastIndex = r;
+        var s = i.exec(u);
+        if (s && d && s[1]) {
+          var g = s[1].length;
+          s.index += g, s[0] = s[0].slice(g);
+        }
+        return s;
+      }
+      function b(i, r, u, d, s, g) {
+        for (var m in u)
+          if (!(!u.hasOwnProperty(m) || !u[m])) {
+            var h = u[m];
+            h = Array.isArray(h) ? h : [h];
+            for (var E = 0; E < h.length; ++E) {
+              if (g && g.cause == m + "," + E)
+                return;
+              var F = h[E], I = F.inside, J = !!F.lookbehind, Q = !!F.greedy, he = F.alias;
+              if (Q && !F.pattern.global) {
+                var fe = F.pattern.toString().match(/[imsuy]*$/)[0];
+                F.pattern = RegExp(F.pattern.source, fe + "g");
+              }
+              for (var ee = F.pattern || F, L = d.next, P = s; L !== r.tail && !(g && P >= g.reach); P += L.value.length, L = L.next) {
+                var O = L.value;
+                if (r.length > i.length)
+                  return;
+                if (!(O instanceof p)) {
+                  var z = 1, _;
+                  if (Q) {
+                    if (_ = A(ee, P, i, J), !_ || _.index >= i.length)
+                      break;
+                    var M = _.index, me = _.index + _[0].length, R = P;
+                    for (R += L.value.length; M >= R; )
+                      L = L.next, R += L.value.length;
+                    if (R -= L.value.length, P = R, L.value instanceof p)
+                      continue;
+                    for (var j = L; j !== r.tail && (R < me || typeof j.value == "string"); j = j.next)
+                      z++, R += j.value.length;
+                    z--, O = i.slice(P, R), _.index -= P;
+                  } else if (_ = A(ee, 0, O, J), !_)
+                    continue;
+                  var M = _.index, H = _[0], K = O.slice(0, M), te = O.slice(M + H.length), G = P + O.length;
+                  g && G > g.reach && (g.reach = G);
+                  var q = L.prev;
+                  K && (q = $(r, q, K), P += K.length), S(r, q, z);
+                  var ve = new p(m, I ? o.tokenize(H, I) : H, he, H);
+                  if (L = $(r, q, ve), te && $(r, L, te), z > 1) {
+                    var Z = {
+                      cause: m + "," + E,
+                      reach: G
+                    };
+                    b(i, r, u, L.prev, P, Z), g && Z.reach > g.reach && (g.reach = Z.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function k() {
+        var i = { value: null, prev: null, next: null }, r = { value: null, prev: i, next: null };
+        i.next = r, this.head = i, this.tail = r, this.length = 0;
+      }
+      function $(i, r, u) {
+        var d = r.next, s = { value: u, prev: r, next: d };
+        return r.next = s, d.prev = s, i.length++, s;
+      }
+      function S(i, r, u) {
+        for (var d = r.next, s = 0; s < u && d !== i.tail; s++)
+          d = d.next;
+        r.next = d, d.prev = r, i.length -= s;
+      }
+      function w(i) {
+        for (var r = [], u = i.head.next; u !== i.tail; )
+          r.push(u.value), u = u.next;
+        return r;
+      }
+      if (!t.document)
+        return t.addEventListener && (o.disableWorkerMessageHandler || t.addEventListener("message", function(i) {
+          var r = JSON.parse(i.data), u = r.language, d = r.code, s = r.immediateClose;
+          t.postMessage(o.highlight(d, o.languages[u], u)), s && t.close();
+        }, !1)), o;
+      var y = o.util.currentScript();
+      y && (o.filename = y.src, y.hasAttribute("data-manual") && (o.manual = !0));
+      function f() {
+        o.manual || o.highlightAll();
+      }
+      if (!o.manual) {
+        var x = document.readyState;
+        x === "loading" || x === "interactive" && y && y.defer ? document.addEventListener("DOMContentLoaded", f) : window.requestAnimationFrame ? window.requestAnimationFrame(f) : window.setTimeout(f, 16);
+      }
+      return o;
+    })(a);
+    n.exports && (n.exports = e), typeof ue < "u" && (ue.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(t) {
+      t.type === "entity" && (t.attributes.title = t.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(l, c) {
+        var v = {};
+        v["language-" + c] = {
+          pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+          lookbehind: !0,
+          inside: e.languages[c]
+        }, v.cdata = /^<!\[CDATA\[|\]\]>$/i;
+        var o = {
+          "included-cdata": {
+            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+            inside: v
+          }
+        };
+        o["language-" + c] = {
+          pattern: /[\s\S]+/,
+          inside: e.languages[c]
+        };
+        var p = {};
+        p[l] = {
+          pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+            return l;
+          }), "i"),
+          lookbehind: !0,
+          greedy: !0,
+          inside: o
+        }, e.languages.insertBefore("markup", "cdata", p);
+      }
+    }), 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(t, l) {
+        e.languages.markup.tag.inside["special-attr"].push({
+          pattern: RegExp(
+            /(^|["'\s])/.source + "(?:" + t + ")" + /\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: [l, "language-" + l],
+                  inside: e.languages[l]
+                },
+                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(t) {
+      var l = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+      t.languages.css = {
+        comment: /\/\*[\s\S]*?\*\//,
+        atrule: {
+          pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + l.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\\((?:" + l.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+          greedy: !0,
+          inside: {
+            function: /^url/i,
+            punctuation: /^\(|\)$/,
+            string: {
+              pattern: RegExp("^" + l.source + "$"),
+              alias: "url"
+            }
+          }
+        },
+        selector: {
+          pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + l.source + ")*(?=\\s*\\{)"),
+          lookbehind: !0
+        },
+        string: {
+          pattern: l,
+          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: /[(){};:,]/
+      }, t.languages.css.atrule.inside.rest = t.languages.css;
+      var c = t.languages.markup;
+      c && (c.tag.addInlined("style", "css"), c.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 t = "Loading…", l = function(y, f) {
+        return "✖ Error " + y + " while fetching file: " + f;
+      }, c = "✖ Error: File does not exist or is empty", v = {
+        js: "javascript",
+        py: "python",
+        rb: "ruby",
+        ps1: "powershell",
+        psm1: "powershell",
+        sh: "bash",
+        bat: "batch",
+        h: "c",
+        tex: "latex"
+      }, o = "data-src-status", p = "loading", A = "loaded", b = "failed", k = "pre[data-src]:not([" + o + '="' + A + '"]):not([' + o + '="' + p + '"])';
+      function $(y, f, x) {
+        var i = new XMLHttpRequest();
+        i.open("GET", y, !0), i.onreadystatechange = function() {
+          i.readyState == 4 && (i.status < 400 && i.responseText ? f(i.responseText) : i.status >= 400 ? x(l(i.status, i.statusText)) : x(c));
+        }, i.send(null);
+      }
+      function S(y) {
+        var f = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(y || "");
+        if (f) {
+          var x = Number(f[1]), i = f[2], r = f[3];
+          return i ? r ? [x, Number(r)] : [x, void 0] : [x, x];
+        }
+      }
+      e.hooks.add("before-highlightall", function(y) {
+        y.selector += ", " + k;
+      }), e.hooks.add("before-sanity-check", function(y) {
+        var f = (
+          /** @type {HTMLPreElement} */
+          y.element
+        );
+        if (f.matches(k)) {
+          y.code = "", f.setAttribute(o, p);
+          var x = f.appendChild(document.createElement("CODE"));
+          x.textContent = t;
+          var i = f.getAttribute("data-src"), r = y.language;
+          if (r === "none") {
+            var u = (/\.(\w+)$/.exec(i) || [, "none"])[1];
+            r = v[u] || u;
+          }
+          e.util.setLanguage(x, r), e.util.setLanguage(f, r);
+          var d = e.plugins.autoloader;
+          d && d.loadLanguages(r), $(
+            i,
+            function(s) {
+              f.setAttribute(o, A);
+              var g = S(f.getAttribute("data-range"));
+              if (g) {
+                var m = s.split(/\r\n?|\n/g), h = g[0], E = g[1] == null ? m.length : g[1];
+                h < 0 && (h += m.length), h = Math.max(0, Math.min(h - 1, m.length)), E < 0 && (E += m.length), E = Math.max(0, Math.min(E, m.length)), s = m.slice(h, E).join(`
+`), f.hasAttribute("data-start") || f.setAttribute("data-start", String(h + 1));
+              }
+              x.textContent = s, e.highlightElement(x);
+            },
+            function(s) {
+              f.setAttribute(o, b), x.textContent = s;
+            }
+          );
+        }
+      }), 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(f) {
+          for (var x = (f || document).querySelectorAll(k), i = 0, r; r = x[i++]; )
+            e.highlightElement(r);
+        }
+      };
+      var w = !1;
+      e.fileHighlight = function() {
+        w || (console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."), w = !0), e.plugins.fileHighlight.highlight.apply(this, arguments);
+      };
+    })();
+  })(U)), U.exports;
+}
+var Oe = Re();
+const de = /* @__PURE__ */ Ie(Oe);
+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(n) {
+  n.type === "entity" && (n.attributes.title = n.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(a, e) {
+    var t = {};
+    t["language-" + e] = {
+      pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+      lookbehind: !0,
+      inside: Prism.languages[e]
+    }, t.cdata = /^<!\[CDATA\[|\]\]>$/i;
+    var l = {
+      "included-cdata": {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        inside: t
+      }
+    };
+    l["language-" + e] = {
+      pattern: /[\s\S]+/,
+      inside: Prism.languages[e]
+    };
+    var c = {};
+    c[a] = {
+      pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+        return a;
+      }), "i"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: l
+    }, Prism.languages.insertBefore("markup", "cdata", c);
+  }
+});
+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(n, a) {
+    Prism.languages.markup.tag.inside["special-attr"].push({
+      pattern: RegExp(
+        /(^|["'\s])/.source + "(?:" + n + ")" + /\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: [a, "language-" + a],
+              inside: Prism.languages[a]
+            },
+            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;
+(function(n) {
+  var a = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+  function e(b) {
+    return b = b.replace(/<inner>/g, function() {
+      return a;
+    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + b + ")");
+  }
+  var t = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, l = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+    return t;
+  }), c = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+  n.languages.markdown = n.languages.extend("markup", {}), n.languages.insertBefore("markdown", "prolog", {
+    "front-matter-block": {
+      pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        punctuation: /^---|---$/,
+        "front-matter": {
+          pattern: /\S+(?:\s+\S+)*/,
+          alias: ["yaml", "language-yaml"],
+          inside: n.languages.yaml
+        }
+      }
+    },
+    blockquote: {
+      // > ...
+      pattern: /^>(?:[\t ]*>)*/m,
+      alias: "punctuation"
+    },
+    table: {
+      pattern: RegExp("^" + l + c + "(?:" + l + ")*", "m"),
+      inside: {
+        "table-data-rows": {
+          pattern: RegExp("^(" + l + c + ")(?:" + l + ")*$"),
+          lookbehind: !0,
+          inside: {
+            "table-data": {
+              pattern: RegExp(t),
+              inside: n.languages.markdown
+            },
+            punctuation: /\|/
+          }
+        },
+        "table-line": {
+          pattern: RegExp("^(" + l + ")" + c + "$"),
+          lookbehind: !0,
+          inside: {
+            punctuation: /\||:?-{3,}:?/
+          }
+        },
+        "table-header-row": {
+          pattern: RegExp("^" + l + "$"),
+          inside: {
+            "table-header": {
+              pattern: RegExp(t),
+              alias: "important",
+              inside: n.languages.markdown
+            },
+            punctuation: /\|/
+          }
+        }
+      }
+    },
+    code: [
+      {
+        // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+        pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      {
+        // ```optional language
+        // code block
+        // ```
+        pattern: /^```[\s\S]*?^```$/m,
+        greedy: !0,
+        inside: {
+          "code-block": {
+            pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+            lookbehind: !0
+          },
+          "code-language": {
+            pattern: /^(```).+/,
+            lookbehind: !0
+          },
+          punctuation: /```/
+        }
+      }
+    ],
+    title: [
+      {
+        // title 1
+        // =======
+        // title 2
+        // -------
+        pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+        alias: "important",
+        inside: {
+          punctuation: /==+$|--+$/
+        }
+      },
+      {
+        // # title 1
+        // ###### title 6
+        pattern: /(^\s*)#.+/m,
+        lookbehind: !0,
+        alias: "important",
+        inside: {
+          punctuation: /^#+|#+$/
+        }
+      }
+    ],
+    hr: {
+      // ***
+      // ---
+      // * * *
+      // -----------
+      pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+      lookbehind: !0,
+      alias: "punctuation"
+    },
+    list: {
+      // * item
+      // + item
+      // - item
+      // 1. item
+      pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+      lookbehind: !0,
+      alias: "punctuation"
+    },
+    "url-reference": {
+      // [id]: http://example.com "Optional title"
+      // [id]: http://example.com 'Optional title'
+      // [id]: http://example.com (Optional title)
+      // [id]: <http://example.com> "Optional title"
+      pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+      inside: {
+        variable: {
+          pattern: /^(!?\[)[^\]]+/,
+          lookbehind: !0
+        },
+        string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+        punctuation: /^[\[\]!:]|[<>]/
+      },
+      alias: "url"
+    },
+    bold: {
+      // **strong**
+      // __strong__
+      // allow one nested instance of italic text using the same delimiter
+      pattern: e(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        content: {
+          pattern: /(^..)[\s\S]+(?=..$)/,
+          lookbehind: !0,
+          inside: {}
+          // see below
+        },
+        punctuation: /\*\*|__/
+      }
+    },
+    italic: {
+      // *em*
+      // _em_
+      // allow one nested instance of bold text using the same delimiter
+      pattern: e(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        content: {
+          pattern: /(^.)[\s\S]+(?=.$)/,
+          lookbehind: !0,
+          inside: {}
+          // see below
+        },
+        punctuation: /[*_]/
+      }
+    },
+    strike: {
+      // ~~strike through~~
+      // ~strike~
+      // eslint-disable-next-line regexp/strict
+      pattern: e(/(~~?)(?:(?!~)<inner>)+\2/.source),
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        content: {
+          pattern: /(^~~?)[\s\S]+(?=\1$)/,
+          lookbehind: !0,
+          inside: {}
+          // see below
+        },
+        punctuation: /~~?/
+      }
+    },
+    "code-snippet": {
+      // `code`
+      // ``code``
+      pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+      lookbehind: !0,
+      greedy: !0,
+      alias: ["code", "keyword"]
+    },
+    url: {
+      // [example](http://example.com "Optional title")
+      // [example][id]
+      // [example] [id]
+      pattern: e(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        operator: /^!/,
+        content: {
+          pattern: /(^\[)[^\]]+(?=\])/,
+          lookbehind: !0,
+          inside: {}
+          // see below
+        },
+        variable: {
+          pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+          lookbehind: !0
+        },
+        url: {
+          pattern: /(^\]\()[^\s)]+/,
+          lookbehind: !0
+        },
+        string: {
+          pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+          lookbehind: !0
+        }
+      }
+    }
+  }), ["url", "bold", "italic", "strike"].forEach(function(b) {
+    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(k) {
+      b !== k && (n.languages.markdown[b].inside.content.inside[k] = n.languages.markdown[k]);
+    });
+  }), n.hooks.add("after-tokenize", function(b) {
+    if (b.language !== "markdown" && b.language !== "md")
+      return;
+    function k($) {
+      if (!(!$ || typeof $ == "string"))
+        for (var S = 0, w = $.length; S < w; S++) {
+          var y = $[S];
+          if (y.type !== "code") {
+            k(y.content);
+            continue;
+          }
+          var f = y.content[1], x = y.content[3];
+          if (f && x && f.type === "code-language" && x.type === "code-block" && typeof f.content == "string") {
+            var i = f.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+            i = (/[a-z][\w-]*/i.exec(i) || [""])[0].toLowerCase();
+            var r = "language-" + i;
+            x.alias ? typeof x.alias == "string" ? x.alias = [x.alias, r] : x.alias.push(r) : x.alias = [r];
+          }
+        }
+    }
+    k(b.tokens);
+  }), n.hooks.add("wrap", function(b) {
+    if (b.type === "code-block") {
+      for (var k = "", $ = 0, S = b.classes.length; $ < S; $++) {
+        var w = b.classes[$], y = /language-(.+)/.exec(w);
+        if (y) {
+          k = y[1];
+          break;
+        }
+      }
+      var f = n.languages[k];
+      if (f)
+        b.content = n.highlight(A(b.content), f, k);
+      else if (k && k !== "none" && n.plugins.autoloader) {
+        var x = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+        b.attributes.id = x, n.plugins.autoloader.loadLanguages(k, function() {
+          var i = document.getElementById(x);
+          i && (i.innerHTML = n.highlight(i.textContent, n.languages[k], k));
+        });
+      }
+    }
+  });
+  var v = RegExp(n.languages.markup.tag.pattern.source, "gi"), o = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"'
+  }, p = String.fromCodePoint || String.fromCharCode;
+  function A(b) {
+    var k = b.replace(v, "");
+    return k = k.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function($, S) {
+      if (S = S.toLowerCase(), S[0] === "#") {
+        var w;
+        return S[1] === "x" ? w = parseInt(S.slice(2), 16) : w = Number(S.slice(1)), p(w);
+      } else {
+        var y = o[S];
+        return y || $;
+      }
+    }), k;
+  }
+  n.languages.md = n.languages.markdown;
+})(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(n) {
+  var a = /[*&][^\s[\]{},]+/, e = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, t = "(?:" + e.source + "(?:[ 	]+" + a.source + ")?|" + a.source + "(?:[ 	]+" + e.source + ")?)", l = /(?:[^\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;
+  }), c = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+  function v(o, p) {
+    p = (p || "").replace(/m/g, "") + "m";
+    var A = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+      return t;
+    }).replace(/<<value>>/g, function() {
+      return o;
+    });
+    return RegExp(A, p);
+  }
+  n.languages.yaml = {
+    scalar: {
+      pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
+        return t;
+      })),
+      lookbehind: !0,
+      alias: "string"
+    },
+    comment: /#.*/,
+    key: {
+      pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+        return t;
+      }).replace(/<<key>>/g, function() {
+        return "(?:" + l + "|" + c + ")";
+      })),
+      lookbehind: !0,
+      greedy: !0,
+      alias: "atrule"
+    },
+    directive: {
+      pattern: /(^[ \t]*)%.+/m,
+      lookbehind: !0,
+      alias: "important"
+    },
+    datetime: {
+      pattern: v(/\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: !0,
+      alias: "number"
+    },
+    boolean: {
+      pattern: v(/false|true/.source, "i"),
+      lookbehind: !0,
+      alias: "important"
+    },
+    null: {
+      pattern: v(/null|~/.source, "i"),
+      lookbehind: !0,
+      alias: "important"
+    },
+    string: {
+      pattern: v(c),
+      lookbehind: !0,
+      greedy: !0
+    },
+    number: {
+      pattern: v(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
+      lookbehind: !0
+    },
+    tag: e,
+    important: a,
+    punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+  }, n.languages.yml = n.languages.yaml;
+})(Prism);
+function je(n, a) {
+  const e = de.languages[a];
+  return e ? de.highlight(n, e, a) : De(n);
+}
+function De(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function ze(n) {
+  switch (n) {
+    case "md":
+      return "markdown";
+    case "xml":
+      return "markup";
+    case "json":
+      return "json";
+    case "yaml":
+      return "yaml";
+    default:
+      return null;
+  }
+}
+function Me(n) {
+  return (a) => {
+    if (n === "pd") return Te(a);
+    const e = ze(n);
+    return e ? je(a, e) : Ae(a);
+  };
+}
+function He(n, a = {}) {
+  return Le(n, a, Me);
+}
+export {
+  He as createPdEditor
+};
+//# sourceMappingURL=index.js.map