@oddkin/ai 0.0.0-stage → 1.0.0-beta.1

package/dist/prod/markdown/parse.js

@@ -0,0 +1,363 @@
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/, HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/, RULE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/, BULLET = /^( {0,3})([-*+])([ \t]+|$)(.*)$/, ORDERED = /^( {0,3})(\d{1,9})([.)])([ \t]+|$)(.*)$/, QUOTE = /^ {0,3}> ?(.*)$/, TABLE_DELIMITER = /^ *\|? *:?-+:? *(?:\| *:?-+:? *)*\|? *$/, HTML_BLOCK = /^ {0,3}<(?:[a-zA-Z][\w-]*|\/[a-zA-Z][\w-]*|!--)/, isBlank = (line) => /^[ \t]*$/.test(line);
+function splitBlocks(source) {
+  const lines = source.split(/\r\n|\r|\n/), blocks = [];
+  let current = [], fence, kind;
+  const flush = () => {
+    current.length && blocks.push(current.join(`
+`)), current = [], kind = void 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (fence) {
+      current.push(line);
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+      close && close[1]?.[0] === fence[0] && (close[1]?.length ?? 0) >= fence.length && (fence = void 0, flush());
+      continue;
+    }
+    const open = FENCE.exec(line);
+    if (open && !(open[1]?.startsWith("`") && open[2]?.includes("`"))) {
+      flush(), fence = open[1], current.push(line);
+      continue;
+    }
+    if (isBlank(line)) {
+      const next = lines.slice(i + 1).find((l) => !isBlank(l));
+      if (next !== void 0 && (kind === "bullet" && BULLET.test(next) || kind === "ordered" && ORDERED.test(next) || (kind === "bullet" || kind === "ordered") && /^ {2,}\S/.test(next))) {
+        current.push(line);
+        continue;
+      }
+      flush();
+      continue;
+    }
+    if (!current.length)
+      kind = BULLET.test(line) ? "bullet" : ORDERED.test(line) ? "ordered" : "other";
+    else if (HEADING.test(line) || RULE.test(line)) {
+      flush(), blocks.push(line);
+      continue;
+    }
+    if (!current.length && (HEADING.test(line) || RULE.test(line))) {
+      blocks.push(line), kind = void 0;
+      continue;
+    }
+    current.push(line);
+  }
+  return flush(), blocks;
+}
+function parseBlocks(source, options = {}) {
+  return parseLines(source.split(/\r\n|\r|\n/), options);
+}
+function parseLines(lines, options) {
+  const blocks = [];
+  let i = 0;
+  for (; i < lines.length; ) {
+    const line = lines[i];
+    if (isBlank(line)) {
+      i++;
+      continue;
+    }
+    const fence = FENCE.exec(line);
+    if (fence && !(fence[1]?.startsWith("`") && fence[2]?.includes("`"))) {
+      const marker = fence[1], lang = (fence[2] ?? "").trim().split(/\s+/)[0] ?? "", body = [];
+      let open = !0;
+      for (i++; i < lines.length; ) {
+        const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(lines[i]);
+        if (close && close[1]?.[0] === marker[0] && (close[1]?.length ?? 0) >= marker.length) {
+          open = !1, i++;
+          break;
+        }
+        body.push(lines[i]), i++;
+      }
+      blocks.push({ type: "code", lang, text: body.join(`
+`), open });
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      blocks.push({
+        type: "heading",
+        level: heading[1]?.length ?? 1,
+        children: parseInline(heading[2] ?? "", options)
+      }), i++;
+      continue;
+    }
+    if (RULE.test(line)) {
+      blocks.push({ type: "rule" }), i++;
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      const inner = [];
+      for (; i < lines.length && !isBlank(lines[i]); ) {
+        const match = QUOTE.exec(lines[i]);
+        inner.push(match ? match[1] ?? "" : lines[i]), i++;
+      }
+      blocks.push({ type: "quote", children: parseLines(inner, options) });
+      continue;
+    }
+    if (BULLET.test(line) || ORDERED.test(line)) {
+      const [list, next] = parseList(lines, i, options);
+      blocks.push(list), i = next;
+      continue;
+    }
+    if (line.includes("|") && i + 1 < lines.length && TABLE_DELIMITER.test(lines[i + 1]) && lines[i + 1].includes("-")) {
+      const head = cells(line), align = cells(lines[i + 1]).map((c) => {
+        const left = c.startsWith(":"), right = c.endsWith(":");
+        return left && right ? "center" : right ? "right" : left ? "left" : null;
+      }), rows = [];
+      for (i += 2; i < lines.length && !isBlank(lines[i]) && lines[i].includes("|"); )
+        rows.push(cells(lines[i]).slice(0, head.length).map((c) => parseInline(c, options))), i++;
+      blocks.push({ type: "table", align, head: head.map((c) => parseInline(c, options)), rows });
+      continue;
+    }
+    if (HTML_BLOCK.test(line)) {
+      const raw = [];
+      for (; i < lines.length && !isBlank(lines[i]); )
+        raw.push(lines[i++]);
+      blocks.push({ type: "html", raw: raw.join(`
+`) });
+      continue;
+    }
+    const paragraph = [];
+    for (; i < lines.length; ) {
+      const l = lines[i];
+      if (isBlank(l) || HEADING.test(l) || RULE.test(l) || QUOTE.test(l) || FENCE.test(l) || paragraph.length && (BULLET.test(l) || ORDERED.test(l)))
+        break;
+      paragraph.push(l), i++;
+    }
+    blocks.push({ type: "paragraph", children: parseInline(paragraph.join(`
+`), options) });
+  }
+  return blocks;
+}
+function cells(row) {
+  let text = row.trim();
+  text.startsWith("|") && (text = text.slice(1)), text.endsWith("|") && !text.endsWith("\\|") && (text = text.slice(0, -1));
+  const out = [];
+  let cell = "";
+  for (let k = 0; k < text.length; k++) {
+    const ch = text[k];
+    ch === "\\" && text[k + 1] === "|" ? (cell += "|", k++) : ch === "|" ? (out.push(cell.trim()), cell = "") : cell += ch;
+  }
+  return out.push(cell.trim()), out;
+}
+function parseList(lines, start, options) {
+  const first = lines[start], ordered = ORDERED.test(first), firstMatch = ordered ? ORDERED.exec(first) : BULLET.exec(first), indent = (firstMatch?.[1] ?? "").length, startNumber = ordered ? Number(firstMatch?.[2] ?? 1) : 1, items = [];
+  let current, contentIndent = 0, i = start;
+  for (; i < lines.length; i++) {
+    const line = lines[i], match = ordered ? ORDERED.exec(line) : BULLET.exec(line);
+    if (match && (match[1] ?? "").length === indent) {
+      current && items.push(parseLines(current, options));
+      const marker = ordered ? `${match[2]}${match[3]}` : match[2], gap = ordered ? match[4] : match[3];
+      contentIndent = indent + marker.length + Math.max(1, (gap ?? " ").length), current = [(ordered ? match[5] : match[4]) ?? ""];
+      continue;
+    }
+    if (isBlank(line)) {
+      const next = lines.slice(i + 1).find((l) => !isBlank(l));
+      if (next === void 0)
+        break;
+      const nextMatch = ordered ? ORDERED.exec(next) : BULLET.exec(next);
+      if (!(nextMatch && (nextMatch[1] ?? "").length === indent || next.search(/\S/) >= Math.min(contentIndent, indent + 2)))
+        break;
+      current?.push("");
+      continue;
+    }
+    const lead = line.search(/\S/);
+    if (lead >= Math.min(contentIndent, indent + 2)) {
+      current?.push(line.slice(Math.min(lead, contentIndent)));
+      continue;
+    }
+    if (!BULLET.test(line) && !ORDERED.test(line) && !HEADING.test(line) && !RULE.test(line) && !FENCE.test(line) && !QUOTE.test(line)) {
+      current?.push(line);
+      continue;
+    }
+    break;
+  }
+  return current && items.push(parseLines(current, options)), [{ type: "list", ordered, start: startNumber, items }, i];
+}
+const PUNCTUATION = /[!-/:-@[-`{-~]/, AUTOLINK = /^<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>]*)>/, BARE_URL = /^https?:\/\/[^\s<>()]*[^\s<>().,;:!?'"*_~\]]/, CITATION = /^\[\^([A-Za-z0-9][\w.:-]*)\]/;
+function parseInline(text, options = {}) {
+  const out = inline(text, options, !0);
+  return merge(out);
+}
+function merge(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    const last = out[out.length - 1];
+    node.type === "text" && last?.type === "text" ? out[out.length - 1] = { type: "text", text: last.text + node.text } : (node.type !== "text" || node.text) && out.push(node);
+  }
+  return out;
+}
+function inline(text, options, atEnd) {
+  const out = [];
+  let buffer = "";
+  const flushText = () => {
+    buffer && out.push({ type: "text", text: buffer }), buffer = "";
+  };
+  let i = 0;
+  for (; i < text.length; ) {
+    const ch = text[i], rest = text.slice(i);
+    if (ch === "\\") {
+      const next = text[i + 1];
+      if (next === `
+`) {
+        flushText(), out.push({ type: "break" }), i += 2;
+        continue;
+      }
+      if (next !== void 0 && PUNCTUATION.test(next)) {
+        buffer += next, i += 2;
+        continue;
+      }
+    }
+    if (ch === `
+`) {
+      for (buffer.endsWith("  ") ? (buffer = buffer.replace(/ +$/, ""), flushText(), out.push({ type: "break" })) : (buffer = buffer.replace(/ +$/, ""), buffer += " "), i++; text[i] === " "; )
+        i++;
+      continue;
+    }
+    if (ch === "`") {
+      const run = /^`+/.exec(rest)?.[0], close = text.indexOf(run, i + run.length);
+      if (close !== -1 && text[close + run.length] !== "`") {
+        flushText();
+        let code = text.slice(i + run.length, close).replace(/\n/g, " ");
+        code.length > 2 && code.startsWith(" ") && code.endsWith(" ") && (code = code.slice(1, -1)), out.push({ type: "code", text: code }), i = close + run.length;
+        continue;
+      }
+      if (options.repair && atEnd) {
+        flushText(), out.push({ type: "code", text: text.slice(i + run.length) }), i = text.length;
+        continue;
+      }
+      buffer += run, i += run.length;
+      continue;
+    }
+    if (ch === "[") {
+      const citation = CITATION.exec(rest);
+      if (citation) {
+        flushText(), out.push({ type: "citation", id: citation[1] }), i += citation[0].length;
+        continue;
+      }
+      const link = matchLink(text, i);
+      if (link) {
+        flushText(), out.push({
+          type: "link",
+          href: link.href,
+          title: link.title,
+          children: inline(link.label, options, !1)
+        }), i = link.end;
+        continue;
+      }
+      if (options.repair && atEnd) {
+        const partial = /^\[([^\]]*)(?:\]\(?[^)\s]*)?$/.exec(rest);
+        if (partial) {
+          buffer += partial[1] ?? "", i = text.length;
+          continue;
+        }
+      }
+    }
+    if (ch === "!" && text[i + 1] === "[") {
+      const link = matchLink(text, i + 1);
+      if (link) {
+        flushText(), out.push({ type: "image", src: link.href, alt: link.label }), i = link.end;
+        continue;
+      }
+    }
+    if (ch === "<") {
+      const auto = AUTOLINK.exec(rest);
+      if (auto) {
+        flushText(), out.push({
+          type: "link",
+          href: auto[1],
+          children: [{ type: "text", text: auto[1] }]
+        }), i += auto[0].length;
+        continue;
+      }
+    }
+    if ((ch === "h" || ch === "H") && /[\s(]$|^$/.test(text.slice(Math.max(0, i - 1), i))) {
+      const url = BARE_URL.exec(rest);
+      if (url) {
+        flushText(), out.push({ type: "link", href: url[0], children: [{ type: "text", text: url[0] }] }), i += url[0].length;
+        continue;
+      }
+    }
+    if (ch === "*" || ch === "_" || ch === "~") {
+      const run = new RegExp(`^\\${ch}+`).exec(rest)?.[0], size = ch === "~" ? run.length >= 2 ? 2 : 0 : Math.min(run.length, 2), before = text[i - 1], after = text[i + run.length];
+      if (size > 0 && after !== void 0 && !/\s/.test(after) && !(ch === "_" && before !== void 0 && /[\p{L}\p{N}]/u.test(before))) {
+        const marker = ch.repeat(size), close = findClose(text, i + size, marker);
+        if (close !== -1) {
+          flushText();
+          const children = inline(text.slice(i + size, close), options, !1);
+          out.push({ type: ch === "~" ? "del" : size === 2 ? "strong" : "em", children }), i = close + size;
+          continue;
+        }
+        if (options.repair && atEnd && /^[*_~]+$/.test(run) && !text.slice(i + run.length).includes(ch)) {
+          i += run.length;
+          continue;
+        }
+      }
+      if (options.repair && atEnd && i + run.length === text.length) {
+        i += run.length;
+        continue;
+      }
+      buffer += run, i += run.length;
+      continue;
+    }
+    buffer += ch, i++;
+  }
+  return flushText(), out;
+}
+function findClose(text, from, marker) {
+  let k = from;
+  for (; k < text.length; ) {
+    const ch = text[k];
+    if (ch === "\\") {
+      k += 2;
+      continue;
+    }
+    if (ch === "`") {
+      const run = /^`+/.exec(text.slice(k))?.[0], end = text.indexOf(run, k + run.length);
+      if (end !== -1) {
+        k = end + run.length;
+        continue;
+      }
+    }
+    if (text.startsWith(marker, k)) {
+      const before = text[k - 1], after = text[k + marker.length], runLength = (/^[*_~]+/.exec(text.slice(k))?.[0] ?? "").length;
+      if (before !== void 0 && !/\s/.test(before) && k > from && !(marker[0] === "_" && after !== void 0 && /[\p{L}\p{N}]/u.test(after)) && !(marker.length === 1 && runLength === 2))
+        return k;
+      k += Math.max(runLength, 1);
+      continue;
+    }
+    k++;
+  }
+  return -1;
+}
+function matchLink(text, start) {
+  let depth = 0, k = start;
+  for (; k < text.length; k++) {
+    const ch = text[k];
+    if (ch === "\\") {
+      k++;
+      continue;
+    }
+    if (ch === "[")
+      depth++;
+    else if (ch === "]" && (depth--, depth === 0))
+      break;
+  }
+  if (depth !== 0 || text[k + 1] !== "(")
+    return;
+  const target = /^\(\s*(<[^>\n]*>|[^\s()]*(?:\([^\s()]*\)[^\s()]*)*)(?:\s+("[^"]*"|'[^']*'))?\s*\)/.exec(text.slice(k + 1));
+  if (!target)
+    return;
+  let href = target[1] ?? "";
+  href.startsWith("<") && (href = href.slice(1, -1));
+  const title = target[2]?.slice(1, -1);
+  return {
+    label: text.slice(start + 1, k),
+    href,
+    ...title !== void 0 ? { title } : {},
+    end: k + 1 + target[0].length
+  };
+}
+export {
+  parseBlocks,
+  parseInline,
+  splitBlocks
+};

package/dist/prod/markdown/render.js

@@ -0,0 +1,273 @@
+import { parseBlocks, splitBlocks } from "./parse.js";
+import { DEFAULT_URL_POLICY, safeUrl } from "./url.js";
+const KIND = /^[a-z][a-z-]{0,23}$/, REMOVE = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "iframe",
+  "object",
+  "embed",
+  "link",
+  "meta",
+  "base",
+  "form",
+  "input",
+  "button",
+  "textarea",
+  "select",
+  "frame",
+  "frameset",
+  "template",
+  "svg",
+  "math",
+  "noscript"
+]), URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "xlink:href", "action", "poster", "cite", "srcset"]);
+class MarkdownView {
+  #container;
+  #doc;
+  #options;
+  #rendered = [];
+  #source = "";
+  constructor(container, options = {}) {
+    this.#container = container, this.#doc = container.ownerDocument ?? document, this.#options = options;
+  }
+  /** Canonical source last rendered (copy/export use this, never the DOM). */
+  get source() {
+    return this.#source;
+  }
+  /** Change options; the next update rebuilds every block. */
+  configure(options) {
+    this.#options = options;
+    for (const block of this.#rendered)
+      block.nodes.forEach((n) => n.parentNode?.removeChild(n));
+    this.#rendered = [], this.update(this.#source, !1, !0);
+  }
+  /** Render `source`. While `streaming`, the last block shows presentation repairs. */
+  update(source, streaming, force = !1) {
+    if (!force && source === this.#source && !streaming && this.#rendered.every((r) => !r.repaired))
+      return;
+    this.#source = source;
+    const slices = splitBlocks(source), next = [];
+    for (let k = 0; k < slices.length; k++) {
+      const slice = slices[k], repaired = streaming && k === slices.length - 1, previous = this.#rendered[k];
+      if (previous && previous.source === slice && previous.repaired === repaired) {
+        next.push(previous);
+        continue;
+      }
+      const blocks = parseBlocks(slice, { repair: repaired });
+      if (previous && previous.source === slice && JSON.stringify(previous.blocks) === JSON.stringify(blocks)) {
+        previous.repaired = repaired, next.push(previous);
+        continue;
+      }
+      if (previous && this.#grow(previous, slice, blocks, repaired)) {
+        next.push(previous);
+        continue;
+      }
+      const nodes = blocks.map((b) => this.#block(b)), rendered = { source: slice, repaired, blocks, nodes }, last = blocks[blocks.length - 1];
+      if (last?.type === "code" && last.open && (rendered.codeText = this.#lastCodeText(nodes[nodes.length - 1])), previous) {
+        const anchor = previous.nodes[0] ?? null;
+        for (const node of nodes)
+          this.#container.insertBefore(node, anchor);
+        for (const node of previous.nodes)
+          node.parentNode?.removeChild(node);
+      } else {
+        const anchor = this.#rendered[k + 1]?.nodes[0] ?? null;
+        for (const node of nodes)
+          this.#container.insertBefore(node, anchor);
+      }
+      next.push(rendered);
+    }
+    for (const stale of this.#rendered.slice(slices.length))
+      for (const node of stale.nodes)
+        node.parentNode?.removeChild(node);
+    this.#rendered = next;
+  }
+  dispose() {
+    for (const block of this.#rendered)
+      for (const node of block.nodes)
+        node.parentNode?.removeChild(node);
+    this.#rendered = [];
+  }
+  /** Append-only growth of a streaming code block keeps its text node (and any selection). */
+  #grow(previous, slice, blocks, repaired) {
+    const before = previous.blocks[previous.blocks.length - 1], after = blocks[blocks.length - 1];
+    return !previous.codeText || before?.type !== "code" || after?.type !== "code" || !after.open || blocks.length !== previous.blocks.length || before.lang !== after.lang || !after.text.startsWith(before.text) || !slice.startsWith(previous.source) ? !1 : (previous.codeText.appendData(after.text.slice(before.text.length)), previous.source = slice, previous.repaired = repaired, previous.blocks = blocks, !0);
+  }
+  #lastCodeText(node) {
+    const text = (node instanceof Element ? node.querySelector("code") : void 0)?.firstChild;
+    return text && text.nodeType === 3 && !text.nextSibling ? text : void 0;
+  }
+  #el(tag, className) {
+    const el = this.#doc.createElement(tag);
+    return className && (el.className = className), el;
+  }
+  #block(block) {
+    switch (block.type) {
+      case "heading": {
+        const level = Math.min(6, block.level + (this.#options.headingOffset ?? 2)), el = this.#el(`h${level}`);
+        return this.#inlines(el, block.children), el;
+      }
+      case "paragraph": {
+        const el = this.#el("p");
+        return this.#inlines(el, block.children), el;
+      }
+      case "code": {
+        const wrapper = this.#el("div", "code-block"), pre = this.#el("pre"), code = this.#el("code");
+        block.lang && (code.dataset.language = block.lang.slice(0, 32));
+        const tokens = !block.open && this.#options.highlight ? this.#options.highlight(block.text, block.lang) : void 0;
+        if (tokens && tokens.map((t) => t.text).join("") === block.text)
+          for (const token of tokens)
+            if (token.kind && KIND.test(token.kind)) {
+              const span = this.#el("span", `tok-${token.kind}`);
+              span.textContent = token.text, code.append(span);
+            } else
+              code.append(this.#doc.createTextNode(token.text));
+        else
+          code.append(this.#doc.createTextNode(block.text));
+        if (pre.append(code), wrapper.append(pre), !block.open) {
+          const actions = this.#options.codeActions?.(block.text, block.lang);
+          actions && wrapper.append(actions);
+        }
+        return wrapper;
+      }
+      case "quote": {
+        const el = this.#el("blockquote");
+        for (const child of block.children)
+          el.append(this.#block(child));
+        return el;
+      }
+      case "list": {
+        const el = this.#el(block.ordered ? "ol" : "ul");
+        block.ordered && block.start !== 1 && el.setAttribute("start", String(block.start));
+        for (const item of block.items) {
+          const li = this.#el("li");
+          if (item.length === 1 && item[0]?.type === "paragraph")
+            this.#inlines(li, item[0].children);
+          else
+            for (const child of item)
+              li.append(this.#block(child));
+          el.append(li);
+        }
+        return el;
+      }
+      case "table": {
+        const scroll = this.#el("div", "table-scroll"), table = this.#el("table"), head = this.#el("thead"), headRow = this.#el("tr");
+        block.head.forEach((cell, c) => {
+          const th = this.#el("th");
+          th.scope = "col";
+          const align = block.align[c];
+          align && (th.dataset.align = align), this.#inlines(th, cell), headRow.append(th);
+        }), head.append(headRow);
+        const body = this.#el("tbody");
+        for (const row of block.rows) {
+          const tr = this.#el("tr");
+          for (let c = 0; c < block.head.length; c++) {
+            const td = this.#el("td"), align = block.align[c];
+            align && (td.dataset.align = align), this.#inlines(td, row[c] ?? []), tr.append(td);
+          }
+          body.append(tr);
+        }
+        return table.append(head, body), scroll.append(table), scroll.tabIndex = 0, scroll;
+      }
+      case "rule":
+        return this.#el("hr");
+      case "html": {
+        if (this.#options.html === "sanitize" && this.#options.sanitize) {
+          const clean = this.#options.sanitize(block.raw);
+          if (clean) {
+            const wrapper = this.#el("div", "html-block");
+            return wrapper.append(this.#doc.importNode(clean, !0)), this.#clean(wrapper), wrapper;
+          }
+        }
+        const el = this.#el("p", "raw-html");
+        return el.textContent = block.raw, el;
+      }
+    }
+  }
+  #inlines(parent, nodes) {
+    for (const node of nodes)
+      parent.append(this.#inline(node));
+  }
+  #inline(node) {
+    switch (node.type) {
+      case "text":
+        return this.#doc.createTextNode(node.text);
+      case "code": {
+        const el = this.#el("code");
+        return el.textContent = node.text, el;
+      }
+      case "em":
+      case "strong":
+      case "del": {
+        const el = this.#el(node.type);
+        return this.#inlines(el, node.children), el;
+      }
+      case "break":
+        return this.#el("br");
+      case "citation":
+        return this.#options.citation?.(node.id) ?? this.#doc.createTextNode(`[${node.id}]`);
+      case "link": {
+        const href = safeUrl(node.href, this.#options.url ?? DEFAULT_URL_POLICY);
+        if (!href) {
+          const span = this.#el("span", "unsafe-link");
+          return this.#inlines(span, node.children), span;
+        }
+        const a = this.#el("a");
+        return a.href = href, a.rel = "noopener noreferrer nofollow", this.#options.linkTarget === "_blank" && (a.target = "_blank"), node.title && (a.title = node.title), this.#inlines(a, node.children), a;
+      }
+      case "image": {
+        const src = safeUrl(node.src, this.#options.url ?? DEFAULT_URL_POLICY);
+        if (src && this.#options.images === "load" && src.startsWith("https:")) {
+          const img = this.#el("img");
+          return img.alt = node.alt, img.loading = "lazy", img.referrerPolicy = "no-referrer", img.src = src, img;
+        }
+        const label = `${this.#options.imageLabel ?? "Image"}: ${node.alt || src || ""}`.trim();
+        if (!src)
+          return this.#doc.createTextNode(label);
+        const a = this.#el("a", "image-link");
+        return a.href = src, a.rel = "noopener noreferrer nofollow", a.textContent = label, a;
+      }
+    }
+  }
+  /** Defense in depth over sanitizer output: no active content, handlers, styles, or unsafe URLs. */
+  #clean(root) {
+    const policy = this.#options.url ?? DEFAULT_URL_POLICY;
+    for (const el of [...root.querySelectorAll("*")]) {
+      if (REMOVE.has(el.localName)) {
+        el.remove();
+        continue;
+      }
+      for (const attr of [...el.attributes]) {
+        const name = attr.name.toLowerCase();
+        if (name.startsWith("on") || name === "style" || name === "srcdoc" || name === "formaction")
+          el.removeAttribute(attr.name);
+        else if (URL_ATTRS.has(name)) {
+          const url = name === "srcset" ? void 0 : safeUrl(attr.value, policy);
+          url ? el.setAttribute(attr.name, url) : el.removeAttribute(attr.name);
+        }
+      }
+      el.localName === "a" && el.setAttribute("rel", "noopener noreferrer nofollow");
+    }
+  }
+}
+function toPlainText(source) {
+  const out = [], inline = (nodes) => nodes.map((n) => n.type === "text" || n.type === "code" ? n.text : n.type === "break" ? `
+` : n.type === "citation" ? `[${n.id}]` : n.type === "image" ? n.alt : inline(n.children)).join(""), walk = (blocks) => {
+    for (const b of blocks)
+      if (b.type === "heading" || b.type === "paragraph")
+        out.push(inline(b.children));
+      else if (b.type === "code")
+        out.push(b.text);
+      else if (b.type === "quote")
+        walk(b.children);
+      else if (b.type === "list")
+        for (const item of b.items)
+          walk(item);
+      else b.type === "table" ? out.push(...[b.head, ...b.rows].map((r) => r.map(inline).join(" | "))) : b.type === "html" && out.push(b.raw);
+  };
+  return walk(parseBlocks(source)), out.join(`
+`);
+}
+export {
+  MarkdownView,
+  toPlainText
+};

package/dist/prod/markdown/url.js

@@ -0,0 +1,42 @@
+const DEFAULT_URL_POLICY = {
+  protocols: ["https:", "http:", "mailto:"],
+  allowRelative: !1
+}, SCHEME = /^([a-zA-Z][a-zA-Z0-9+.-]*):/, CONTROL = /[\u0000-\u001f\u007f]/;
+function safeUrl(raw, policy = DEFAULT_URL_POLICY) {
+  const value = raw.trim();
+  if (!value || CONTROL.test(value))
+    return;
+  const scheme = SCHEME.exec(value);
+  if (!scheme) {
+    if (!policy.allowRelative || value.startsWith("//"))
+      return;
+    if (!policy.base)
+      return value;
+    try {
+      return new URL(value, policy.base).href;
+    } catch {
+      return;
+    }
+  }
+  const protocol = `${scheme[1].toLowerCase()}:`;
+  if (policy.protocols.includes(protocol))
+    try {
+      return new URL(value).href;
+    } catch {
+      return;
+    }
+}
+function displayHost(url) {
+  if (url)
+    try {
+      const host = new URL(url).hostname;
+      return host ? host.replace(/^www\./, "") : void 0;
+    } catch {
+      return;
+    }
+}
+export {
+  DEFAULT_URL_POLICY,
+  displayHost,
+  safeUrl
+};

package/dist/prod/message/index.js

@@ -0,0 +1,11 @@
+import { OddkinMessage, MESSAGE_STRINGS } from "./message.js";
+import { messageTemplate } from "./message.template.js";
+import { messageStyles } from "./message.styles.js";
+import { messageDefinition } from "./message.definition.js";
+export {
+  MESSAGE_STRINGS,
+  OddkinMessage,
+  messageDefinition,
+  messageStyles,
+  messageTemplate
+};

package/dist/prod/message/message.define.js

@@ -0,0 +1,3 @@
+import { define } from "@oddkin/core/element";
+import { messageDefinition } from "./message.definition.js";
+define(messageDefinition);