diff --git "a/src/backend/gradio_buttonplus/templates/component/index.js" "b/src/backend/gradio_buttonplus/templates/component/index.js" new file mode 100644--- /dev/null +++ "b/src/backend/gradio_buttonplus/templates/component/index.js" @@ -0,0 +1,7124 @@ +var Ut = Object.defineProperty; +var Ve = (a) => { + throw TypeError(a); +}; +var Gt = (a, e, t) => e in a ? Ut(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t; +var S = (a, e, t) => Gt(a, typeof e != "symbol" ? e + "" : e, t), Oe = (a, e, t) => e.has(a) || Ve("Cannot " + t); +var ee = (a, e, t) => (Oe(a, e, "read from private field"), t ? t.call(a) : e.get(a)), Ne = (a, e, t) => e.has(a) ? Ve("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(a) : e.set(a, t), Qe = (a, e, t, n) => (Oe(a, e, "write to private field"), n ? n.call(a, t) : e.set(a, t), t), De = (a, e, t) => (Oe(a, e, "access private method"), t); +new Intl.Collator(0, { numeric: 1 }).compare; +typeof process < "u" && process.versions && process.versions.node; +var H; +class va extends TransformStream { + /** Constructs a new instance. */ + constructor(t = { allowCR: !1 }) { + super({ + transform: (n, i) => { + for (n = ee(this, H) + n; ; ) { + const r = n.indexOf(` +`), o = t.allowCR ? n.indexOf("\r") : -1; + if (o !== -1 && o !== n.length - 1 && (r === -1 || r - 1 > o)) { + i.enqueue(n.slice(0, o)), n = n.slice(o + 1); + continue; + } + if (r === -1) + break; + const s = n[r - 1] === "\r" ? r - 1 : r; + i.enqueue(n.slice(0, s)), n = n.slice(r + 1); + } + Qe(this, H, n); + }, + flush: (n) => { + if (ee(this, H) === "") + return; + const i = t.allowCR && ee(this, H).endsWith("\r") ? ee(this, H).slice(0, -1) : ee(this, H); + n.enqueue(i); + } + }); + Ne(this, H, ""); + } +} +H = new WeakMap(); +const { + SvelteComponent: Ht, + assign: ze, + bubble: jt, + claim_element: Zt, + compute_rest_props: Je, + detach: Xt, + element: Yt, + exclude_internal_props: Wt, + get_spread_update: Kt, + init: Vt, + insert_hydration: Qt, + listen: Jt, + noop: et, + safe_not_equal: en, + set_attributes: tt, + src_url_equal: tn, + toggle_class: nt +} = window.__gradio__svelte__internal; +function nn(a) { + let e, t, n, i, r = [ + { src: t = /*src*/ + a[0] }, + /*$$restProps*/ + a[1] + ], o = {}; + for (let s = 0; s < r.length; s += 1) + o = ze(o, r[s]); + return { + c() { + e = Yt("img"), this.h(); + }, + l(s) { + e = Zt(s, "IMG", { src: !0 }), this.h(); + }, + h() { + tt(e, o), nt(e, "svelte-kxeri3", !0); + }, + m(s, l) { + Qt(s, e, l), n || (i = Jt( + e, + "load", + /*load_handler*/ + a[2] + ), n = !0); + }, + p(s, [l]) { + tt(e, o = Kt(r, [ + l & /*src*/ + 1 && !tn(e.src, t = /*src*/ + s[0]) && { src: t }, + l & /*$$restProps*/ + 2 && /*$$restProps*/ + s[1] + ])), nt(e, "svelte-kxeri3", !0); + }, + i: et, + o: et, + d(s) { + s && Xt(e), n = !1, i(); + } + }; +} +function an(a, e, t) { + const n = ["src"]; + let i = Je(e, n), { src: r = void 0 } = e; + function o(s) { + jt.call(this, a, s); + } + return a.$$set = (s) => { + e = ze(ze({}, e), Wt(s)), t(1, i = Je(e, n)), "src" in s && t(0, r = s.src); + }, [r, i, o]; +} +class gt extends Ht { + constructor(e) { + super(), Vt(this, e, an, nn, en, { src: 0 }); + } +} +const rn = [ + { color: "red", primary: 600, secondary: 100 }, + { color: "green", primary: 600, secondary: 100 }, + { color: "blue", primary: 600, secondary: 100 }, + { color: "yellow", primary: 500, secondary: 100 }, + { color: "purple", primary: 600, secondary: 100 }, + { color: "teal", primary: 600, secondary: 100 }, + { color: "orange", primary: 600, secondary: 100 }, + { color: "cyan", primary: 600, secondary: 100 }, + { color: "lime", primary: 500, secondary: 100 }, + { color: "pink", primary: 600, secondary: 100 } +], at = { + inherit: "inherit", + current: "currentColor", + transparent: "transparent", + black: "#000", + white: "#fff", + slate: { + 50: "#f8fafc", + 100: "#f1f5f9", + 200: "#e2e8f0", + 300: "#cbd5e1", + 400: "#94a3b8", + 500: "#64748b", + 600: "#475569", + 700: "#334155", + 800: "#1e293b", + 900: "#0f172a", + 950: "#020617" + }, + gray: { + 50: "#f9fafb", + 100: "#f3f4f6", + 200: "#e5e7eb", + 300: "#d1d5db", + 400: "#9ca3af", + 500: "#6b7280", + 600: "#4b5563", + 700: "#374151", + 800: "#1f2937", + 900: "#111827", + 950: "#030712" + }, + zinc: { + 50: "#fafafa", + 100: "#f4f4f5", + 200: "#e4e4e7", + 300: "#d4d4d8", + 400: "#a1a1aa", + 500: "#71717a", + 600: "#52525b", + 700: "#3f3f46", + 800: "#27272a", + 900: "#18181b", + 950: "#09090b" + }, + neutral: { + 50: "#fafafa", + 100: "#f5f5f5", + 200: "#e5e5e5", + 300: "#d4d4d4", + 400: "#a3a3a3", + 500: "#737373", + 600: "#525252", + 700: "#404040", + 800: "#262626", + 900: "#171717", + 950: "#0a0a0a" + }, + stone: { + 50: "#fafaf9", + 100: "#f5f5f4", + 200: "#e7e5e4", + 300: "#d6d3d1", + 400: "#a8a29e", + 500: "#78716c", + 600: "#57534e", + 700: "#44403c", + 800: "#292524", + 900: "#1c1917", + 950: "#0c0a09" + }, + red: { + 50: "#fef2f2", + 100: "#fee2e2", + 200: "#fecaca", + 300: "#fca5a5", + 400: "#f87171", + 500: "#ef4444", + 600: "#dc2626", + 700: "#b91c1c", + 800: "#991b1b", + 900: "#7f1d1d", + 950: "#450a0a" + }, + orange: { + 50: "#fff7ed", + 100: "#ffedd5", + 200: "#fed7aa", + 300: "#fdba74", + 400: "#fb923c", + 500: "#f97316", + 600: "#ea580c", + 700: "#c2410c", + 800: "#9a3412", + 900: "#7c2d12", + 950: "#431407" + }, + amber: { + 50: "#fffbeb", + 100: "#fef3c7", + 200: "#fde68a", + 300: "#fcd34d", + 400: "#fbbf24", + 500: "#f59e0b", + 600: "#d97706", + 700: "#b45309", + 800: "#92400e", + 900: "#78350f", + 950: "#451a03" + }, + yellow: { + 50: "#fefce8", + 100: "#fef9c3", + 200: "#fef08a", + 300: "#fde047", + 400: "#facc15", + 500: "#eab308", + 600: "#ca8a04", + 700: "#a16207", + 800: "#854d0e", + 900: "#713f12", + 950: "#422006" + }, + lime: { + 50: "#f7fee7", + 100: "#ecfccb", + 200: "#d9f99d", + 300: "#bef264", + 400: "#a3e635", + 500: "#84cc16", + 600: "#65a30d", + 700: "#4d7c0f", + 800: "#3f6212", + 900: "#365314", + 950: "#1a2e05" + }, + green: { + 50: "#f0fdf4", + 100: "#dcfce7", + 200: "#bbf7d0", + 300: "#86efac", + 400: "#4ade80", + 500: "#22c55e", + 600: "#16a34a", + 700: "#15803d", + 800: "#166534", + 900: "#14532d", + 950: "#052e16" + }, + emerald: { + 50: "#ecfdf5", + 100: "#d1fae5", + 200: "#a7f3d0", + 300: "#6ee7b7", + 400: "#34d399", + 500: "#10b981", + 600: "#059669", + 700: "#047857", + 800: "#065f46", + 900: "#064e3b", + 950: "#022c22" + }, + teal: { + 50: "#f0fdfa", + 100: "#ccfbf1", + 200: "#99f6e4", + 300: "#5eead4", + 400: "#2dd4bf", + 500: "#14b8a6", + 600: "#0d9488", + 700: "#0f766e", + 800: "#115e59", + 900: "#134e4a", + 950: "#042f2e" + }, + cyan: { + 50: "#ecfeff", + 100: "#cffafe", + 200: "#a5f3fc", + 300: "#67e8f9", + 400: "#22d3ee", + 500: "#06b6d4", + 600: "#0891b2", + 700: "#0e7490", + 800: "#155e75", + 900: "#164e63", + 950: "#083344" + }, + sky: { + 50: "#f0f9ff", + 100: "#e0f2fe", + 200: "#bae6fd", + 300: "#7dd3fc", + 400: "#38bdf8", + 500: "#0ea5e9", + 600: "#0284c7", + 700: "#0369a1", + 800: "#075985", + 900: "#0c4a6e", + 950: "#082f49" + }, + blue: { + 50: "#eff6ff", + 100: "#dbeafe", + 200: "#bfdbfe", + 300: "#93c5fd", + 400: "#60a5fa", + 500: "#3b82f6", + 600: "#2563eb", + 700: "#1d4ed8", + 800: "#1e40af", + 900: "#1e3a8a", + 950: "#172554" + }, + indigo: { + 50: "#eef2ff", + 100: "#e0e7ff", + 200: "#c7d2fe", + 300: "#a5b4fc", + 400: "#818cf8", + 500: "#6366f1", + 600: "#4f46e5", + 700: "#4338ca", + 800: "#3730a3", + 900: "#312e81", + 950: "#1e1b4b" + }, + violet: { + 50: "#f5f3ff", + 100: "#ede9fe", + 200: "#ddd6fe", + 300: "#c4b5fd", + 400: "#a78bfa", + 500: "#8b5cf6", + 600: "#7c3aed", + 700: "#6d28d9", + 800: "#5b21b6", + 900: "#4c1d95", + 950: "#2e1065" + }, + purple: { + 50: "#faf5ff", + 100: "#f3e8ff", + 200: "#e9d5ff", + 300: "#d8b4fe", + 400: "#c084fc", + 500: "#a855f7", + 600: "#9333ea", + 700: "#7e22ce", + 800: "#6b21a8", + 900: "#581c87", + 950: "#3b0764" + }, + fuchsia: { + 50: "#fdf4ff", + 100: "#fae8ff", + 200: "#f5d0fe", + 300: "#f0abfc", + 400: "#e879f9", + 500: "#d946ef", + 600: "#c026d3", + 700: "#a21caf", + 800: "#86198f", + 900: "#701a75", + 950: "#4a044e" + }, + pink: { + 50: "#fdf2f8", + 100: "#fce7f3", + 200: "#fbcfe8", + 300: "#f9a8d4", + 400: "#f472b6", + 500: "#ec4899", + 600: "#db2777", + 700: "#be185d", + 800: "#9d174d", + 900: "#831843", + 950: "#500724" + }, + rose: { + 50: "#fff1f2", + 100: "#ffe4e6", + 200: "#fecdd3", + 300: "#fda4af", + 400: "#fb7185", + 500: "#f43f5e", + 600: "#e11d48", + 700: "#be123c", + 800: "#9f1239", + 900: "#881337", + 950: "#4c0519" + } +}; +rn.reduce( + (a, { color: e, primary: t, secondary: n }) => ({ + ...a, + [e]: { + primary: at[e][t], + secondary: at[e][n] + } + }), + {} +); +const { + SvelteComponent: ya, + append_hydration: Fa, + assign: Ea, + attr: wa, + binding_callbacks: ka, + children: Ca, + claim_element: Aa, + claim_space: Sa, + claim_svg_element: xa, + create_slot: Ta, + detach: Ba, + element: Ia, + empty: Ra, + get_all_dirty_from_scope: qa, + get_slot_changes: La, + get_spread_update: Oa, + init: Na, + insert_hydration: za, + listen: Pa, + noop: Ma, + safe_not_equal: Ua, + set_dynamic_element_data: Ga, + set_style: Ha, + space: ja, + svg_element: Za, + toggle_class: Xa, + transition_in: Ya, + transition_out: Wa, + update_slot_base: Ka +} = window.__gradio__svelte__internal; +function Ue() { + return { + async: !1, + breaks: !1, + extensions: null, + gfm: !0, + hooks: null, + pedantic: !1, + renderer: null, + silent: !1, + tokenizer: null, + walkTokens: null + }; +} +let V = Ue(); +function ft(a) { + V = a; +} +const $t = /[&<>"']/, on = new RegExp($t.source, "g"), Dt = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, sn = new RegExp(Dt.source, "g"), ln = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" +}, it = (a) => ln[a]; +function O(a, e) { + if (e) { + if ($t.test(a)) + return a.replace(on, it); + } else if (Dt.test(a)) + return a.replace(sn, it); + return a; +} +const un = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig; +function cn(a) { + return a.replace(un, (e, t) => (t = t.toLowerCase(), t === "colon" ? ":" : t.charAt(0) === "#" ? t.charAt(1) === "x" ? String.fromCharCode(parseInt(t.substring(2), 16)) : String.fromCharCode(+t.substring(1)) : "")); +} +const dn = /(^|[^\[])\^/g; +function A(a, e) { + let t = typeof a == "string" ? a : a.source; + e = e || ""; + const n = { + replace: (i, r) => { + let o = typeof r == "string" ? r : r.source; + return o = o.replace(dn, "$1"), t = t.replace(i, o), n; + }, + getRegex: () => new RegExp(t, e) + }; + return n; +} +function rt(a) { + try { + a = encodeURI(a).replace(/%25/g, "%"); + } catch { + return null; + } + return a; +} +const se = { exec: () => null }; +function ot(a, e) { + const t = a.replace(/\|/g, (r, o, s) => { + let l = !1, p = o; + for (; --p >= 0 && s[p] === "\\"; ) + l = !l; + return l ? "|" : " |"; + }), n = t.split(/ \|/); + let i = 0; + if (n[0].trim() || n.shift(), n.length > 0 && !n[n.length - 1].trim() && n.pop(), e) + if (n.length > e) + n.splice(e); + else + for (; n.length < e; ) + n.push(""); + for (; i < n.length; i++) + n[i] = n[i].trim().replace(/\\\|/g, "|"); + return n; +} +function be(a, e, t) { + const n = a.length; + if (n === 0) + return ""; + let i = 0; + for (; i < n && a.charAt(n - i - 1) === e; ) + i++; + return a.slice(0, n - i); +} +function _n(a, e) { + if (a.indexOf(e[1]) === -1) + return -1; + let t = 0; + for (let n = 0; n < a.length; n++) + if (a[n] === "\\") + n++; + else if (a[n] === e[0]) + t++; + else if (a[n] === e[1] && (t--, t < 0)) + return n; + return -1; +} +function st(a, e, t, n) { + const i = e.href, r = e.title ? O(e.title) : null, o = a[1].replace(/\\([\[\]])/g, "$1"); + if (a[0].charAt(0) !== "!") { + n.state.inLink = !0; + const s = { + type: "link", + raw: t, + href: i, + title: r, + text: o, + tokens: n.inlineTokens(o) + }; + return n.state.inLink = !1, s; + } + return { + type: "image", + raw: t, + href: i, + title: r, + text: O(o) + }; +} +function pn(a, e) { + const t = a.match(/^(\s+)(?:```)/); + if (t === null) + return e; + const n = t[1]; + return e.split(` +`).map((i) => { + const r = i.match(/^\s+/); + if (r === null) + return i; + const [o] = r; + return o.length >= n.length ? i.slice(n.length) : i; + }).join(` +`); +} +class Fe { + // set by the lexer + constructor(e) { + S(this, "options"); + S(this, "rules"); + // set by the lexer + S(this, "lexer"); + this.options = e || V; + } + space(e) { + const t = this.rules.block.newline.exec(e); + if (t && t[0].length > 0) + return { + type: "space", + raw: t[0] + }; + } + code(e) { + const t = this.rules.block.code.exec(e); + if (t) { + const n = t[0].replace(/^ {1,4}/gm, ""); + return { + type: "code", + raw: t[0], + codeBlockStyle: "indented", + text: this.options.pedantic ? n : be(n, ` +`) + }; + } + } + fences(e) { + const t = this.rules.block.fences.exec(e); + if (t) { + const n = t[0], i = pn(n, t[3] || ""); + return { + type: "code", + raw: n, + lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], + text: i + }; + } + } + heading(e) { + const t = this.rules.block.heading.exec(e); + if (t) { + let n = t[2].trim(); + if (/#$/.test(n)) { + const i = be(n, "#"); + (this.options.pedantic || !i || / $/.test(i)) && (n = i.trim()); + } + return { + type: "heading", + raw: t[0], + depth: t[1].length, + text: n, + tokens: this.lexer.inline(n) + }; + } + } + hr(e) { + const t = this.rules.block.hr.exec(e); + if (t) + return { + type: "hr", + raw: t[0] + }; + } + blockquote(e) { + const t = this.rules.block.blockquote.exec(e); + if (t) { + let n = t[0].replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, ` + $1`); + n = be(n.replace(/^ *>[ \t]?/gm, ""), ` +`); + const i = this.lexer.state.top; + this.lexer.state.top = !0; + const r = this.lexer.blockTokens(n); + return this.lexer.state.top = i, { + type: "blockquote", + raw: t[0], + tokens: r, + text: n + }; + } + } + list(e) { + let t = this.rules.block.list.exec(e); + if (t) { + let n = t[1].trim(); + const i = n.length > 1, r = { + type: "list", + raw: "", + ordered: i, + start: i ? +n.slice(0, -1) : "", + loose: !1, + items: [] + }; + n = i ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = i ? n : "[*+-]"); + const o = new RegExp(`^( {0,3}${n})((?:[ ][^\\n]*)?(?:\\n|$))`); + let s = "", l = "", p = !1; + for (; e; ) { + let g = !1; + if (!(t = o.exec(e)) || this.rules.block.hr.test(e)) + break; + s = t[0], e = e.substring(s.length); + let _ = t[2].split(` +`, 1)[0].replace(/^\t+/, (d) => " ".repeat(3 * d.length)), D = e.split(` +`, 1)[0], v = 0; + this.options.pedantic ? (v = 2, l = _.trimStart()) : (v = t[2].search(/[^ ]/), v = v > 4 ? 1 : v, l = _.slice(v), v += t[1].length); + let k = !1; + if (!_ && /^ *$/.test(D) && (s += D + ` +`, e = e.substring(D.length + 1), g = !0), !g) { + const d = new RegExp(`^ {0,${Math.min(3, v - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`), u = new RegExp(`^ {0,${Math.min(3, v - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), c = new RegExp(`^ {0,${Math.min(3, v - 1)}}(?:\`\`\`|~~~)`), h = new RegExp(`^ {0,${Math.min(3, v - 1)}}#`); + for (; e; ) { + const m = e.split(` +`, 1)[0]; + if (D = m, this.options.pedantic && (D = D.replace(/^ {1,4}(?=( {4})*[^ ])/g, " ")), c.test(D) || h.test(D) || d.test(D) || u.test(e)) + break; + if (D.search(/[^ ]/) >= v || !D.trim()) + l += ` +` + D.slice(v); + else { + if (k || _.search(/[^ ]/) >= 4 || c.test(_) || h.test(_) || u.test(_)) + break; + l += ` +` + D; + } + !k && !D.trim() && (k = !0), s += m + ` +`, e = e.substring(m.length + 1), _ = D.slice(v); + } + } + r.loose || (p ? r.loose = !0 : /\n *\n *$/.test(s) && (p = !0)); + let $ = null, b; + this.options.gfm && ($ = /^\[[ xX]\] /.exec(l), $ && (b = $[0] !== "[ ] ", l = l.replace(/^\[[ xX]\] +/, ""))), r.items.push({ + type: "list_item", + raw: s, + task: !!$, + checked: b, + loose: !1, + text: l, + tokens: [] + }), r.raw += s; + } + r.items[r.items.length - 1].raw = s.trimEnd(), r.items[r.items.length - 1].text = l.trimEnd(), r.raw = r.raw.trimEnd(); + for (let g = 0; g < r.items.length; g++) + if (this.lexer.state.top = !1, r.items[g].tokens = this.lexer.blockTokens(r.items[g].text, []), !r.loose) { + const _ = r.items[g].tokens.filter((v) => v.type === "space"), D = _.length > 0 && _.some((v) => /\n.*\n/.test(v.raw)); + r.loose = D; + } + if (r.loose) + for (let g = 0; g < r.items.length; g++) + r.items[g].loose = !0; + return r; + } + } + html(e) { + const t = this.rules.block.html.exec(e); + if (t) + return { + type: "html", + block: !0, + raw: t[0], + pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", + text: t[0] + }; + } + def(e) { + const t = this.rules.block.def.exec(e); + if (t) { + const n = t[1].toLowerCase().replace(/\s+/g, " "), i = t[2] ? t[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3]; + return { + type: "def", + tag: n, + raw: t[0], + href: i, + title: r + }; + } + } + table(e) { + const t = this.rules.block.table.exec(e); + if (!t || !/[:|]/.test(t[2])) + return; + const n = ot(t[1]), i = t[2].replace(/^\||\| *$/g, "").split("|"), r = t[3] && t[3].trim() ? t[3].replace(/\n[ \t]*$/, "").split(` +`) : [], o = { + type: "table", + raw: t[0], + header: [], + align: [], + rows: [] + }; + if (n.length === i.length) { + for (const s of i) + /^ *-+: *$/.test(s) ? o.align.push("right") : /^ *:-+: *$/.test(s) ? o.align.push("center") : /^ *:-+ *$/.test(s) ? o.align.push("left") : o.align.push(null); + for (const s of n) + o.header.push({ + text: s, + tokens: this.lexer.inline(s) + }); + for (const s of r) + o.rows.push(ot(s, o.header.length).map((l) => ({ + text: l, + tokens: this.lexer.inline(l) + }))); + return o; + } + } + lheading(e) { + const t = this.rules.block.lheading.exec(e); + if (t) + return { + type: "heading", + raw: t[0], + depth: t[2].charAt(0) === "=" ? 1 : 2, + text: t[1], + tokens: this.lexer.inline(t[1]) + }; + } + paragraph(e) { + const t = this.rules.block.paragraph.exec(e); + if (t) { + const n = t[1].charAt(t[1].length - 1) === ` +` ? t[1].slice(0, -1) : t[1]; + return { + type: "paragraph", + raw: t[0], + text: n, + tokens: this.lexer.inline(n) + }; + } + } + text(e) { + const t = this.rules.block.text.exec(e); + if (t) + return { + type: "text", + raw: t[0], + text: t[0], + tokens: this.lexer.inline(t[0]) + }; + } + escape(e) { + const t = this.rules.inline.escape.exec(e); + if (t) + return { + type: "escape", + raw: t[0], + text: O(t[1]) + }; + } + tag(e) { + const t = this.rules.inline.tag.exec(e); + if (t) + return !this.lexer.state.inLink && /^/i.test(t[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(t[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(t[0]) && (this.lexer.state.inRawBlock = !1), { + type: "html", + raw: t[0], + inLink: this.lexer.state.inLink, + inRawBlock: this.lexer.state.inRawBlock, + block: !1, + text: t[0] + }; + } + link(e) { + const t = this.rules.inline.link.exec(e); + if (t) { + const n = t[2].trim(); + if (!this.options.pedantic && /^$/.test(n)) + return; + const o = be(n.slice(0, -1), "\\"); + if ((n.length - o.length) % 2 === 0) + return; + } else { + const o = _n(t[2], "()"); + if (o > -1) { + const l = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + o; + t[2] = t[2].substring(0, o), t[0] = t[0].substring(0, l).trim(), t[3] = ""; + } + } + let i = t[2], r = ""; + if (this.options.pedantic) { + const o = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(i); + o && (i = o[1], r = o[3]); + } else + r = t[3] ? t[3].slice(1, -1) : ""; + return i = i.trim(), /^$/.test(n) ? i = i.slice(1) : i = i.slice(1, -1)), st(t, { + href: i && i.replace(this.rules.inline.anyPunctuation, "$1"), + title: r && r.replace(this.rules.inline.anyPunctuation, "$1") + }, t[0], this.lexer); + } + } + reflink(e, t) { + let n; + if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) { + const i = (n[2] || n[1]).replace(/\s+/g, " "), r = t[i.toLowerCase()]; + if (!r) { + const o = n[0].charAt(0); + return { + type: "text", + raw: o, + text: o + }; + } + return st(n, r, n[0], this.lexer); + } + } + emStrong(e, t, n = "") { + let i = this.rules.inline.emStrongLDelim.exec(e); + if (!i || i[3] && n.match(/[\p{L}\p{N}]/u)) + return; + if (!(i[1] || i[2] || "") || !n || this.rules.inline.punctuation.exec(n)) { + const o = [...i[0]].length - 1; + let s, l, p = o, g = 0; + const _ = i[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd; + for (_.lastIndex = 0, t = t.slice(-1 * e.length + o); (i = _.exec(t)) != null; ) { + if (s = i[1] || i[2] || i[3] || i[4] || i[5] || i[6], !s) + continue; + if (l = [...s].length, i[3] || i[4]) { + p += l; + continue; + } else if ((i[5] || i[6]) && o % 3 && !((o + l) % 3)) { + g += l; + continue; + } + if (p -= l, p > 0) + continue; + l = Math.min(l, l + p + g); + const D = [...i[0]][0].length, v = e.slice(0, o + i.index + D + l); + if (Math.min(o, l) % 2) { + const $ = v.slice(1, -1); + return { + type: "em", + raw: v, + text: $, + tokens: this.lexer.inlineTokens($) + }; + } + const k = v.slice(2, -2); + return { + type: "strong", + raw: v, + text: k, + tokens: this.lexer.inlineTokens(k) + }; + } + } + } + codespan(e) { + const t = this.rules.inline.code.exec(e); + if (t) { + let n = t[2].replace(/\n/g, " "); + const i = /[^ ]/.test(n), r = /^ /.test(n) && / $/.test(n); + return i && r && (n = n.substring(1, n.length - 1)), n = O(n, !0), { + type: "codespan", + raw: t[0], + text: n + }; + } + } + br(e) { + const t = this.rules.inline.br.exec(e); + if (t) + return { + type: "br", + raw: t[0] + }; + } + del(e) { + const t = this.rules.inline.del.exec(e); + if (t) + return { + type: "del", + raw: t[0], + text: t[2], + tokens: this.lexer.inlineTokens(t[2]) + }; + } + autolink(e) { + const t = this.rules.inline.autolink.exec(e); + if (t) { + let n, i; + return t[2] === "@" ? (n = O(t[1]), i = "mailto:" + n) : (n = O(t[1]), i = n), { + type: "link", + raw: t[0], + text: n, + href: i, + tokens: [ + { + type: "text", + raw: n, + text: n + } + ] + }; + } + } + url(e) { + var n; + let t; + if (t = this.rules.inline.url.exec(e)) { + let i, r; + if (t[2] === "@") + i = O(t[0]), r = "mailto:" + i; + else { + let o; + do + o = t[0], t[0] = ((n = this.rules.inline._backpedal.exec(t[0])) == null ? void 0 : n[0]) ?? ""; + while (o !== t[0]); + i = O(t[0]), t[1] === "www." ? r = "http://" + t[0] : r = t[0]; + } + return { + type: "link", + raw: t[0], + text: i, + href: r, + tokens: [ + { + type: "text", + raw: i, + text: i + } + ] + }; + } + } + inlineText(e) { + const t = this.rules.inline.text.exec(e); + if (t) { + let n; + return this.lexer.state.inRawBlock ? n = t[0] : n = O(t[0]), { + type: "text", + raw: t[0], + text: n + }; + } + } +} +const hn = /^(?: *(?:\n|$))+/, mn = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/, gn = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, de = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, fn = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, bt = /(?:[*+-]|\d{1,9}[.)])/, vt = A(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bt).replace(/blockCode/g, / {4}/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex(), Ge = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, $n = /^[^\n]+/, He = /(?!\s*\])(?:\\.|[^\[\]\\])+/, Dn = A(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", He).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), bn = A(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bt).getRegex(), Se = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", je = /|$))/, vn = A("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", je).replace("tag", Se).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), yt = A(Ge).replace("hr", de).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Se).getRegex(), yn = A(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", yt).getRegex(), Ze = { + blockquote: yn, + code: mn, + def: Dn, + fences: gn, + heading: fn, + hr: de, + html: vn, + lheading: vt, + list: bn, + newline: hn, + paragraph: yt, + table: se, + text: $n +}, lt = A("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", de).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Se).getRegex(), Fn = { + ...Ze, + table: lt, + paragraph: A(Ge).replace("hr", de).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", lt).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", Se).getRegex() +}, En = { + ...Ze, + html: A(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", je).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), + def: /^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, + heading: /^(#{1,6})(.*)(?:\n+|$)/, + fences: se, + // fences not supported + lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, + paragraph: A(Ge).replace("hr", de).replace("heading", ` *#{1,6} *[^ +]`).replace("lheading", vt).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() +}, Ft = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, wn = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, Et = /^( {2,}|\\)\n(?!\s*$)/, kn = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\]*?>/g, Sn = A(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, _e).getRegex(), xn = A("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, _e).getRegex(), Tn = A("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, _e).getRegex(), Bn = A(/\\([punct])/, "gu").replace(/punct/g, _e).getRegex(), In = A(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), Rn = A(je).replace("(?:-->|$)", "-->").getRegex(), qn = A("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment", Rn).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), Ee = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/, Ln = A(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", Ee).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), wt = A(/^!?\[(label)\]\[(ref)\]/).replace("label", Ee).replace("ref", He).getRegex(), kt = A(/^!?\[(ref)\](?:\[\])?/).replace("ref", He).getRegex(), On = A("reflink|nolink(?!\\()", "g").replace("reflink", wt).replace("nolink", kt).getRegex(), Xe = { + _backpedal: se, + // only used for GFM url + anyPunctuation: Bn, + autolink: In, + blockSkip: An, + br: Et, + code: wn, + del: se, + emStrongLDelim: Sn, + emStrongRDelimAst: xn, + emStrongRDelimUnd: Tn, + escape: Ft, + link: Ln, + nolink: kt, + punctuation: Cn, + reflink: wt, + reflinkSearch: On, + tag: qn, + text: kn, + url: se +}, Nn = { + ...Xe, + link: A(/^!?\[(label)\]\((.*?)\)/).replace("label", Ee).getRegex(), + reflink: A(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", Ee).getRegex() +}, Pe = { + ...Xe, + escape: A(Ft).replace("])", "~|])").getRegex(), + url: A(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), + _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, + del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/, + text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\ l + " ".repeat(p.length)); + let n, i, r, o; + for (; e; ) + if (!(this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((s) => (n = s.call({ lexer: this }, e, t)) ? (e = e.substring(n.raw.length), t.push(n), !0) : !1))) { + if (n = this.tokenizer.space(e)) { + e = e.substring(n.raw.length), n.raw.length === 1 && t.length > 0 ? t[t.length - 1].raw += ` +` : t.push(n); + continue; + } + if (n = this.tokenizer.code(e)) { + e = e.substring(n.raw.length), i = t[t.length - 1], i && (i.type === "paragraph" || i.type === "text") ? (i.raw += ` +` + n.raw, i.text += ` +` + n.text, this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(n); + continue; + } + if (n = this.tokenizer.fences(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.heading(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.hr(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.blockquote(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.list(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.html(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.def(e)) { + e = e.substring(n.raw.length), i = t[t.length - 1], i && (i.type === "paragraph" || i.type === "text") ? (i.raw += ` +` + n.raw, i.text += ` +` + n.raw, this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : this.tokens.links[n.tag] || (this.tokens.links[n.tag] = { + href: n.href, + title: n.title + }); + continue; + } + if (n = this.tokenizer.table(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.lheading(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (r = e, this.options.extensions && this.options.extensions.startBlock) { + let s = 1 / 0; + const l = e.slice(1); + let p; + this.options.extensions.startBlock.forEach((g) => { + p = g.call({ lexer: this }, l), typeof p == "number" && p >= 0 && (s = Math.min(s, p)); + }), s < 1 / 0 && s >= 0 && (r = e.substring(0, s + 1)); + } + if (this.state.top && (n = this.tokenizer.paragraph(r))) { + i = t[t.length - 1], o && i.type === "paragraph" ? (i.raw += ` +` + n.raw, i.text += ` +` + n.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(n), o = r.length !== e.length, e = e.substring(n.raw.length); + continue; + } + if (n = this.tokenizer.text(e)) { + e = e.substring(n.raw.length), i = t[t.length - 1], i && i.type === "text" ? (i.raw += ` +` + n.raw, i.text += ` +` + n.text, this.inlineQueue.pop(), this.inlineQueue[this.inlineQueue.length - 1].src = i.text) : t.push(n); + continue; + } + if (e) { + const s = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(s); + break; + } else + throw new Error(s); + } + } + return this.state.top = !0, t; + } + inline(e, t = []) { + return this.inlineQueue.push({ src: e, tokens: t }), t; + } + /** + * Lexing/Compiling + */ + inlineTokens(e, t = []) { + let n, i, r, o = e, s, l, p; + if (this.tokens.links) { + const g = Object.keys(this.tokens.links); + if (g.length > 0) + for (; (s = this.tokenizer.rules.inline.reflinkSearch.exec(o)) != null; ) + g.includes(s[0].slice(s[0].lastIndexOf("[") + 1, -1)) && (o = o.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + o.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex)); + } + for (; (s = this.tokenizer.rules.inline.blockSkip.exec(o)) != null; ) + o = o.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + o.slice(this.tokenizer.rules.inline.blockSkip.lastIndex); + for (; (s = this.tokenizer.rules.inline.anyPunctuation.exec(o)) != null; ) + o = o.slice(0, s.index) + "++" + o.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex); + for (; e; ) + if (l || (p = ""), l = !1, !(this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((g) => (n = g.call({ lexer: this }, e, t)) ? (e = e.substring(n.raw.length), t.push(n), !0) : !1))) { + if (n = this.tokenizer.escape(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.tag(e)) { + e = e.substring(n.raw.length), i = t[t.length - 1], i && n.type === "text" && i.type === "text" ? (i.raw += n.raw, i.text += n.text) : t.push(n); + continue; + } + if (n = this.tokenizer.link(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.reflink(e, this.tokens.links)) { + e = e.substring(n.raw.length), i = t[t.length - 1], i && n.type === "text" && i.type === "text" ? (i.raw += n.raw, i.text += n.text) : t.push(n); + continue; + } + if (n = this.tokenizer.emStrong(e, o, p)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.codespan(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.br(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.del(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (n = this.tokenizer.autolink(e)) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (!this.state.inLink && (n = this.tokenizer.url(e))) { + e = e.substring(n.raw.length), t.push(n); + continue; + } + if (r = e, this.options.extensions && this.options.extensions.startInline) { + let g = 1 / 0; + const _ = e.slice(1); + let D; + this.options.extensions.startInline.forEach((v) => { + D = v.call({ lexer: this }, _), typeof D == "number" && D >= 0 && (g = Math.min(g, D)); + }), g < 1 / 0 && g >= 0 && (r = e.substring(0, g + 1)); + } + if (n = this.tokenizer.inlineText(r)) { + e = e.substring(n.raw.length), n.raw.slice(-1) !== "_" && (p = n.raw.slice(-1)), l = !0, i = t[t.length - 1], i && i.type === "text" ? (i.raw += n.raw, i.text += n.text) : t.push(n); + continue; + } + if (e) { + const g = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(g); + break; + } else + throw new Error(g); + } + } + return t; + } +} +class we { + constructor(e) { + S(this, "options"); + this.options = e || V; + } + code(e, t, n) { + var r; + const i = (r = (t || "").match(/^\S*/)) == null ? void 0 : r[0]; + return e = e.replace(/\n$/, "") + ` +`, i ? '
' + (n ? e : O(e, !0)) + `
+` : "
" + (n ? e : O(e, !0)) + `
+`; + } + blockquote(e) { + return `
+${e}
+`; + } + html(e, t) { + return e; + } + heading(e, t, n) { + return `${e} +`; + } + hr() { + return `
+`; + } + list(e, t, n) { + const i = t ? "ol" : "ul", r = t && n !== 1 ? ' start="' + n + '"' : ""; + return "<" + i + r + `> +` + e + " +`; + } + listitem(e, t, n) { + return `
  • ${e}
    • +`; + } + checkbox(e) { + return "'; + } + paragraph(e) { + return `

    ${e}

    +`; + } + table(e, t) { + return t && (t = `${t}`), ` + +` + e + ` +` + t + `
    +`; + } + tablerow(e) { + return ` +${e} +`; + } + tablecell(e, t) { + const n = t.header ? "th" : "td"; + return (t.align ? `<${n} align="${t.align}">` : `<${n}>`) + e + ` +`; + } + /** + * span level renderer + */ + strong(e) { + return `${e}`; + } + em(e) { + return `${e}`; + } + codespan(e) { + return `${e}`; + } + br() { + return "
    "; + } + del(e) { + return `${e}`; + } + link(e, t, n) { + const i = rt(e); + if (i === null) + return n; + e = i; + let r = '    ", r; + } + image(e, t, n) { + const i = rt(e); + if (i === null) + return n; + e = i; + let r = `${n} 0 && D.tokens[0].type === "paragraph" ? (D.tokens[0].text = b + " " + D.tokens[0].text, D.tokens[0].tokens && D.tokens[0].tokens.length > 0 && D.tokens[0].tokens[0].type === "text" && (D.tokens[0].tokens[0].text = b + " " + D.tokens[0].tokens[0].text)) : D.tokens.unshift({ + type: "text", + text: b + " " + }) : $ += b + " "; + } + $ += this.parse(D.tokens, p), g += this.renderer.listitem($, k, !!v); + } + n += this.renderer.list(g, s, l); + continue; + } + case "html": { + const o = r; + n += this.renderer.html(o.text, o.block); + continue; + } + case "paragraph": { + const o = r; + n += this.renderer.paragraph(this.parseInline(o.tokens)); + continue; + } + case "text": { + let o = r, s = o.tokens ? this.parseInline(o.tokens) : o.text; + for (; i + 1 < e.length && e[i + 1].type === "text"; ) + o = e[++i], s += ` +` + (o.tokens ? this.parseInline(o.tokens) : o.text); + n += t ? this.renderer.paragraph(s) : s; + continue; + } + default: { + const o = 'Token with "' + r.type + '" type was not found.'; + if (this.options.silent) + return console.error(o), ""; + throw new Error(o); + } + } + } + return n; + } + /** + * Parse Inline Tokens + */ + parseInline(e, t) { + t = t || this.renderer; + let n = ""; + for (let i = 0; i < e.length; i++) { + const r = e[i]; + if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[r.type]) { + const o = this.options.extensions.renderers[r.type].call({ parser: this }, r); + if (o !== !1 || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(r.type)) { + n += o || ""; + continue; + } + } + switch (r.type) { + case "escape": { + const o = r; + n += t.text(o.text); + break; + } + case "html": { + const o = r; + n += t.html(o.text); + break; + } + case "link": { + const o = r; + n += t.link(o.href, o.title, this.parseInline(o.tokens, t)); + break; + } + case "image": { + const o = r; + n += t.image(o.href, o.title, o.text); + break; + } + case "strong": { + const o = r; + n += t.strong(this.parseInline(o.tokens, t)); + break; + } + case "em": { + const o = r; + n += t.em(this.parseInline(o.tokens, t)); + break; + } + case "codespan": { + const o = r; + n += t.codespan(o.text); + break; + } + case "br": { + n += t.br(); + break; + } + case "del": { + const o = r; + n += t.del(this.parseInline(o.tokens, t)); + break; + } + case "text": { + const o = r; + n += t.text(o.text); + break; + } + default: { + const o = 'Token with "' + r.type + '" type was not found.'; + if (this.options.silent) + return console.error(o), ""; + throw new Error(o); + } + } + } + return n; + } +} +class le { + constructor(e) { + S(this, "options"); + this.options = e || V; + } + /** + * Process markdown before marked + */ + preprocess(e) { + return e; + } + /** + * Process HTML after marked is finished + */ + postprocess(e) { + return e; + } + /** + * Process all tokens before walk tokens + */ + processAllTokens(e) { + return e; + } +} +S(le, "passThroughHooks", /* @__PURE__ */ new Set([ + "preprocess", + "postprocess", + "processAllTokens" +])); +var K, Me, Ct; +class Pn { + constructor(...e) { + Ne(this, K); + S(this, "defaults", Ue()); + S(this, "options", this.setOptions); + S(this, "parse", De(this, K, Me).call(this, U.lex, G.parse)); + S(this, "parseInline", De(this, K, Me).call(this, U.lexInline, G.parseInline)); + S(this, "Parser", G); + S(this, "Renderer", we); + S(this, "TextRenderer", Ye); + S(this, "Lexer", U); + S(this, "Tokenizer", Fe); + S(this, "Hooks", le); + this.use(...e); + } + /** + * Run callback for every token + */ + walkTokens(e, t) { + var i, r; + let n = []; + for (const o of e) + switch (n = n.concat(t.call(this, o)), o.type) { + case "table": { + const s = o; + for (const l of s.header) + n = n.concat(this.walkTokens(l.tokens, t)); + for (const l of s.rows) + for (const p of l) + n = n.concat(this.walkTokens(p.tokens, t)); + break; + } + case "list": { + const s = o; + n = n.concat(this.walkTokens(s.items, t)); + break; + } + default: { + const s = o; + (r = (i = this.defaults.extensions) == null ? void 0 : i.childTokens) != null && r[s.type] ? this.defaults.extensions.childTokens[s.type].forEach((l) => { + const p = s[l].flat(1 / 0); + n = n.concat(this.walkTokens(p, t)); + }) : s.tokens && (n = n.concat(this.walkTokens(s.tokens, t))); + } + } + return n; + } + use(...e) { + const t = this.defaults.extensions || { renderers: {}, childTokens: {} }; + return e.forEach((n) => { + const i = { ...n }; + if (i.async = this.defaults.async || i.async || !1, n.extensions && (n.extensions.forEach((r) => { + if (!r.name) + throw new Error("extension name required"); + if ("renderer" in r) { + const o = t.renderers[r.name]; + o ? t.renderers[r.name] = function(...s) { + let l = r.renderer.apply(this, s); + return l === !1 && (l = o.apply(this, s)), l; + } : t.renderers[r.name] = r.renderer; + } + if ("tokenizer" in r) { + if (!r.level || r.level !== "block" && r.level !== "inline") + throw new Error("extension level must be 'block' or 'inline'"); + const o = t[r.level]; + o ? o.unshift(r.tokenizer) : t[r.level] = [r.tokenizer], r.start && (r.level === "block" ? t.startBlock ? t.startBlock.push(r.start) : t.startBlock = [r.start] : r.level === "inline" && (t.startInline ? t.startInline.push(r.start) : t.startInline = [r.start])); + } + "childTokens" in r && r.childTokens && (t.childTokens[r.name] = r.childTokens); + }), i.extensions = t), n.renderer) { + const r = this.defaults.renderer || new we(this.defaults); + for (const o in n.renderer) { + if (!(o in r)) + throw new Error(`renderer '${o}' does not exist`); + if (o === "options") + continue; + const s = o, l = n.renderer[s], p = r[s]; + r[s] = (...g) => { + let _ = l.apply(r, g); + return _ === !1 && (_ = p.apply(r, g)), _ || ""; + }; + } + i.renderer = r; + } + if (n.tokenizer) { + const r = this.defaults.tokenizer || new Fe(this.defaults); + for (const o in n.tokenizer) { + if (!(o in r)) + throw new Error(`tokenizer '${o}' does not exist`); + if (["options", "rules", "lexer"].includes(o)) + continue; + const s = o, l = n.tokenizer[s], p = r[s]; + r[s] = (...g) => { + let _ = l.apply(r, g); + return _ === !1 && (_ = p.apply(r, g)), _; + }; + } + i.tokenizer = r; + } + if (n.hooks) { + const r = this.defaults.hooks || new le(); + for (const o in n.hooks) { + if (!(o in r)) + throw new Error(`hook '${o}' does not exist`); + if (o === "options") + continue; + const s = o, l = n.hooks[s], p = r[s]; + le.passThroughHooks.has(o) ? r[s] = (g) => { + if (this.defaults.async) + return Promise.resolve(l.call(r, g)).then((D) => p.call(r, D)); + const _ = l.call(r, g); + return p.call(r, _); + } : r[s] = (...g) => { + let _ = l.apply(r, g); + return _ === !1 && (_ = p.apply(r, g)), _; + }; + } + i.hooks = r; + } + if (n.walkTokens) { + const r = this.defaults.walkTokens, o = n.walkTokens; + i.walkTokens = function(s) { + let l = []; + return l.push(o.call(this, s)), r && (l = l.concat(r.call(this, s))), l; + }; + } + this.defaults = { ...this.defaults, ...i }; + }), this; + } + setOptions(e) { + return this.defaults = { ...this.defaults, ...e }, this; + } + lexer(e, t) { + return U.lex(e, t ?? this.defaults); + } + parser(e, t) { + return G.parse(e, t ?? this.defaults); + } +} +K = new WeakSet(), Me = function(e, t) { + return (n, i) => { + const r = { ...i }, o = { ...this.defaults, ...r }; + this.defaults.async === !0 && r.async === !1 && (o.silent || console.warn("marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored."), o.async = !0); + const s = De(this, K, Ct).call(this, !!o.silent, !!o.async); + if (typeof n > "u" || n === null) + return s(new Error("marked(): input parameter is undefined or null")); + if (typeof n != "string") + return s(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected")); + if (o.hooks && (o.hooks.options = o), o.async) + return Promise.resolve(o.hooks ? o.hooks.preprocess(n) : n).then((l) => e(l, o)).then((l) => o.hooks ? o.hooks.processAllTokens(l) : l).then((l) => o.walkTokens ? Promise.all(this.walkTokens(l, o.walkTokens)).then(() => l) : l).then((l) => t(l, o)).then((l) => o.hooks ? o.hooks.postprocess(l) : l).catch(s); + try { + o.hooks && (n = o.hooks.preprocess(n)); + let l = e(n, o); + o.hooks && (l = o.hooks.processAllTokens(l)), o.walkTokens && this.walkTokens(l, o.walkTokens); + let p = t(l, o); + return o.hooks && (p = o.hooks.postprocess(p)), p; + } catch (l) { + return s(l); + } + }; +}, Ct = function(e, t) { + return (n) => { + if (n.message += ` +Please report this to https://github.com/markedjs/marked.`, e) { + const i = "

    An error occurred:

    " + O(n.message + "", !0) + "
    "; + return t ? Promise.resolve(i) : i; + } + if (t) + return Promise.reject(n); + throw n; + }; +}; +const W = new Pn(); +function C(a, e) { + return W.parse(a, e); +} +C.options = C.setOptions = function(a) { + return W.setOptions(a), C.defaults = W.defaults, ft(C.defaults), C; +}; +C.getDefaults = Ue; +C.defaults = V; +C.use = function(...a) { + return W.use(...a), C.defaults = W.defaults, ft(C.defaults), C; +}; +C.walkTokens = function(a, e) { + return W.walkTokens(a, e); +}; +C.parseInline = W.parseInline; +C.Parser = G; +C.parser = G.parse; +C.Renderer = we; +C.TextRenderer = Ye; +C.Lexer = U; +C.lexer = U.lex; +C.Tokenizer = Fe; +C.Hooks = le; +C.parse = C; +C.options; +C.setOptions; +C.use; +C.walkTokens; +C.parseInline; +G.parse; +U.lex; +const Mn = /[\0-\x1F!-,\.\/:-@\[-\^`\{-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2-\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B72-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF0-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D58-\u0D5E\u0D64\u0D65\u0D70-\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F2A-\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u170D\u1715-\u171F\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u180A\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DA-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u203E\u2041-\u2053\u2055-\u2070\u2072-\u207E\u2080-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F-\u215F\u2189-\u24B5\u24EA-\u2BFF\u2C2F\u2C5F\u2CE5-\u2CEA\u2CF4-\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u319F\u31C0-\u31EF\u3200-\u33FF\u4DC0-\u4DFF\u9FFD-\u9FFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7C0\uA7C1\uA7CB-\uA7F4\uA828-\uA82B\uA82D-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE32\uFE35-\uFE4C\uFE50-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF3E\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD3F\uDD75-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEE1-\uDEFF\uDF20-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56-\uDC5F\uDC77-\uDC7F\uDC9F-\uDCDF\uDCF3\uDCF6-\uDCFF\uDD16-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBD\uDDC0-\uDDFF\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE40-\uDE5F\uDE7D-\uDE7F\uDE9D-\uDEBF\uDEC8\uDEE7-\uDEFF\uDF36-\uDF3F\uDF56-\uDF5F\uDF73-\uDF7F\uDF92-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCFF\uDD28-\uDD2F\uDD3A-\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF1D-\uDF26\uDF28-\uDF2F\uDF51-\uDFAF\uDFC5-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC65\uDC70-\uDC7E\uDCBB-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3A-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCEA-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC5A-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A-\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE80-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDEBF\uDEFA-\uDFFF]|\uD83A[\uDCC5-\uDCCF\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDD2F\uDD4A-\uDD4F\uDD6A-\uDD6F\uDD8A-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]/g, Un = Object.hasOwnProperty; +class At { + /** + * Create a new slug class. + */ + constructor() { + this.occurrences, this.reset(); + } + /** + * Generate a unique slug. + * + * Tracks previously generated slugs: repeated calls with the same value + * will result in different slugs. + * Use the `slug` function to get same slugs. + * + * @param {string} value + * String of text to slugify + * @param {boolean} [maintainCase=false] + * Keep the current case, otherwise make all lowercase + * @return {string} + * A unique slug string + */ + slug(e, t) { + const n = this; + let i = Gn(e, t === !0); + const r = i; + for (; Un.call(n.occurrences, i); ) + n.occurrences[r]++, i = r + "-" + n.occurrences[r]; + return n.occurrences[i] = 0, i; + } + /** + * Reset - Forget all previous slugs + * + * @return void + */ + reset() { + this.occurrences = /* @__PURE__ */ Object.create(null); + } +} +function Gn(a, e) { + return typeof a != "string" ? "" : (e || (a = a.toLowerCase()), a.replace(Mn, "").replace(/ /g, "-")); +} +new At(); +var ut = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Hn = { exports: {} }; +(function(a) { + var e = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {}; + /** + * Prism: Lightweight, robust, elegant syntax highlighting + * + * @license MIT + * @author Lea Verou + * @namespace + * @public + */ + var t = function(n) { + var i = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, r = 0, o = {}, s = { + /** + * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the + * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load + * 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