@oharness/server 0.5.0 → 0.5.1

package/dist/markdown.js

@@ -18,109 +18,560 @@ const el = (tag, cls, text) => {
 };
 
 // --- markdown -------------------------------------------------------------
-// A small subset: fences, headings, lists, quotes, and inline code/bold/italic
-// /links. Anything unrecognised stays literal text, which is the safe default
-// for a renderer fed by a language model.
+// GitHub-flavoured blocks (fences, headings, rules, tables, quotes, nested and
+// task lists) and inlines (code, emphasis, strikethrough, links, autolinks,
+// escapes). Raw HTML is not rendered: it stays literal text, which is the safe
+// default for a renderer fed by a language model. The one exception is <br>,
+// which models write inside table cells and which becomes a node, not markup.
+
+const HR_RE = /^ {0,3}([-*_])( *\1){2,} *$/;
+const HEADING_RE = /^ {0,3}(#{1,6})(?: +(.*?))?(?: +#+)? *$/;
+const QUOTE_RE = /^ {0,3}> ?/;
+const LIST_RE = /^( *)([-*+]|\d{1,9}[.)])( +|$)/;
+const TASK_RE = /^\[([ xX])\] +/;
+const TABLE_DELIM_RE = /^ *\|? *:?-+:? *(\| *:?-+:? *)*\|? *$/;
+const FENCE_CLOSE_RE = /^ {0,3}(@@FENCE@@+|~~~+) *$/;
 
 function renderMarkdown(source) {
   const root = el("div", "md");
-  const lines = source.split("\n");
+  const lines = String(source).replace(/\r\n?/g, "\n").replace(/\t/g, "    ").split("\n");
+  renderBlocks(root, lines);
+  return root;
+}
+
+function matchFence(line) {
+  const match = /^( {0,3})(@@FENCE@@+|~~~+)(.*)$/.exec(line);
+  if (!match) return null;
+  // A backtick fence cannot carry a backtick in its info string; without this
+  // a one-line code span written with triple backticks swallows the reply.
+  if (match[2][0] !== "~" && match[3].includes("@@BT@@")) return null;
+  return { indent: match[1].length, marker: match[2], lang: match[3].trim().split(/\s+/)[0] || "" };
+}
+
+function isTableStart(lines, i) {
+  if (i + 1 >= lines.length) return false;
+  const head = lines[i];
+  const delim = lines[i + 1];
+  if (!head.includes("|") || !delim.includes("|") || !TABLE_DELIM_RE.test(delim)) return false;
+  return splitRow(head).length === splitRow(delim).length;
+}
+
+function isBlockStart(lines, i) {
+  const line = lines[i];
+  return (
+    matchFence(line) !== null ||
+    HEADING_RE.test(line) ||
+    HR_RE.test(line) ||
+    QUOTE_RE.test(line) ||
+    LIST_RE.test(line) ||
+    isTableStart(lines, i)
+  );
+}
+
+const indentOf = (line) => line.length - line.trimStart().length;
+const stripIndent = (line, n) => line.slice(Math.min(n, indentOf(line)));
+
+function renderBlocks(parent, lines) {
   let i = 0;
 
   while (i < lines.length) {
     const line = lines[i];
 
-    if (/^@@FENCE@@/.test(line)) {
-      const lang = line.slice(3).trim();
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+
+    const fence = matchFence(line);
+    if (fence) {
       const body = [];
       i++;
-      while (i < lines.length && !/^@@FENCE@@/.test(lines[i])) body.push(lines[i++]);
+      while (i < lines.length) {
+        const close = FENCE_CLOSE_RE.exec(lines[i]);
+        if (close && close[1][0] === fence.marker[0] && close[1].length >= fence.marker.length) break;
+        body.push(stripIndent(lines[i], fence.indent));
+        i++;
+      }
+      // Past the closing fence, or past the end while a reply is still
+      // streaming: an unclosed fence shows as code until the rest arrives.
       i++;
-      root.appendChild(codeBlock(body.join("\n"), lang));
+      parent.appendChild(codeBlock(body.join("\n"), fence.lang));
       continue;
     }
 
-    const heading = /^(#{1,4})\s+(.*)$/.exec(line);
+    const heading = HEADING_RE.exec(line);
     if (heading) {
-      root.appendChild(inline(el("h" + (heading[1].length + 2), "md-h"), heading[2]));
+      const depth = heading[1].length;
+      // Shifted down two levels: the page's own chrome owns h1 and h2.
+      const node = el("h" + Math.min(depth + 2, 6), "md-h md-h" + Math.min(depth, 4));
+      parent.appendChild(inline(node, heading[2] || ""));
       i++;
       continue;
     }
 
-    if (/^\s*>/.test(line)) {
-      const body = [];
-      while (i < lines.length && /^\s*>/.test(lines[i])) body.push(lines[i++].replace(/^\s*>\s?/, ""));
-      const quote = el("blockquote", "md-quote");
-      quote.appendChild(renderMarkdown(body.join("\n")));
-      root.appendChild(quote);
+    // Before lists, which "* * *" would otherwise also match.
+    if (HR_RE.test(line)) {
+      parent.appendChild(el("hr", "md-hr"));
+      i++;
       continue;
     }
 
-    if (/^\s*([-*+]|\d+\.)\s+/.test(line)) {
-      const ordered = /^\s*\d+\./.test(line);
-      const list = el(ordered ? "ol" : "ul", "md-list");
-      while (i < lines.length && /^\s*([-*+]|\d+\.)\s+/.test(lines[i])) {
-        const item = lines[i++].replace(/^\s*([-*+]|\d+\.)\s+/, "");
-        list.appendChild(inline(el("li"), item));
+    if (isTableStart(lines, i)) {
+      i = renderTable(parent, lines, i);
+      continue;
+    }
+
+    if (QUOTE_RE.test(line)) {
+      const body = [];
+      while (i < lines.length) {
+        if (QUOTE_RE.test(lines[i])) body.push(lines[i++].replace(QUOTE_RE, ""));
+        // A lazy continuation line belongs to the quote's paragraph.
+        else if (lines[i].trim() !== "" && body.length && body[body.length - 1].trim() !== "" && !isBlockStart(lines, i)) body.push(lines[i++]);
+        else break;
       }
-      root.appendChild(list);
+      const quote = el("blockquote", "md-quote");
+      renderBlocks(quote, body);
+      parent.appendChild(quote);
       continue;
     }
 
-    if (line.trim() === "") {
-      i++;
+    if (LIST_RE.test(line)) {
+      i = renderList(parent, lines, i);
       continue;
     }
 
     const paragraph = [];
-    while (
-      i < lines.length &&
-      lines[i].trim() !== "" &&
-      !/^@@FENCE@@|^\s*>|^#{1,4}\s|^\s*([-*+]|\d+\.)\s+/.test(lines[i])
-    ) {
-      paragraph.push(lines[i++]);
-    }
-    root.appendChild(inline(el("p", "md-p"), paragraph.join("\n")));
+    while (i < lines.length && lines[i].trim() !== "" && (paragraph.length === 0 || !isBlockStart(lines, i))) {
+      // Trailing double spaces and a trailing backslash are hard breaks; the
+      // paragraph keeps its newlines anyway, so the markers only need removing.
+      paragraph.push(lines[i++].trim().replace(/\\$/, ""));
+    }
+    parent.appendChild(inline(el("p", "md-p"), paragraph.join("\n")));
   }
+}
 
-  return root;
+function splitRow(line) {
+  let text = line.trim();
+  if (text.startsWith("|")) text = text.slice(1);
+  if (text.endsWith("|") && !text.endsWith("\\|")) text = text.slice(0, -1);
+
+  const cells = [];
+  let cell = "";
+  let code = false;
+  for (let k = 0; k < text.length; k++) {
+    const ch = text[k];
+    if (ch === "\\" && text[k + 1] === "|") {
+      cell += "|";
+      k++;
+      continue;
+    }
+    if (ch === "@@BT@@") code = !code;
+    if (ch === "|" && !code) {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += ch;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+
+function renderTable(parent, lines, start) {
+  const head = splitRow(lines[start]);
+  const aligns = splitRow(lines[start + 1]).map((cell) =>
+    cell.startsWith(":") && cell.endsWith(":") ? "center" : cell.endsWith(":") ? "right" : cell.startsWith(":") ? "left" : "",
+  );
+
+  const cellNode = (tag, text, k) => {
+    const node = el(tag);
+    if (aligns[k]) node.style.textAlign = aligns[k];
+    return inline(node, text || "");
+  };
+
+  const table = el("table", "md-table");
+  const thead = el("thead");
+  const headRow = el("tr");
+  head.forEach((text, k) => headRow.appendChild(cellNode("th", text, k)));
+  thead.appendChild(headRow);
+  table.appendChild(thead);
+
+  const tbody = el("tbody");
+  let i = start + 2;
+  while (i < lines.length && lines[i].trim() !== "" && lines[i].includes("|") && !isBlockStart(lines, i)) {
+    const cells = splitRow(lines[i++]);
+    const row = el("tr");
+    // Every row as wide as the header: extra cells are dropped, missing ones
+    // left empty, so a ragged row cannot shift the columns under it.
+    head.forEach((_, k) => row.appendChild(cellNode("td", cells[k], k)));
+    tbody.appendChild(row);
+  }
+  if (tbody.childNodes.length) table.appendChild(tbody);
+
+  // Scrolls on its own, so a wide table never widens the transcript.
+  const wrap = el("div", "md-table-wrap");
+  wrap.appendChild(table);
+  parent.appendChild(wrap);
+  return i;
+}
+
+function renderList(parent, lines, start) {
+  const first = LIST_RE.exec(lines[start]);
+  const indent = first[1].length;
+  const ordered = /\d/.test(first[2]);
+  const list = el(ordered ? "ol" : "ul", "md-list");
+  if (ordered && parseInt(first[2], 10) !== 1) list.start = parseInt(first[2], 10);
+
+  const items = [];
+  let loose = false;
+  let i = start;
+
+  while (i < lines.length) {
+    const marker = LIST_RE.exec(lines[i]);
+    // A sibling sits at this list's own indent (give or take a space) and uses
+    // the same kind of marker; anything else ends the list.
+    if (!marker || HR_RE.test(lines[i]) || marker[1].length >= indent + 2 || /\d/.test(marker[2]) !== ordered) break;
+
+    const empty = marker[3] === "";
+    const wide = marker[3].length > 4;
+    const content = empty || wide ? marker[1].length + marker[2].length + 1 : marker[0].length;
+    const nest = Math.min(content, indent + 2);
+    const body = [wide ? lines[i].slice(content) : lines[i].slice(marker[0].length)];
+    i++;
+
+    while (i < lines.length) {
+      const line = lines[i];
+      if (line.trim() === "") {
+        let next = i + 1;
+        while (next < lines.length && lines[next].trim() === "") next++;
+        if (next < lines.length && indentOf(lines[next]) >= nest) {
+          body.push("");
+          i++;
+          continue;
+        }
+        break;
+      }
+      if (indentOf(line) >= nest) {
+        body.push(stripIndent(line, content));
+        i++;
+        continue;
+      }
+      if (isBlockStart(lines, i) || body[body.length - 1].trim() === "") break;
+      // Lazy continuation of the item's paragraph.
+      body.push(line.trim());
+      i++;
+    }
+
+    while (body.length > 1 && body[body.length - 1].trim() === "") body.pop();
+    if (body.some((text, k) => k > 0 && text === "" && k < body.length - 1)) loose = true;
+    items.push(body);
+
+    // Past blank lines that separate this item from the next sibling.
+    while (i < lines.length && lines[i].trim() === "") {
+      let next = i;
+      while (next < lines.length && lines[next].trim() === "") next++;
+      const sibling = next < lines.length ? LIST_RE.exec(lines[next]) : null;
+      if (!sibling || sibling[1].length >= indent + 2 || /\d/.test(sibling[2]) !== ordered) break;
+      loose = true;
+      i = next;
+    }
+  }
+
+  for (const body of items) {
+    const li = el("li");
+    const task = TASK_RE.exec(body[0]);
+    if (task) body[0] = body[0].slice(task[0].length);
+    renderBlocks(li, body);
+    if (!loose) unwrapParagraphs(li);
+
+    if (task) {
+      const box = el("input", "md-check");
+      box.type = "checkbox";
+      box.checked = task[1] !== " ";
+      box.disabled = true;
+      li.className = "md-task";
+      const target = li.firstChild && li.firstChild.className === "md-p" ? li.firstChild : li;
+      target.insertBefore(box, target.firstChild);
+    }
+    list.appendChild(li);
+  }
+
+  if (loose) list.className += " md-loose";
+  parent.appendChild(list);
+  return i;
+}
+
+/** A tight list item reads as a line of text, not as paragraphs with margins. */
+function unwrapParagraphs(li) {
+  for (const child of Array.from(li.childNodes)) {
+    if (child.className !== "md-p") continue;
+    while (child.firstChild) li.insertBefore(child.firstChild, child);
+    li.removeChild(child);
+  }
+}
+
+// --- inlines --------------------------------------------------------------
+
+const ESCAPABLE = "!\"#$%&'()*+,-./:;<=>?@[\\]^_@@BT@@{|}~";
+const BR_RE = /<br *\/?>/iy;
+const ANGLE_LINK_RE = /<((?:https?:\/\/|mailto:)[^\s<>]+)>/iy;
+const BARE_URL_RE = /https?:\/\/[^\s<>]+/iy;
+
+/** Only http(s) and mailto: a javascript: or data: URL from model output would run script in a page that can drive the agent. */
+function safeHref(href) {
+  const url = href.trim();
+  return /^(https?:\/\/|mailto:)/i.test(url) ? url : null;
+}
+
+function linkNode(href, label, parseLabel) {
+  const link = el("a", "md-link");
+  link.href = href;
+  link.target = "_blank";
+  link.rel = "noopener noreferrer";
+  if (parseLabel) inline(link, label);
+  else link.textContent = label;
+  return link;
+}
+
+/** The index of a run of exactly run backticks at or after from, or -1. */
+function findCodeClose(text, from, run) {
+  let k = from;
+  while ((k = text.indexOf("@@BT@@", k)) !== -1) {
+    let len = 1;
+    while (text[k + len] === "@@BT@@") len++;
+    if (len === run) return k;
+    k += len;
+  }
+  return -1;
+}
+
+/** Past a code span starting at k, or k itself when the backticks never close. */
+function skipCode(text, k) {
+  let run = 1;
+  while (text[k + run] === "@@BT@@") run++;
+  const close = findCodeClose(text, k + run, run);
+  return close === -1 ? k + run : close + run;
+}
+
+/** [label](destination "title"), starting at the bracket; null when it is not one. */
+function parseLink(text, start) {
+  let depth = 0;
+  let k = start;
+  for (; k < text.length; k++) {
+    const ch = text[k];
+    if (ch === "\\") k++;
+    else if (ch === "@@BT@@") k = skipCode(text, k) - 1;
+    else if (ch === "[") depth++;
+    else if (ch === "]" && --depth === 0) break;
+  }
+  if (k >= text.length || text[k + 1] !== "(") return null;
+
+  const label = text.slice(start + 1, k);
+  let p = k + 2;
+  while (text[p] === " ") p++;
+
+  let href;
+  if (text[p] === "<") {
+    const end = text.indexOf(">", p);
+    if (end === -1) return null;
+    href = text.slice(p + 1, end);
+    p = end + 1;
+  } else {
+    const begin = p;
+    let parens = 0;
+    for (; p < text.length; p++) {
+      const ch = text[p];
+      if (ch === "\\") p++;
+      else if (ch === "(") parens++;
+      else if (ch === ")" && parens-- === 0) break;
+      else if (ch === " " || ch === "\n") break;
+    }
+    href = text.slice(begin, p);
+  }
+
+  while (text[p] === " ") p++;
+  if (text[p] === "\"" || text[p] === "'") {
+    const end = text.indexOf(text[p], p + 1);
+    if (end === -1) return null;
+    p = end + 1;
+    while (text[p] === " ") p++;
+  }
+  if (text[p] !== ")") return null;
+  return { label, href, end: p + 1 };
+}
+
+/**
+ * Where the emphasis opened at start with size delimiters closes, as
+ * [contentEnd, resumeAt], or null.
+ *
+ * The opener must touch a non-space and the closer follow one, so "2 * 3 * 4"
+ * stays arithmetic; underscores must also sit outside a word, so snake_case
+ * names stay names.
+ */
+function findEmphasisClose(text, start, ch, size) {
+  const word = /[\p{L}\p{N}]/u;
+  const after = text[start + size];
+  if (after === undefined || /\s/.test(after)) return null;
+  if (ch === "_" && start > 0 && word.test(text[start - 1])) return null;
+
+  let k = start + size + 1;
+  while (k < text.length) {
+    const c = text[k];
+    if (c === "\\") {
+      k += 2;
+      continue;
+    }
+    if (c === "@@BT@@") {
+      k = skipCode(text, k);
+      continue;
+    }
+    if (c !== ch) {
+      k++;
+      continue;
+    }
+    let run = 1;
+    while (text[k + run] === ch) run++;
+    const closes =
+      !/\s/.test(text[k - 1]) &&
+      (ch !== "_" || !word.test(text[k + run] || "")) &&
+      (size === 2 ? run >= 2 : run === 1 || run >= 3);
+    // A longer closing run gives up its last delimiters, so ***a*** closes
+    // the strong outside the emphasis inside it.
+    if (closes) return [k + run - size, k + run];
+    k += run;
+  }
+  return null;
 }
 
 /** Inline spans, appended as nodes so no markup can come from the text. */
 function inline(parent, text) {
-  const pattern = /(@@BT@@[^@@BT@@]+@@BT@@)|(\*\*[^*]+\*\*)|(\*[^*]+\*)|(\[[^\]]+\]\([^)]+\))/g;
-  let last = 0;
-  let match;
+  let buffer = "";
+  const flush = () => {
+    if (buffer) parent.appendChild(document.createTextNode(buffer));
+    buffer = "";
+  };
+  const push = (node) => {
+    flush();
+    parent.appendChild(node);
+  };
 
-  while ((match = pattern.exec(text)) !== null) {
-    if (match.index > last) parent.appendChild(document.createTextNode(text.slice(last, match.index)));
-    const token = match[0];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
 
-    if (token.startsWith("@@BT@@")) {
-      parent.appendChild(el("code", "md-code", token.slice(1, -1)));
-    } else if (token.startsWith("**")) {
-      parent.appendChild(el("strong", null, token.slice(2, -2)));
-    } else if (token.startsWith("*")) {
-      parent.appendChild(el("em", null, token.slice(1, -1)));
-    } else {
-      const label = token.slice(1, token.indexOf("]"));
-      const href = token.slice(token.indexOf("(") + 1, -1);
-      // Only http(s): a javascript: or data: URL from model output would run
-      // script in a page that can drive the agent.
-      if (/^https?:\/\//i.test(href)) {
-        const link = el("a", "md-link", label);
-        link.href = href;
-        link.target = "_blank";
-        link.rel = "noopener noreferrer";
-        parent.appendChild(link);
-      } else {
-        parent.appendChild(document.createTextNode(token));
+    if (ch === "\\" && i + 1 < text.length && (ESCAPABLE.includes(text[i + 1]) || text[i + 1] === "\n")) {
+      buffer += text[i + 1];
+      i += 2;
+      continue;
+    }
+
+    if (ch === "@@BT@@") {
+      let run = 1;
+      while (text[i + run] === "@@BT@@") run++;
+      const close = findCodeClose(text, i + run, run);
+      if (close === -1) {
+        buffer += text.slice(i, i + run);
+        i += run;
+        continue;
       }
+      let code = text.slice(i + run, close).replace(/\n/g, " ");
+      if (code.length > 2 && code[0] === " " && code[code.length - 1] === " " && code.trim()) code = code.slice(1, -1);
+      push(el("code", "md-code", code));
+      i = close + run;
+      continue;
     }
-    last = match.index + token.length;
+
+    if (ch === "<") {
+      BR_RE.lastIndex = i;
+      const br = BR_RE.exec(text);
+      if (br) {
+        push(el("br"));
+        i += br[0].length;
+        continue;
+      }
+      ANGLE_LINK_RE.lastIndex = i;
+      const auto = ANGLE_LINK_RE.exec(text);
+      if (auto) {
+        push(linkNode(auto[1], auto[1].replace(/^mailto:/i, ""), false));
+        i += auto[0].length;
+        continue;
+      }
+    }
+
+    if (ch === "!" && text[i + 1] === "[") {
+      const image = parseLink(text, i + 1);
+      if (image) {
+        // A link, not an <img>: a remote image loads without a click, so an
+        // address composed by a model that read a hostile page would carry
+        // whatever it put in the query string straight off this machine.
+        const href = safeHref(image.href);
+        const label = "🖼 " + (image.label || image.href);
+        push(href ? linkNode(href, label, false) : el("span", "md-dead", label));
+        i = image.end;
+        continue;
+      }
+    }
+
+    if (ch === "[") {
+      const link = parseLink(text, i);
+      if (link) {
+        const href = safeHref(link.href);
+        // A label that is itself a URL would autolink into an anchor inside
+        // an anchor.
+        if (href) push(linkNode(href, link.label, !/^https?:\/\/\S*$/i.test(link.label)));
+        else {
+          // A relative path or an anchor has nowhere to go on this page; the
+          // label stays readable and the target is on hover.
+          const dead = inline(el("span", "md-dead"), link.label);
+          dead.title = link.href;
+          push(dead);
+        }
+        i = link.end;
+        continue;
+      }
+    }
+
+    if ((ch === "h" || ch === "H") && (i === 0 || !/[\w/]/.test(text[i - 1]))) {
+      BARE_URL_RE.lastIndex = i;
+      const bare = BARE_URL_RE.exec(text);
+      if (bare) {
+        let url = bare[0].replace(/[?!.,:;*_~'"]+$/, "");
+        // A closing paren belongs to the URL only when it has an opener in it,
+        // so "(see https://x.dev)" leaves the paren outside the link.
+        while (url.endsWith(")") && url.split("(").length < url.split(")").length) url = url.slice(0, -1);
+        push(linkNode(url, url, false));
+        i += url.length;
+        continue;
+      }
+    }
+
+    if (ch === "*" || ch === "_" || ch === "~") {
+      let run = 1;
+      while (text[i + run] === ch) run++;
+      const sizes = ch === "~" ? (run === 2 ? [2] : []) : run >= 2 ? [2, 1] : [1];
+      let done = false;
+      for (const size of sizes) {
+        const close = findEmphasisClose(text, i, ch, size);
+        if (!close) continue;
+        const tag = ch === "~" ? "del" : size === 2 ? "strong" : "em";
+        // The rest of a longer opening run stays inside, so ***a*** nests the
+        // emphasis within the strong.
+        push(inline(el(tag), text.slice(i + size, close[0])));
+        i = close[1];
+        done = true;
+        break;
+      }
+      if (done) continue;
+      buffer += text.slice(i, i + run);
+      i += run;
+      continue;
+    }
+
+    buffer += ch;
+    i++;
   }
 
-  if (last < text.length) parent.appendChild(document.createTextNode(text.slice(last)));
+  flush();
   return parent;
 }
 

package/dist/markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsOrB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC"}
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyqBrB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC"}