@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/core-CcwoL92f.js

@@ -0,0 +1,1712 @@
+import { c as fe, g as yn } from "./index-Sj89RFCY.js";
+import { a as xn } from "./markup-Bwuswjib.js";
+import { a as bn } from "./css-9KZNpeR_.js";
+import { a as wn } from "./clike-D8ff3B0t.js";
+import { a as Cn } from "./javascript-Cl708kfq.js";
+function Sn(e, n) {
+  for (var r = 0; r < n.length; r++) {
+    const t = n[r];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const f in t)
+        if (f !== "default" && !(f in e)) {
+          const v = Object.getOwnPropertyDescriptor(t, f);
+          v && Object.defineProperty(e, f, v.get ? v : {
+            enumerable: !0,
+            get: () => t[f]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var An = En, Pn = Object.prototype.hasOwnProperty;
+function En() {
+  for (var e = {}, n = 0; n < arguments.length; n++) {
+    var r = arguments[n];
+    for (var t in r)
+      Pn.call(r, t) && (e[t] = r[t]);
+  }
+  return e;
+}
+var Ve = Ke, xe = Ke.prototype;
+xe.space = null;
+xe.normal = {};
+xe.property = {};
+function Ke(e, n, r) {
+  this.property = e, this.normal = n, r && (this.space = r);
+}
+var Oe = An, $n = Ve, Tn = kn;
+function kn(e) {
+  for (var n = e.length, r = [], t = [], f = -1, v, m; ++f < n; )
+    v = e[f], r.push(v.property), t.push(v.normal), m = v.space;
+  return new $n(
+    Oe.apply(null, r),
+    Oe.apply(null, t),
+    m
+  );
+}
+var be = Ln;
+function Ln(e) {
+  return e.toLowerCase();
+}
+var Ye = Xe, U = Xe.prototype;
+U.space = null;
+U.attribute = null;
+U.property = null;
+U.boolean = !1;
+U.booleanish = !1;
+U.overloadedBoolean = !1;
+U.number = !1;
+U.commaSeparated = !1;
+U.spaceSeparated = !1;
+U.commaOrSpaceSeparated = !1;
+U.mustUseProperty = !1;
+U.defined = !1;
+function Xe(e, n) {
+  this.property = e, this.attribute = n;
+}
+var H = {}, On = 0;
+H.boolean = X();
+H.booleanish = X();
+H.overloadedBoolean = X();
+H.number = X();
+H.spaceSeparated = X();
+H.commaSeparated = X();
+H.commaOrSpaceSeparated = X();
+function X() {
+  return Math.pow(2, ++On);
+}
+var Je = Ye, Me = H, Qe = we;
+we.prototype = new Je();
+we.prototype.defined = !0;
+var Ze = [
+  "boolean",
+  "booleanish",
+  "overloadedBoolean",
+  "number",
+  "commaSeparated",
+  "spaceSeparated",
+  "commaOrSpaceSeparated"
+], Mn = Ze.length;
+function we(e, n, r, t) {
+  var f = -1, v;
+  for (Ie(this, "space", t), Je.call(this, e, n); ++f < Mn; )
+    v = Ze[f], Ie(this, v, (r & Me[v]) === Me[v]);
+}
+function Ie(e, n, r) {
+  r && (e[n] = r);
+}
+var De = be, In = Ve, Dn = Qe, le = Un;
+function Un(e) {
+  var n = e.space, r = e.mustUseProperty || [], t = e.attributes || {}, f = e.properties, v = e.transform, m = {}, u = {}, g, P;
+  for (g in f)
+    P = new Dn(
+      g,
+      v(t, g),
+      f[g],
+      n
+    ), r.indexOf(g) !== -1 && (P.mustUseProperty = !0), m[g] = P, u[De(g)] = g, u[De(P.attribute)] = g;
+  return new In(m, u, n);
+}
+var Nn = le, jn = Nn({
+  space: "xlink",
+  transform: Rn,
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  }
+});
+function Rn(e, n) {
+  return "xlink:" + n.slice(5).toLowerCase();
+}
+var qn = le, zn = qn({
+  space: "xml",
+  transform: Hn,
+  properties: {
+    xmlLang: null,
+    xmlBase: null,
+    xmlSpace: null
+  }
+});
+function Hn(e, n) {
+  return "xml:" + n.slice(3).toLowerCase();
+}
+var _n = Bn;
+function Bn(e, n) {
+  return n in e ? e[n] : n;
+}
+var Wn = _n, en = Fn;
+function Fn(e, n) {
+  return Wn(e, n.toLowerCase());
+}
+var Gn = le, Vn = en, Kn = Gn({
+  space: "xmlns",
+  attributes: {
+    xmlnsxlink: "xmlns:xlink"
+  },
+  transform: Vn,
+  properties: {
+    xmlns: null,
+    xmlnsXLink: null
+  }
+}), Ce = H, Yn = le, O = Ce.booleanish, D = Ce.number, Y = Ce.spaceSeparated, Xn = Yn({
+  transform: Jn,
+  properties: {
+    ariaActiveDescendant: null,
+    ariaAtomic: O,
+    ariaAutoComplete: null,
+    ariaBusy: O,
+    ariaChecked: O,
+    ariaColCount: D,
+    ariaColIndex: D,
+    ariaColSpan: D,
+    ariaControls: Y,
+    ariaCurrent: null,
+    ariaDescribedBy: Y,
+    ariaDetails: null,
+    ariaDisabled: O,
+    ariaDropEffect: Y,
+    ariaErrorMessage: null,
+    ariaExpanded: O,
+    ariaFlowTo: Y,
+    ariaGrabbed: O,
+    ariaHasPopup: null,
+    ariaHidden: O,
+    ariaInvalid: null,
+    ariaKeyShortcuts: null,
+    ariaLabel: null,
+    ariaLabelledBy: Y,
+    ariaLevel: D,
+    ariaLive: null,
+    ariaModal: O,
+    ariaMultiLine: O,
+    ariaMultiSelectable: O,
+    ariaOrientation: null,
+    ariaOwns: Y,
+    ariaPlaceholder: null,
+    ariaPosInSet: D,
+    ariaPressed: O,
+    ariaReadOnly: O,
+    ariaRelevant: null,
+    ariaRequired: O,
+    ariaRoleDescription: Y,
+    ariaRowCount: D,
+    ariaRowIndex: D,
+    ariaRowSpan: D,
+    ariaSelected: O,
+    ariaSetSize: D,
+    ariaSort: null,
+    ariaValueMax: D,
+    ariaValueMin: D,
+    ariaValueNow: D,
+    ariaValueText: null,
+    role: null
+  }
+});
+function Jn(e, n) {
+  return n === "role" ? n : "aria-" + n.slice(4).toLowerCase();
+}
+var ee = H, Qn = le, Zn = en, h = ee.boolean, er = ee.overloadedBoolean, re = ee.booleanish, x = ee.number, L = ee.spaceSeparated, ue = ee.commaSeparated, nr = Qn({
+  space: "html",
+  attributes: {
+    acceptcharset: "accept-charset",
+    classname: "class",
+    htmlfor: "for",
+    httpequiv: "http-equiv"
+  },
+  transform: Zn,
+  mustUseProperty: ["checked", "multiple", "muted", "selected"],
+  properties: {
+    // Standard Properties.
+    abbr: null,
+    accept: ue,
+    acceptCharset: L,
+    accessKey: L,
+    action: null,
+    allow: null,
+    allowFullScreen: h,
+    allowPaymentRequest: h,
+    allowUserMedia: h,
+    alt: null,
+    as: null,
+    async: h,
+    autoCapitalize: null,
+    autoComplete: L,
+    autoFocus: h,
+    autoPlay: h,
+    capture: h,
+    charSet: null,
+    checked: h,
+    cite: null,
+    className: L,
+    cols: x,
+    colSpan: null,
+    content: null,
+    contentEditable: re,
+    controls: h,
+    controlsList: L,
+    coords: x | ue,
+    crossOrigin: null,
+    data: null,
+    dateTime: null,
+    decoding: null,
+    default: h,
+    defer: h,
+    dir: null,
+    dirName: null,
+    disabled: h,
+    download: er,
+    draggable: re,
+    encType: null,
+    enterKeyHint: null,
+    form: null,
+    formAction: null,
+    formEncType: null,
+    formMethod: null,
+    formNoValidate: h,
+    formTarget: null,
+    headers: L,
+    height: x,
+    hidden: h,
+    high: x,
+    href: null,
+    hrefLang: null,
+    htmlFor: L,
+    httpEquiv: L,
+    id: null,
+    imageSizes: null,
+    imageSrcSet: ue,
+    inputMode: null,
+    integrity: null,
+    is: null,
+    isMap: h,
+    itemId: null,
+    itemProp: L,
+    itemRef: L,
+    itemScope: h,
+    itemType: L,
+    kind: null,
+    label: null,
+    lang: null,
+    language: null,
+    list: null,
+    loading: null,
+    loop: h,
+    low: x,
+    manifest: null,
+    max: null,
+    maxLength: x,
+    media: null,
+    method: null,
+    min: null,
+    minLength: x,
+    multiple: h,
+    muted: h,
+    name: null,
+    nonce: null,
+    noModule: h,
+    noValidate: h,
+    onAbort: null,
+    onAfterPrint: null,
+    onAuxClick: null,
+    onBeforePrint: null,
+    onBeforeUnload: null,
+    onBlur: null,
+    onCancel: null,
+    onCanPlay: null,
+    onCanPlayThrough: null,
+    onChange: null,
+    onClick: null,
+    onClose: null,
+    onContextMenu: null,
+    onCopy: null,
+    onCueChange: null,
+    onCut: null,
+    onDblClick: null,
+    onDrag: null,
+    onDragEnd: null,
+    onDragEnter: null,
+    onDragExit: null,
+    onDragLeave: null,
+    onDragOver: null,
+    onDragStart: null,
+    onDrop: null,
+    onDurationChange: null,
+    onEmptied: null,
+    onEnded: null,
+    onError: null,
+    onFocus: null,
+    onFormData: null,
+    onHashChange: null,
+    onInput: null,
+    onInvalid: null,
+    onKeyDown: null,
+    onKeyPress: null,
+    onKeyUp: null,
+    onLanguageChange: null,
+    onLoad: null,
+    onLoadedData: null,
+    onLoadedMetadata: null,
+    onLoadEnd: null,
+    onLoadStart: null,
+    onMessage: null,
+    onMessageError: null,
+    onMouseDown: null,
+    onMouseEnter: null,
+    onMouseLeave: null,
+    onMouseMove: null,
+    onMouseOut: null,
+    onMouseOver: null,
+    onMouseUp: null,
+    onOffline: null,
+    onOnline: null,
+    onPageHide: null,
+    onPageShow: null,
+    onPaste: null,
+    onPause: null,
+    onPlay: null,
+    onPlaying: null,
+    onPopState: null,
+    onProgress: null,
+    onRateChange: null,
+    onRejectionHandled: null,
+    onReset: null,
+    onResize: null,
+    onScroll: null,
+    onSecurityPolicyViolation: null,
+    onSeeked: null,
+    onSeeking: null,
+    onSelect: null,
+    onSlotChange: null,
+    onStalled: null,
+    onStorage: null,
+    onSubmit: null,
+    onSuspend: null,
+    onTimeUpdate: null,
+    onToggle: null,
+    onUnhandledRejection: null,
+    onUnload: null,
+    onVolumeChange: null,
+    onWaiting: null,
+    onWheel: null,
+    open: h,
+    optimum: x,
+    pattern: null,
+    ping: L,
+    placeholder: null,
+    playsInline: h,
+    poster: null,
+    preload: null,
+    readOnly: h,
+    referrerPolicy: null,
+    rel: L,
+    required: h,
+    reversed: h,
+    rows: x,
+    rowSpan: x,
+    sandbox: L,
+    scope: null,
+    scoped: h,
+    seamless: h,
+    selected: h,
+    shape: null,
+    size: x,
+    sizes: null,
+    slot: null,
+    span: x,
+    spellCheck: re,
+    src: null,
+    srcDoc: null,
+    srcLang: null,
+    srcSet: ue,
+    start: x,
+    step: null,
+    style: null,
+    tabIndex: x,
+    target: null,
+    title: null,
+    translate: null,
+    type: null,
+    typeMustMatch: h,
+    useMap: null,
+    value: re,
+    width: x,
+    wrap: null,
+    // Legacy.
+    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
+    align: null,
+    // Several. Use CSS `text-align` instead,
+    aLink: null,
+    // `<body>`. Use CSS `a:active {color}` instead
+    archive: L,
+    // `<object>`. List of URIs to archives
+    axis: null,
+    // `<td>` and `<th>`. Use `scope` on `<th>`
+    background: null,
+    // `<body>`. Use CSS `background-image` instead
+    bgColor: null,
+    // `<body>` and table elements. Use CSS `background-color` instead
+    border: x,
+    // `<table>`. Use CSS `border-width` instead,
+    borderColor: null,
+    // `<table>`. Use CSS `border-color` instead,
+    bottomMargin: x,
+    // `<body>`
+    cellPadding: null,
+    // `<table>`
+    cellSpacing: null,
+    // `<table>`
+    char: null,
+    // Several table elements. When `align=char`, sets the character to align on
+    charOff: null,
+    // Several table elements. When `char`, offsets the alignment
+    classId: null,
+    // `<object>`
+    clear: null,
+    // `<br>`. Use CSS `clear` instead
+    code: null,
+    // `<object>`
+    codeBase: null,
+    // `<object>`
+    codeType: null,
+    // `<object>`
+    color: null,
+    // `<font>` and `<hr>`. Use CSS instead
+    compact: h,
+    // Lists. Use CSS to reduce space between items instead
+    declare: h,
+    // `<object>`
+    event: null,
+    // `<script>`
+    face: null,
+    // `<font>`. Use CSS instead
+    frame: null,
+    // `<table>`
+    frameBorder: null,
+    // `<iframe>`. Use CSS `border` instead
+    hSpace: x,
+    // `<img>` and `<object>`
+    leftMargin: x,
+    // `<body>`
+    link: null,
+    // `<body>`. Use CSS `a:link {color: *}` instead
+    longDesc: null,
+    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
+    lowSrc: null,
+    // `<img>`. Use a `<picture>`
+    marginHeight: x,
+    // `<body>`
+    marginWidth: x,
+    // `<body>`
+    noResize: h,
+    // `<frame>`
+    noHref: h,
+    // `<area>`. Use no href instead of an explicit `nohref`
+    noShade: h,
+    // `<hr>`. Use background-color and height instead of borders
+    noWrap: h,
+    // `<td>` and `<th>`
+    object: null,
+    // `<applet>`
+    profile: null,
+    // `<head>`
+    prompt: null,
+    // `<isindex>`
+    rev: null,
+    // `<link>`
+    rightMargin: x,
+    // `<body>`
+    rules: null,
+    // `<table>`
+    scheme: null,
+    // `<meta>`
+    scrolling: re,
+    // `<frame>`. Use overflow in the child context
+    standby: null,
+    // `<object>`
+    summary: null,
+    // `<table>`
+    text: null,
+    // `<body>`. Use CSS `color` instead
+    topMargin: x,
+    // `<body>`
+    valueType: null,
+    // `<param>`
+    version: null,
+    // `<html>`. Use a doctype.
+    vAlign: null,
+    // Several. Use CSS `vertical-align` instead
+    vLink: null,
+    // `<body>`. Use CSS `a:visited {color}` instead
+    vSpace: x,
+    // `<img>` and `<object>`
+    // Non-standard Properties.
+    allowTransparency: null,
+    autoCorrect: null,
+    autoSave: null,
+    disablePictureInPicture: h,
+    disableRemotePlayback: h,
+    prefix: null,
+    property: null,
+    results: x,
+    security: null,
+    unselectable: null
+  }
+}), rr = Tn, ar = jn, tr = zn, lr = Kn, ir = Xn, or = nr, sr = rr([tr, ar, lr, ir, or]), ur = be, cr = Qe, fr = Ye, Se = "data", dr = gr, vr = /^data[-\w.:]+$/i, nn = /-[a-z]/g, pr = /[A-Z]/g;
+function gr(e, n) {
+  var r = ur(n), t = n, f = fr;
+  return r in e.normal ? e.property[e.normal[r]] : (r.length > 4 && r.slice(0, 4) === Se && vr.test(n) && (n.charAt(4) === "-" ? t = hr(n) : n = mr(n), f = cr), new f(t, n));
+}
+function hr(e) {
+  var n = e.slice(5).replace(nn, xr);
+  return Se + n.charAt(0).toUpperCase() + n.slice(1);
+}
+function mr(e) {
+  var n = e.slice(4);
+  return nn.test(n) ? e : (n = n.replace(pr, yr), n.charAt(0) !== "-" && (n = "-" + n), Se + n);
+}
+function yr(e) {
+  return "-" + e.toLowerCase();
+}
+function xr(e) {
+  return e.charAt(1).toUpperCase();
+}
+var br = wr, Ue = /[#.]/g;
+function wr(e, n) {
+  for (var r = e || "", t = n || "div", f = {}, v = 0, m, u, g; v < r.length; )
+    Ue.lastIndex = v, g = Ue.exec(r), m = r.slice(v, g ? g.index : r.length), m && (u ? u === "#" ? f.id = m : f.className ? f.className.push(m) : f.className = [m] : t = m, v += m.length), g && (u = g[0], v++);
+  return { type: "element", tagName: t, properties: f, children: [] };
+}
+var Ae = {};
+Ae.parse = Ar;
+Ae.stringify = Pr;
+var Ne = "", Cr = " ", Sr = /[ \t\n\r\f]+/g;
+function Ar(e) {
+  var n = String(e || Ne).trim();
+  return n === Ne ? [] : n.split(Sr);
+}
+function Pr(e) {
+  return e.join(Cr).trim();
+}
+var Pe = {};
+Pe.parse = Er;
+Pe.stringify = $r;
+var me = ",", je = " ", ae = "";
+function Er(e) {
+  for (var n = [], r = String(e || ae), t = r.indexOf(me), f = 0, v = !1, m; !v; )
+    t === -1 && (t = r.length, v = !0), m = r.slice(f, t).trim(), (m || !v) && n.push(m), f = t + 1, t = r.indexOf(me, f);
+  return n;
+}
+function $r(e, n) {
+  var r = n || {}, t = r.padLeft === !1 ? ae : je, f = r.padRight ? je : ae;
+  return e[e.length - 1] === ae && (e = e.concat(ae)), e.join(f + me + t).trim();
+}
+var Tr = dr, Re = be, kr = br, qe = Ae.parse, ze = Pe.parse, Lr = Mr, Or = {}.hasOwnProperty;
+function Mr(e, n, r) {
+  var t = r ? jr(r) : null;
+  return f;
+  function f(m, u) {
+    var g = kr(m, n), P = Array.prototype.slice.call(arguments, 2), T = g.tagName.toLowerCase(), C;
+    if (g.tagName = t && Or.call(t, T) ? t[T] : T, u && Ir(u, g) && (P.unshift(u), u = null), u)
+      for (C in u)
+        v(g.properties, C, u[C]);
+    return rn(g.children, P), g.tagName === "template" && (g.content = { type: "root", children: g.children }, g.children = []), g;
+  }
+  function v(m, u, g) {
+    var P, T, C;
+    g == null || g !== g || (P = Tr(e, u), T = P.property, C = g, typeof C == "string" && (P.spaceSeparated ? C = qe(C) : P.commaSeparated ? C = ze(C) : P.commaOrSpaceSeparated && (C = qe(ze(C).join(" ")))), T === "style" && typeof g != "string" && (C = Nr(C)), T === "className" && m.className && (C = m.className.concat(C)), m[T] = Ur(P, T, C));
+  }
+}
+function Ir(e, n) {
+  return typeof e == "string" || "length" in e || Dr(n.tagName, e);
+}
+function Dr(e, n) {
+  var r = n.type;
+  return e === "input" || !r || typeof r != "string" ? !1 : typeof n.children == "object" && "length" in n.children ? !0 : (r = r.toLowerCase(), e === "button" ? r !== "menu" && r !== "submit" && r !== "reset" && r !== "button" : "value" in n);
+}
+function rn(e, n) {
+  var r, t;
+  if (typeof n == "string" || typeof n == "number") {
+    e.push({ type: "text", value: String(n) });
+    return;
+  }
+  if (typeof n == "object" && "length" in n) {
+    for (r = -1, t = n.length; ++r < t; )
+      rn(e, n[r]);
+    return;
+  }
+  if (typeof n != "object" || !("type" in n))
+    throw new Error("Expected node, nodes, or string, got `" + n + "`");
+  e.push(n);
+}
+function Ur(e, n, r) {
+  var t, f, v;
+  if (typeof r != "object" || !("length" in r))
+    return He(e, n, r);
+  for (f = r.length, t = -1, v = []; ++t < f; )
+    v[t] = He(e, n, r[t]);
+  return v;
+}
+function He(e, n, r) {
+  var t = r;
+  return e.number || e.positiveNumber ? !isNaN(t) && t !== "" && (t = Number(t)) : (e.boolean || e.overloadedBoolean) && typeof t == "string" && (t === "" || Re(r) === Re(n)) && (t = !0), t;
+}
+function Nr(e) {
+  var n = [], r;
+  for (r in e)
+    n.push([r, e[r]].join(": "));
+  return n.join("; ");
+}
+function jr(e) {
+  for (var n = e.length, r = -1, t = {}, f; ++r < n; )
+    f = e[r], t[f.toLowerCase()] = f;
+  return t;
+}
+var Rr = sr, qr = Lr, an = qr(Rr, "div");
+an.displayName = "html";
+var zr = an, Hr = zr;
+const _r = "Æ", Br = "&", Wr = "Á", Fr = "Â", Gr = "À", Vr = "Å", Kr = "Ã", Yr = "Ä", Xr = "©", Jr = "Ç", Qr = "Ð", Zr = "É", ea = "Ê", na = "È", ra = "Ë", aa = ">", ta = "Í", la = "Î", ia = "Ì", oa = "Ï", sa = "<", ua = "Ñ", ca = "Ó", fa = "Ô", da = "Ò", va = "Ø", pa = "Õ", ga = "Ö", ha = '"', ma = "®", ya = "Þ", xa = "Ú", ba = "Û", wa = "Ù", Ca = "Ü", Sa = "Ý", Aa = "á", Pa = "â", Ea = "´", $a = "æ", Ta = "à", ka = "&", La = "å", Oa = "ã", Ma = "ä", Ia = "¦", Da = "ç", Ua = "¸", Na = "¢", ja = "©", Ra = "¤", qa = "°", za = "÷", Ha = "é", _a = "ê", Ba = "è", Wa = "ð", Fa = "ë", Ga = "½", Va = "¼", Ka = "¾", Ya = ">", Xa = "í", Ja = "î", Qa = "¡", Za = "ì", et = "¿", nt = "ï", rt = "«", at = "<", tt = "¯", lt = "µ", it = "·", ot = " ", st = "¬", ut = "ñ", ct = "ó", ft = "ô", dt = "ò", vt = "ª", pt = "º", gt = "ø", ht = "õ", mt = "ö", yt = "¶", xt = "±", bt = "£", wt = '"', Ct = "»", St = "®", At = "§", Pt = "­", Et = "¹", $t = "²", Tt = "³", kt = "ß", Lt = "þ", Ot = "×", Mt = "ú", It = "û", Dt = "ù", Ut = "¨", Nt = "ü", jt = "ý", Rt = "¥", qt = "ÿ", zt = {
+  AElig: _r,
+  AMP: Br,
+  Aacute: Wr,
+  Acirc: Fr,
+  Agrave: Gr,
+  Aring: Vr,
+  Atilde: Kr,
+  Auml: Yr,
+  COPY: Xr,
+  Ccedil: Jr,
+  ETH: Qr,
+  Eacute: Zr,
+  Ecirc: ea,
+  Egrave: na,
+  Euml: ra,
+  GT: aa,
+  Iacute: ta,
+  Icirc: la,
+  Igrave: ia,
+  Iuml: oa,
+  LT: sa,
+  Ntilde: ua,
+  Oacute: ca,
+  Ocirc: fa,
+  Ograve: da,
+  Oslash: va,
+  Otilde: pa,
+  Ouml: ga,
+  QUOT: ha,
+  REG: ma,
+  THORN: ya,
+  Uacute: xa,
+  Ucirc: ba,
+  Ugrave: wa,
+  Uuml: Ca,
+  Yacute: Sa,
+  aacute: Aa,
+  acirc: Pa,
+  acute: Ea,
+  aelig: $a,
+  agrave: Ta,
+  amp: ka,
+  aring: La,
+  atilde: Oa,
+  auml: Ma,
+  brvbar: Ia,
+  ccedil: Da,
+  cedil: Ua,
+  cent: Na,
+  copy: ja,
+  curren: Ra,
+  deg: qa,
+  divide: za,
+  eacute: Ha,
+  ecirc: _a,
+  egrave: Ba,
+  eth: Wa,
+  euml: Fa,
+  frac12: Ga,
+  frac14: Va,
+  frac34: Ka,
+  gt: Ya,
+  iacute: Xa,
+  icirc: Ja,
+  iexcl: Qa,
+  igrave: Za,
+  iquest: et,
+  iuml: nt,
+  laquo: rt,
+  lt: at,
+  macr: tt,
+  micro: lt,
+  middot: it,
+  nbsp: ot,
+  not: st,
+  ntilde: ut,
+  oacute: ct,
+  ocirc: ft,
+  ograve: dt,
+  ordf: vt,
+  ordm: pt,
+  oslash: gt,
+  otilde: ht,
+  ouml: mt,
+  para: yt,
+  plusmn: xt,
+  pound: bt,
+  quot: wt,
+  raquo: Ct,
+  reg: St,
+  sect: At,
+  shy: Pt,
+  sup1: Et,
+  sup2: $t,
+  sup3: Tt,
+  szlig: kt,
+  thorn: Lt,
+  times: Ot,
+  uacute: Mt,
+  ucirc: It,
+  ugrave: Dt,
+  uml: Ut,
+  uuml: Nt,
+  yacute: jt,
+  yen: Rt,
+  yuml: qt
+}, Ht = {
+  0: "�",
+  128: "€",
+  130: "‚",
+  131: "ƒ",
+  132: "„",
+  133: "…",
+  134: "†",
+  135: "‡",
+  136: "ˆ",
+  137: "‰",
+  138: "Š",
+  139: "‹",
+  140: "Œ",
+  142: "Ž",
+  145: "‘",
+  146: "’",
+  147: "“",
+  148: "”",
+  149: "•",
+  150: "–",
+  151: "—",
+  152: "˜",
+  153: "™",
+  154: "š",
+  155: "›",
+  156: "œ",
+  158: "ž",
+  159: "Ÿ"
+};
+var tn = _t;
+function _t(e) {
+  var n = typeof e == "string" ? e.charCodeAt(0) : e;
+  return n >= 48 && n <= 57;
+}
+var Bt = Wt;
+function Wt(e) {
+  var n = typeof e == "string" ? e.charCodeAt(0) : e;
+  return n >= 97 && n <= 102 || n >= 65 && n <= 70 || n >= 48 && n <= 57;
+}
+var Ft = Gt;
+function Gt(e) {
+  var n = typeof e == "string" ? e.charCodeAt(0) : e;
+  return n >= 97 && n <= 122 || n >= 65 && n <= 90;
+}
+var Vt = Ft, Kt = tn, Yt = Xt;
+function Xt(e) {
+  return Vt(e) || Kt(e);
+}
+var ce, Jt = 59, Qt = Zt;
+function Zt(e) {
+  var n = "&" + e + ";", r;
+  return ce = ce || document.createElement("i"), ce.innerHTML = n, r = ce.textContent, r.charCodeAt(r.length - 1) === Jt && e !== "semi" || r === n ? !1 : r;
+}
+var _e = zt, Be = Ht, el = tn, nl = Bt, ln = Yt, rl = Qt, al = hl, tl = {}.hasOwnProperty, Q = String.fromCharCode, ll = Function.prototype, We = {
+  warning: null,
+  reference: null,
+  text: null,
+  warningContext: null,
+  referenceContext: null,
+  textContext: null,
+  position: {},
+  additional: null,
+  attribute: !1,
+  nonTerminated: !0
+}, il = 9, Fe = 10, ol = 12, sl = 32, Ge = 38, ul = 59, cl = 60, fl = 61, dl = 35, vl = 88, pl = 120, gl = 65533, Z = "named", Ee = "hexadecimal", $e = "decimal", Te = {};
+Te[Ee] = 16;
+Te[$e] = 10;
+var de = {};
+de[Z] = ln;
+de[$e] = el;
+de[Ee] = nl;
+var on = 1, sn = 2, un = 3, cn = 4, fn = 5, ye = 6, dn = 7, V = {};
+V[on] = "Named character references must be terminated by a semicolon";
+V[sn] = "Numeric character references must be terminated by a semicolon";
+V[un] = "Named character references cannot be empty";
+V[cn] = "Numeric character references cannot be empty";
+V[fn] = "Named character references must be known";
+V[ye] = "Numeric character references cannot be disallowed";
+V[dn] = "Numeric character references cannot be outside the permissible Unicode range";
+function hl(e, n) {
+  var r = {}, t, f;
+  n || (n = {});
+  for (f in We)
+    t = n[f], r[f] = t ?? We[f];
+  return (r.position.indent || r.position.start) && (r.indent = r.position.indent || [], r.position = r.position.start), ml(e, r);
+}
+function ml(e, n) {
+  var r = n.additional, t = n.nonTerminated, f = n.text, v = n.reference, m = n.warning, u = n.textContext, g = n.referenceContext, P = n.warningContext, T = n.position, C = n.indent || [], B = e.length, R = 0, oe = -1, M = T.column || 1, J = T.line || 1, q = "", l = [], a, s, o, i, d, p, c, y, S, I, z, W, _, N, ne, w, k, E, b;
+  for (typeof r == "string" && (r = r.charCodeAt(0)), w = $(), y = m ? ve : ll, R--, B++; ++R < B; )
+    if (d === Fe && (M = C[oe] || 1), d = e.charCodeAt(R), d === Ge) {
+      if (c = e.charCodeAt(R + 1), c === il || c === Fe || c === ol || c === sl || c === Ge || c === cl || c !== c || r && c === r) {
+        q += Q(d), M++;
+        continue;
+      }
+      for (_ = R + 1, W = _, b = _, c === dl ? (b = ++W, c = e.charCodeAt(b), c === vl || c === pl ? (N = Ee, b = ++W) : N = $e) : N = Z, a = "", z = "", i = "", ne = de[N], b--; ++b < B && (c = e.charCodeAt(b), !!ne(c)); )
+        i += Q(c), N === Z && tl.call(_e, i) && (a = i, z = _e[i]);
+      o = e.charCodeAt(b) === ul, o && (b++, s = N === Z ? rl(i) : !1, s && (a = i, z = s)), E = 1 + b - _, !o && !t || (i ? N === Z ? (o && !z ? y(fn, 1) : (a !== i && (b = W + a.length, E = 1 + b - W, o = !1), o || (S = a ? on : un, n.attribute ? (c = e.charCodeAt(b), c === fl ? (y(S, E), z = null) : ln(c) ? z = null : y(S, E)) : y(S, E))), p = z) : (o || y(sn, E), p = parseInt(i, Te[N]), yl(p) ? (y(dn, E), p = Q(gl)) : p in Be ? (y(ye, E), p = Be[p]) : (I = "", xl(p) && y(ye, E), p > 65535 && (p -= 65536, I += Q(p >>> 10 | 55296), p = 56320 | p & 1023), p = I + Q(p))) : N !== Z && y(cn, E)), p ? (j(), w = $(), R = b - 1, M += b - _ + 1, l.push(p), k = $(), k.offset++, v && v.call(
+        g,
+        p,
+        { start: w, end: k },
+        e.slice(_ - 1, b)
+      ), w = k) : (i = e.slice(_ - 1, b), q += i, M += i.length, R = b - 1);
+    } else
+      d === 10 && (J++, oe++, M = 0), d === d ? (q += Q(d), M++) : j();
+  return l.join("");
+  function $() {
+    return {
+      line: J,
+      column: M,
+      offset: R + (T.offset || 0)
+    };
+  }
+  function ve(F, K) {
+    var G = $();
+    G.column += K, G.offset += K, m.call(P, V[F], G, F);
+  }
+  function j() {
+    q && (l.push(q), f && f.call(u, q, { start: w, end: $() }), q = "");
+  }
+}
+function yl(e) {
+  return e >= 55296 && e <= 57343 || e > 1114111;
+}
+function xl(e) {
+  return e >= 1 && e <= 8 || e === 11 || e >= 13 && e <= 31 || e >= 127 && e <= 159 || e >= 64976 && e <= 65007 || (e & 65535) === 65535 || (e & 65535) === 65534;
+}
+var vn = { exports: {} };
+(function(e) {
+  var n = 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 r = function(t) {
+    var f = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, v = 0, m = {}, u = {
+      /**
+       * 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 l(a) {
+          return a instanceof g ? new g(a.type, l(a.content), a.alias) : Array.isArray(a) ? a.map(l) : a.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(l) {
+          return Object.prototype.toString.call(l).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(l) {
+          return l.__id || Object.defineProperty(l, "__id", { value: ++v }), l.__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 l(a, s) {
+          s = s || {};
+          var o, i;
+          switch (u.util.type(a)) {
+            case "Object":
+              if (i = u.util.objId(a), s[i])
+                return s[i];
+              o = /** @type {Record<string, any>} */
+              {}, s[i] = o;
+              for (var d in a)
+                a.hasOwnProperty(d) && (o[d] = l(a[d], s));
+              return (
+                /** @type {any} */
+                o
+              );
+            case "Array":
+              return i = u.util.objId(a), s[i] ? s[i] : (o = [], s[i] = o, /** @type {Array} */
+              /** @type {any} */
+              a.forEach(function(p, c) {
+                o[c] = l(p, s);
+              }), /** @type {any} */
+              o);
+            default:
+              return a;
+          }
+        },
+        /**
+         * 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(l) {
+          for (; l; ) {
+            var a = f.exec(l.className);
+            if (a)
+              return a[1].toLowerCase();
+            l = l.parentElement;
+          }
+          return "none";
+        },
+        /**
+         * Sets the Prism `language-xxxx` class of the given element.
+         *
+         * @param {Element} element
+         * @param {string} language
+         * @returns {void}
+         */
+        setLanguage: function(l, a) {
+          l.className = l.className.replace(RegExp(f, "gi"), ""), l.classList.add("language-" + a);
+        },
+        /**
+         * 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 ("currentScript" in document)
+            return (
+              /** @type {any} */
+              document.currentScript
+            );
+          try {
+            throw new Error();
+          } catch (o) {
+            var l = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(o.stack) || [])[1];
+            if (l) {
+              var a = document.getElementsByTagName("script");
+              for (var s in a)
+                if (a[s].src == l)
+                  return a[s];
+            }
+            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(l, a, s) {
+          for (var o = "no-" + a; l; ) {
+            var i = l.classList;
+            if (i.contains(a))
+              return !0;
+            if (i.contains(o))
+              return !1;
+            l = l.parentElement;
+          }
+          return !!s;
+        }
+      },
+      /**
+       * 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: m,
+        plaintext: m,
+        text: m,
+        txt: m,
+        /**
+         * 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(l, a) {
+          var s = u.util.clone(u.languages[l]);
+          for (var o in a)
+            s[o] = a[o];
+          return s;
+        },
+        /**
+         * 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(l, a, s, o) {
+          o = o || /** @type {any} */
+          u.languages;
+          var i = o[l], d = {};
+          for (var p in i)
+            if (i.hasOwnProperty(p)) {
+              if (p == a)
+                for (var c in s)
+                  s.hasOwnProperty(c) && (d[c] = s[c]);
+              s.hasOwnProperty(p) || (d[p] = i[p]);
+            }
+          var y = o[l];
+          return o[l] = d, u.languages.DFS(u.languages, function(S, I) {
+            I === y && S != l && (this[S] = d);
+          }), d;
+        },
+        // Traverse a language definition with Depth First Search
+        DFS: function l(a, s, o, i) {
+          i = i || {};
+          var d = u.util.objId;
+          for (var p in a)
+            if (a.hasOwnProperty(p)) {
+              s.call(a, p, a[p], o || p);
+              var c = a[p], y = u.util.type(c);
+              y === "Object" && !i[d(c)] ? (i[d(c)] = !0, l(c, s, null, i)) : y === "Array" && !i[d(c)] && (i[d(c)] = !0, l(c, s, p, i));
+            }
+        }
+      },
+      plugins: {},
+      /**
+       * This is the most high-level function in Prism’s API.
+       * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
+       * each one of them.
+       *
+       * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
+       *
+       * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
+       * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
+       * @memberof Prism
+       * @public
+       */
+      highlightAll: function(l, a) {
+        u.highlightAllUnder(document, l, a);
+      },
+      /**
+       * 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(l, a, s) {
+        var o = {
+          callback: s,
+          container: l,
+          selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+        };
+        u.hooks.run("before-highlightall", o), o.elements = Array.prototype.slice.apply(o.container.querySelectorAll(o.selector)), u.hooks.run("before-all-elements-highlight", o);
+        for (var i = 0, d; d = o.elements[i++]; )
+          u.highlightElement(d, a === !0, o.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(l, a, s) {
+        var o = u.util.getLanguage(l), i = u.languages[o];
+        u.util.setLanguage(l, o);
+        var d = l.parentElement;
+        d && d.nodeName.toLowerCase() === "pre" && u.util.setLanguage(d, o);
+        var p = l.textContent, c = {
+          element: l,
+          language: o,
+          grammar: i,
+          code: p
+        };
+        function y(I) {
+          c.highlightedCode = I, u.hooks.run("before-insert", c), c.element.innerHTML = c.highlightedCode, u.hooks.run("after-highlight", c), u.hooks.run("complete", c), s && s.call(c.element);
+        }
+        if (u.hooks.run("before-sanity-check", c), d = c.element.parentElement, d && d.nodeName.toLowerCase() === "pre" && !d.hasAttribute("tabindex") && d.setAttribute("tabindex", "0"), !c.code) {
+          u.hooks.run("complete", c), s && s.call(c.element);
+          return;
+        }
+        if (u.hooks.run("before-highlight", c), !c.grammar) {
+          y(u.util.encode(c.code));
+          return;
+        }
+        if (a && t.Worker) {
+          var S = new Worker(u.filename);
+          S.onmessage = function(I) {
+            y(I.data);
+          }, S.postMessage(JSON.stringify({
+            language: c.language,
+            code: c.code,
+            immediateClose: !0
+          }));
+        } else
+          y(u.highlight(c.code, c.grammar, c.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(l, a, s) {
+        var o = {
+          code: l,
+          grammar: a,
+          language: s
+        };
+        if (u.hooks.run("before-tokenize", o), !o.grammar)
+          throw new Error('The language "' + o.language + '" has no grammar.');
+        return o.tokens = u.tokenize(o.code, o.grammar), u.hooks.run("after-tokenize", o), g.stringify(u.util.encode(o.tokens), o.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(l, a) {
+        var s = a.rest;
+        if (s) {
+          for (var o in s)
+            a[o] = s[o];
+          delete a.rest;
+        }
+        var i = new C();
+        return B(i, i.head, l), T(l, i, a, i.head, 0), oe(i);
+      },
+      /**
+       * @namespace
+       * @memberof Prism
+       * @public
+       */
+      hooks: {
+        all: {},
+        /**
+         * Adds the given callback to the list of callbacks for the given hook.
+         *
+         * The callback will be invoked when the hook it is registered for is run.
+         * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+         *
+         * One callback function can be registered to multiple hooks and the same hook multiple times.
+         *
+         * @param {string} name The name of the hook.
+         * @param {HookCallback} callback The callback function which is given environment variables.
+         * @public
+         */
+        add: function(l, a) {
+          var s = u.hooks.all;
+          s[l] = s[l] || [], s[l].push(a);
+        },
+        /**
+         * 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(l, a) {
+          var s = u.hooks.all[l];
+          if (!(!s || !s.length))
+            for (var o = 0, i; i = s[o++]; )
+              i(a);
+        }
+      },
+      Token: g
+    };
+    t.Prism = u;
+    function g(l, a, s, o) {
+      this.type = l, this.content = a, this.alias = s, this.length = (o || "").length | 0;
+    }
+    g.stringify = function l(a, s) {
+      if (typeof a == "string")
+        return a;
+      if (Array.isArray(a)) {
+        var o = "";
+        return a.forEach(function(y) {
+          o += l(y, s);
+        }), o;
+      }
+      var i = {
+        type: a.type,
+        content: l(a.content, s),
+        tag: "span",
+        classes: ["token", a.type],
+        attributes: {},
+        language: s
+      }, d = a.alias;
+      d && (Array.isArray(d) ? Array.prototype.push.apply(i.classes, d) : i.classes.push(d)), u.hooks.run("wrap", i);
+      var p = "";
+      for (var c in i.attributes)
+        p += " " + c + '="' + (i.attributes[c] || "").replace(/"/g, "&quot;") + '"';
+      return "<" + i.tag + ' class="' + i.classes.join(" ") + '"' + p + ">" + i.content + "</" + i.tag + ">";
+    };
+    function P(l, a, s, o) {
+      l.lastIndex = a;
+      var i = l.exec(s);
+      if (i && o && i[1]) {
+        var d = i[1].length;
+        i.index += d, i[0] = i[0].slice(d);
+      }
+      return i;
+    }
+    function T(l, a, s, o, i, d) {
+      for (var p in s)
+        if (!(!s.hasOwnProperty(p) || !s[p])) {
+          var c = s[p];
+          c = Array.isArray(c) ? c : [c];
+          for (var y = 0; y < c.length; ++y) {
+            if (d && d.cause == p + "," + y)
+              return;
+            var S = c[y], I = S.inside, z = !!S.lookbehind, W = !!S.greedy, _ = S.alias;
+            if (W && !S.pattern.global) {
+              var N = S.pattern.toString().match(/[imsuy]*$/)[0];
+              S.pattern = RegExp(S.pattern.source, N + "g");
+            }
+            for (var ne = S.pattern || S, w = o.next, k = i; w !== a.tail && !(d && k >= d.reach); k += w.value.length, w = w.next) {
+              var E = w.value;
+              if (a.length > l.length)
+                return;
+              if (!(E instanceof g)) {
+                var b = 1, $;
+                if (W) {
+                  if ($ = P(ne, k, l, z), !$ || $.index >= l.length)
+                    break;
+                  var K = $.index, ve = $.index + $[0].length, j = k;
+                  for (j += w.value.length; K >= j; )
+                    w = w.next, j += w.value.length;
+                  if (j -= w.value.length, k = j, w.value instanceof g)
+                    continue;
+                  for (var F = w; F !== a.tail && (j < ve || typeof F.value == "string"); F = F.next)
+                    b++, j += F.value.length;
+                  b--, E = l.slice(k, j), $.index -= k;
+                } else if ($ = P(ne, 0, E, z), !$)
+                  continue;
+                var K = $.index, G = $[0], pe = E.slice(0, K), Le = E.slice(K + G.length), ge = k + E.length;
+                d && ge > d.reach && (d.reach = ge);
+                var se = w.prev;
+                pe && (se = B(a, se, pe), k += pe.length), R(a, se, b);
+                var mn = new g(p, I ? u.tokenize(G, I) : G, _, G);
+                if (w = B(a, se, mn), Le && B(a, w, Le), b > 1) {
+                  var he = {
+                    cause: p + "," + y,
+                    reach: ge
+                  };
+                  T(l, a, s, w.prev, k, he), d && he.reach > d.reach && (d.reach = he.reach);
+                }
+              }
+            }
+          }
+        }
+    }
+    function C() {
+      var l = { value: null, prev: null, next: null }, a = { value: null, prev: l, next: null };
+      l.next = a, this.head = l, this.tail = a, this.length = 0;
+    }
+    function B(l, a, s) {
+      var o = a.next, i = { value: s, prev: a, next: o };
+      return a.next = i, o.prev = i, l.length++, i;
+    }
+    function R(l, a, s) {
+      for (var o = a.next, i = 0; i < s && o !== l.tail; i++)
+        o = o.next;
+      a.next = o, o.prev = a, l.length -= i;
+    }
+    function oe(l) {
+      for (var a = [], s = l.head.next; s !== l.tail; )
+        a.push(s.value), s = s.next;
+      return a;
+    }
+    if (!t.document)
+      return t.addEventListener && (u.disableWorkerMessageHandler || t.addEventListener("message", function(l) {
+        var a = JSON.parse(l.data), s = a.language, o = a.code, i = a.immediateClose;
+        t.postMessage(u.highlight(o, u.languages[s], s)), i && t.close();
+      }, !1)), u;
+    var M = u.util.currentScript();
+    M && (u.filename = M.src, M.hasAttribute("data-manual") && (u.manual = !0));
+    function J() {
+      u.manual || u.highlightAll();
+    }
+    if (!u.manual) {
+      var q = document.readyState;
+      q === "loading" || q === "interactive" && M && M.defer ? document.addEventListener("DOMContentLoaded", J) : window.requestAnimationFrame ? window.requestAnimationFrame(J) : window.setTimeout(J, 16);
+    }
+    return u;
+  }(n);
+  e.exports && (e.exports = r), typeof fe < "u" && (fe.Prism = r);
+})(vn);
+var bl = vn.exports, te = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof fe == "object" ? fe : {}, wl = Nl();
+te.Prism = { manual: !0, disableWorkerMessageHandler: !0 };
+var Cl = Hr, Sl = al, pn = bl, Al = xn, Pl = bn, El = wn, $l = Cn;
+wl();
+var ke = {}.hasOwnProperty;
+function gn() {
+}
+gn.prototype = pn;
+var A = new gn(), hn = A;
+A.highlight = kl;
+A.register = ie;
+A.alias = Tl;
+A.registered = Ll;
+A.listLanguages = Ol;
+ie(Al);
+ie(Pl);
+ie(El);
+ie($l);
+A.util.encode = Dl;
+A.Token.stringify = Ml;
+function ie(e) {
+  if (typeof e != "function" || !e.displayName)
+    throw new Error("Expected `function` for `grammar`, got `" + e + "`");
+  A.languages[e.displayName] === void 0 && e(A);
+}
+function Tl(e, n) {
+  var r = A.languages, t = e, f, v, m, u;
+  n && (t = {}, t[e] = n);
+  for (f in t)
+    for (v = t[f], v = typeof v == "string" ? [v] : v, m = v.length, u = -1; ++u < m; )
+      r[v[u]] = r[f];
+}
+function kl(e, n) {
+  var r = pn.highlight, t;
+  if (typeof e != "string")
+    throw new Error("Expected `string` for `value`, got `" + e + "`");
+  if (A.util.type(n) === "Object")
+    t = n, n = null;
+  else {
+    if (typeof n != "string")
+      throw new Error("Expected `string` for `name`, got `" + n + "`");
+    if (ke.call(A.languages, n))
+      t = A.languages[n];
+    else
+      throw new Error("Unknown language: `" + n + "` is not registered");
+  }
+  return r.call(this, e, t, n);
+}
+function Ll(e) {
+  if (typeof e != "string")
+    throw new Error("Expected `string` for `language`, got `" + e + "`");
+  return ke.call(A.languages, e);
+}
+function Ol() {
+  var e = A.languages, n = [], r;
+  for (r in e)
+    ke.call(e, r) && typeof e[r] == "object" && n.push(r);
+  return n;
+}
+function Ml(e, n, r) {
+  var t;
+  return typeof e == "string" ? { type: "text", value: e } : A.util.type(e) === "Array" ? Il(e, n) : (t = {
+    type: e.type,
+    content: A.Token.stringify(e.content, n, r),
+    tag: "span",
+    classes: ["token", e.type],
+    attributes: {},
+    language: n,
+    parent: r
+  }, e.alias && (t.classes = t.classes.concat(e.alias)), A.hooks.run("wrap", t), Cl(
+    t.tag + "." + t.classes.join("."),
+    Ul(t.attributes),
+    t.content
+  ));
+}
+function Il(e, n) {
+  for (var r = [], t = e.length, f = -1, v; ++f < t; )
+    v = e[f], v !== "" && v !== null && v !== void 0 && r.push(v);
+  for (f = -1, t = r.length; ++f < t; )
+    v = r[f], r[f] = A.Token.stringify(v, n, r);
+  return r;
+}
+function Dl(e) {
+  return e;
+}
+function Ul(e) {
+  var n;
+  for (n in e)
+    e[n] = Sl(e[n]);
+  return e;
+}
+function Nl() {
+  var e = "Prism" in te, n = e ? te.Prism : void 0;
+  return r;
+  function r() {
+    e ? te.Prism = n : delete te.Prism, e = void 0, n = void 0;
+  }
+}
+const jl = /* @__PURE__ */ yn(hn), Bl = /* @__PURE__ */ Sn({
+  __proto__: null,
+  default: jl
+}, [hn]);
+export {
+  Bl as c
+};