brookmd 0.22.0

package/dist/dom.js

@@ -0,0 +1,627 @@
+import { highlight } from "./hi.js";
+import { morph } from "./morph.js";
+import { blockProps, extractLang } from "./block-props.js";
+import { decorateSegments } from "./decorate.js";
+import { safeUrl } from "./url-safety.js";
+const INTRINSIC_PX = {
+  Paragraph: 80,
+  Heading: 44,
+  CodeBlock: 300,
+  MathBlock: 140,
+  Mermaid: 220,
+  List: 120,
+  Blockquote: 100,
+  Alert: 120,
+  Table: 200,
+  Rule: 24,
+  Html: 80,
+  Component: 120
+};
+function mountBrookMarkdown(client, container, options = {}) {
+  if (typeof document === "undefined") {
+    throw new Error("mountBrookMarkdown is browser-only; call it after the DOM exists.");
+  }
+  const components = options.components && Object.keys(options.components).length > 0 ? options.components : void 0;
+  const { sanitize, virtualize, stickToBottom, onRenderMetrics } = options;
+  const decorators = options.decorators && options.decorators.length > 0 ? options.decorators : void 0;
+  const urlTransform = options.urlTransform;
+  const hasInlineTransforms = !!decorators || !!urlTransform;
+  const hasPerf = typeof performance !== "undefined";
+  const highlightCode = options.highlightCode !== false && !components?.CodeBlock;
+  const batch = options.batch !== false && typeof requestAnimationFrame === "function";
+  const morphOpenBlocks = options.morphOpenBlocks === true;
+  const root = document.createElement("div");
+  root.className = options.className ? `brook-md ${options.className}` : "brook-md";
+  if (options.id) root.id = options.id;
+  if (options.role) root.setAttribute("role", options.role);
+  if (options.ariaLive) root.setAttribute("aria-live", options.ariaLive);
+  if (options.ariaAtomic !== void 0) root.setAttribute("aria-atomic", String(options.ariaAtomic));
+  container.appendChild(root);
+  let anchor = null;
+  if (stickToBottom) {
+    anchor = document.createElement("div");
+    anchor.className = "brook-bottom-anchor";
+    anchor.setAttribute("aria-hidden", "true");
+    anchor.style.scrollSnapAlign = "end";
+    root.appendChild(anchor);
+  }
+  const mounted = /* @__PURE__ */ new Map();
+  let order = [];
+  let dead = false;
+  let frame = 0;
+  let lastRenderGeneric = false;
+  function sync() {
+    if (dead) return;
+    const snapshot = client.getSnapshot();
+    const nextOrder = new Array(snapshot.length);
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < snapshot.length; i++) {
+      const b = snapshot[i];
+      nextOrder[i] = b.id;
+      seen.add(b.id);
+      const existing = mounted.get(b.id);
+      if (!existing) {
+        const t02 = onRenderMetrics && hasPerf ? performance.now() : 0;
+        const mb = {
+          id: b.id,
+          node: void 0,
+          html: b.html,
+          open: b.open,
+          speculative: b.speculative,
+          kind: b.kind.type,
+          renderCount: 0,
+          toggleCount: 0,
+          generic: false
+        };
+        mb.node = renderBlock(b, mb);
+        mb.generic = lastRenderGeneric;
+        mounted.set(b.id, mb);
+        if (onRenderMetrics) noteRender(mb, b, t02);
+        continue;
+      }
+      if (existing.html === b.html && existing.open === b.open && existing.speculative === b.speculative) {
+        continue;
+      }
+      const t0 = onRenderMetrics && hasPerf ? performance.now() : 0;
+      if (existing.table && b.open && b.kind.type === "Table") {
+        const data = tableData(b);
+        if (data) {
+          syncTbody(existing.table, data);
+          if (onRenderMetrics) noteRender(existing, b, t0);
+          if (existing.speculative !== b.speculative) {
+            existing.node.classList.toggle("brook-speculative", b.speculative);
+          }
+          existing.html = b.html;
+          existing.open = b.open;
+          existing.speculative = b.speculative;
+          continue;
+        }
+      }
+      if (morphOpenBlocks && b.open && existing.open && existing.generic && existing.kind === b.kind.type && usesGenericPath(b)) {
+        morph(existing.node, sanitize ? sanitize(b.html) : b.html);
+        if (onRenderMetrics) noteRender(existing, b, t0);
+        existing.html = b.html;
+        existing.speculative = b.speculative;
+        existing.node.className = genericClassName(b);
+        existing.generic = !sanitize;
+        continue;
+      }
+      if (!sanitize && existing.generic && existing.kind === b.kind.type && existing.open === b.open && existing.speculative === b.speculative && b.html.length > existing.html.length && b.html.startsWith(existing.html) && isDepth0Boundary(existing.html, b.html)) {
+        existing.node.insertAdjacentHTML("beforeend", b.html.slice(existing.html.length));
+        if (onRenderMetrics) noteRender(existing, b, t0);
+        existing.html = b.html;
+        continue;
+      }
+      existing.table = void 0;
+      const node = renderBlock(b, existing);
+      existing.node.replaceWith(node);
+      existing.node = node;
+      if (onRenderMetrics) noteRender(existing, b, t0);
+      existing.html = b.html;
+      existing.open = b.open;
+      existing.speculative = b.speculative;
+      existing.kind = b.kind.type;
+      existing.generic = lastRenderGeneric;
+    }
+    if (mounted.size > seen.size) {
+      for (const [id, mb] of mounted) {
+        if (!seen.has(id)) {
+          mb.node.remove();
+          mounted.delete(id);
+        }
+      }
+    }
+    order = nextOrder;
+    reconcileChildren();
+  }
+  function noteRender(mb, b, t0) {
+    mb.renderCount++;
+    if (mb.speculative !== b.speculative) mb.toggleCount++;
+    client.__noteRebuild();
+    onRenderMetrics(b.id, {
+      renderCount: mb.renderCount,
+      speculativeToggleCount: mb.toggleCount,
+      lastRenderMs: hasPerf ? performance.now() - t0 : 0,
+      kind: b.kind.type
+    });
+  }
+  function reconcileChildren() {
+    let cursor = root.firstChild;
+    for (let i = 0; i < order.length; i++) {
+      const mb = mounted.get(order[i]);
+      if (!mb) continue;
+      const want = mb.node;
+      if (cursor === want) {
+        cursor = want.nextSibling;
+        continue;
+      }
+      root.insertBefore(want, cursor);
+    }
+  }
+  function renderBlock(b, mb) {
+    const content = renderBlockContent(b, mb);
+    if (virtualize && !b.open && !b.speculative) {
+      const px = INTRINSIC_PX[b.kind.type] ?? 120;
+      content.style.contentVisibility = "auto";
+      content.style.containIntrinsicSize = `auto ${px}px`;
+    }
+    return content;
+  }
+  function renderBlockContent(b, mb) {
+    const kind = b.kind.type;
+    lastRenderGeneric = false;
+    if (components) {
+      if (kind === "Component") {
+        const tag = b.kind.data?.tag;
+        const override = tag && components[tag] || components.Component;
+        if (override) return wrapOverrideResult(override(blockProps(b)));
+      }
+      const blockOverride = components[kind];
+      if (blockOverride) return wrapOverrideResult(blockOverride(blockProps(b)));
+    }
+    switch (kind) {
+      case "CodeBlock":
+        if (highlightCode) return renderCodeBlock(b);
+        break;
+      // fall through to the generic path
+      case "MathBlock":
+        return renderMathBlock(b);
+      case "Mermaid":
+        return renderMermaid(b);
+    }
+    if (kind === "Table" && b.open && !hasInlineTransforms) {
+      const data = tableData(b);
+      if (data) return buildKeyedTable(b, data, mb);
+    }
+    if (b.open && kind === "List" && !hasInlineTransforms) {
+      const keyed = renderKeyedList(b);
+      if (keyed) return keyed;
+    }
+    const node = document.createElement("div");
+    node.className = genericClassName(b);
+    if (b.open && !sanitize && !hasInlineTransforms && (kind === "Blockquote" || kind === "Alert")) {
+      const wrapper = renderKeyedContainer(b);
+      if (wrapper) {
+        node.appendChild(wrapper);
+        return node;
+      }
+    }
+    node.innerHTML = sanitize ? sanitize(b.html) : b.html;
+    if (decorators) decorateDomSubtree(node, decorators);
+    if (urlTransform) applyUrlTransformDom(node, urlTransform);
+    lastRenderGeneric = !sanitize && !hasInlineTransforms;
+    return node;
+  }
+  function renderKeyedList(b) {
+    const ld = b.kind.data;
+    const items = ld?.items;
+    if (!Array.isArray(items) || items.length === 0) return null;
+    const node = document.createElement("div");
+    node.className = "brook-block brook-block-list" + (b.open ? " brook-open" : "") + (b.speculative ? " brook-speculative" : "");
+    const list = document.createElement(ld?.ordered ? "ol" : "ul");
+    if (ld?.ordered && ld.start !== void 0 && ld.start !== 1) {
+      list.setAttribute("start", String(ld.start));
+    }
+    for (const it of items) {
+      const li = document.createElement("li");
+      li.innerHTML = sanitize ? sanitize(it.html) : it.html;
+      list.appendChild(li);
+    }
+    node.appendChild(list);
+    return node;
+  }
+  function renderKeyedContainer(b) {
+    const nested = b.kind.data?.nested;
+    if (!Array.isArray(nested)) return null;
+    const tagName = b.kind.type === "Alert" ? "div" : "blockquote";
+    const wrapper = document.createElement(tagName);
+    applyOpenTagAttrs(wrapper, b.html);
+    if (b.kind.type === "Alert") {
+      const title = alertTitleHtml(b.html);
+      if (title) {
+        const t = document.createElement("div");
+        t.innerHTML = title;
+        const titleNode = t.firstElementChild;
+        if (titleNode) wrapper.appendChild(titleNode);
+      }
+    }
+    for (let i = 0; i < nested.length; i++) {
+      const child = document.createElement("div");
+      child.innerHTML = nested[i].html;
+      const inner = child.firstElementChild;
+      wrapper.appendChild(inner ?? child);
+    }
+    return wrapper;
+  }
+  function buildKeyedTable(b, data, mb) {
+    const node = document.createElement("div");
+    node.className = "brook-block brook-block-table brook-open" + (b.speculative ? " brook-speculative" : "");
+    const table = document.createElement("table");
+    if (b.html.startsWith('<table dir="auto"')) table.setAttribute("dir", "auto");
+    const scope = b.html.includes('<th scope="col"');
+    const thead = document.createElement("thead");
+    const htr = document.createElement("tr");
+    for (let j = 0; j < data.headers.length; j++) {
+      htr.appendChild(makeCell("th", data.headers[j].html, data.aligns[j] ?? null, scope));
+    }
+    thead.appendChild(htr);
+    table.appendChild(thead);
+    const km = { table, tbody: null, scope, committed: 0, lastRow: null };
+    mb.table = km;
+    node.appendChild(table);
+    syncTbody(km, data);
+    return node;
+  }
+  function syncTbody(km, data) {
+    const n = data.rows.length;
+    if (n === 0) {
+      if (km.tbody) {
+        km.tbody.remove();
+        km.tbody = null;
+      }
+      km.committed = 0;
+      km.lastRow = null;
+      return;
+    }
+    if (!km.tbody) {
+      km.tbody = document.createElement("tbody");
+      km.table.appendChild(km.tbody);
+    }
+    const tbody = km.tbody;
+    if (km.lastRow) {
+      km.lastRow.remove();
+      km.lastRow = null;
+    }
+    for (let i = km.committed; i < n - 1; i++) {
+      tbody.appendChild(makeRow(data.rows[i], data.aligns));
+    }
+    km.committed = n - 1;
+    const last = makeRow(data.rows[n - 1], data.aligns);
+    tbody.appendChild(last);
+    km.lastRow = last;
+  }
+  function makeRow(cells, aligns) {
+    const tr = document.createElement("tr");
+    for (let j = 0; j < cells.length; j++) {
+      tr.appendChild(makeCell("td", cells[j].html, aligns[j] ?? null, false));
+    }
+    return tr;
+  }
+  function makeCell(tag, html, align, scope) {
+    const cell = document.createElement(tag);
+    if (tag === "th" && scope) cell.setAttribute("scope", "col");
+    if (align) cell.style.textAlign = align;
+    cell.innerHTML = sanitize ? sanitize(html) : html;
+    return cell;
+  }
+  function genericClassName(b) {
+    return "brook-block brook-block-" + b.kind.type.toLowerCase() + (b.open ? " brook-open" : "") + (b.speculative ? " brook-speculative" : "");
+  }
+  function usesGenericPath(b) {
+    const kind = b.kind.type;
+    if (components) {
+      if (kind === "Component") {
+        const tag = b.kind.data?.tag;
+        if (tag && components[tag] || components.Component) return false;
+      }
+      if (components[kind]) return false;
+    }
+    if (kind === "CodeBlock") return !highlightCode;
+    if (kind === "MathBlock" || kind === "Mermaid") return false;
+    return true;
+  }
+  function wrapOverrideResult(result) {
+    if (typeof result === "string") {
+      const node = document.createElement("div");
+      node.innerHTML = result;
+      return node;
+    }
+    return result;
+  }
+  function renderCodeBlock(b) {
+    const lang = extractLang(b.html) || "text";
+    const text = b.open ? "" : decodeCodeText(b.html);
+    const highlighted = text ? highlight(text, lang) : null;
+    const block = document.createElement("div");
+    block.className = "brook-code-block" + (b.open ? " brook-streaming" : "");
+    const header = document.createElement("div");
+    header.className = "brook-code-header";
+    const langSpan = document.createElement("span");
+    langSpan.className = "brook-code-lang";
+    langSpan.textContent = lang;
+    header.appendChild(langSpan);
+    if (b.open) {
+      const pill = document.createElement("span");
+      pill.className = "brook-code-streaming-pill";
+      pill.textContent = "streaming";
+      header.appendChild(pill);
+    } else {
+      header.appendChild(makeCopyButton(text));
+    }
+    block.appendChild(header);
+    const body = document.createElement("div");
+    body.className = "brook-code-body";
+    if (highlighted) {
+      const pre = document.createElement("pre");
+      pre.tabIndex = 0;
+      pre.setAttribute("role", "region");
+      pre.setAttribute("aria-label", `${lang} code`);
+      const code = document.createElement("code");
+      code.innerHTML = highlighted;
+      pre.appendChild(code);
+      body.appendChild(pre);
+    } else {
+      const div = document.createElement("div");
+      div.tabIndex = 0;
+      div.setAttribute("role", "region");
+      div.setAttribute("aria-label", `${lang} code`);
+      div.innerHTML = b.html;
+      body.appendChild(div);
+    }
+    block.appendChild(body);
+    return block;
+  }
+  function renderMathBlock(b) {
+    const block = document.createElement("div");
+    block.className = "brook-math-block" + (b.open ? " brook-streaming" : "");
+    const header = document.createElement("div");
+    header.className = "brook-math-header";
+    const lang = document.createElement("span");
+    lang.className = "brook-math-lang";
+    lang.textContent = "math";
+    header.appendChild(lang);
+    if (b.open) header.appendChild(streamingPill());
+    block.appendChild(header);
+    const body = document.createElement("div");
+    body.className = "brook-math-body";
+    body.innerHTML = b.html;
+    block.appendChild(body);
+    return block;
+  }
+  function renderMermaid(b) {
+    const block = document.createElement("div");
+    block.className = "brook-mermaid-block" + (b.open ? " brook-streaming" : "");
+    const header = document.createElement("div");
+    header.className = "brook-mermaid-header";
+    const lang = document.createElement("span");
+    lang.className = "brook-mermaid-lang";
+    lang.textContent = "mermaid";
+    header.appendChild(lang);
+    if (b.open) header.appendChild(streamingPill());
+    block.appendChild(header);
+    const body = document.createElement("div");
+    body.className = "brook-mermaid-body";
+    body.innerHTML = b.html;
+    block.appendChild(body);
+    return block;
+  }
+  function streamingPill() {
+    const pill = document.createElement("span");
+    pill.className = "brook-code-streaming-pill";
+    pill.textContent = "streaming";
+    return pill;
+  }
+  const COPY_ICON = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="9" y="9" width="11" height="11" rx="2"></rect><path d="M5 15V5a2 2 0 0 1 2-2h10"></path></svg><span>Copy</span>';
+  const COPIED_ICON = '<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 6 9 17l-5-5"></path></svg><span>Copied</span>';
+  function makeCopyButton(text) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "brook-code-copy";
+    btn.setAttribute("aria-label", "Copy code");
+    btn.setAttribute("aria-live", "polite");
+    btn.innerHTML = COPY_ICON;
+    let timer = null;
+    btn.addEventListener("click", () => {
+      const clip = typeof navigator !== "undefined" ? navigator.clipboard : void 0;
+      if (!clip || !clip.writeText || !text) return;
+      clip.writeText(text).then(
+        () => {
+          btn.setAttribute("aria-label", "Copied");
+          btn.innerHTML = COPIED_ICON;
+          if (timer !== null) clearTimeout(timer);
+          timer = setTimeout(() => {
+            btn.setAttribute("aria-label", "Copy code");
+            btn.innerHTML = COPY_ICON;
+          }, 1500);
+        },
+        // Permission denied / blocked: stay silent, leave button usable.
+        () => {
+        }
+      );
+    });
+    return btn;
+  }
+  const unsubscribe = client.subscribe(() => {
+    if (dead) return;
+    if (batch) {
+      if (frame === 0) frame = requestAnimationFrame(flush);
+    } else {
+      sync();
+    }
+  });
+  function flush() {
+    frame = 0;
+    sync();
+  }
+  sync();
+  return {
+    destroy() {
+      if (dead) return;
+      dead = true;
+      if (frame !== 0) {
+        cancelAnimationFrame(frame);
+        frame = 0;
+      }
+      unsubscribe();
+      root.remove();
+    },
+    refresh() {
+      if (dead) return;
+      sync();
+    },
+    openBlockId() {
+      return tailOpenBlockId(client.getSnapshot());
+    }
+  };
+}
+function tableData(b) {
+  if (b.kind.type !== "Table") return void 0;
+  const data = b.kind.data;
+  if (!data || !Array.isArray(data.rows) || !Array.isArray(data.aligns) || !Array.isArray(data.headers)) {
+    return void 0;
+  }
+  return data;
+}
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function isDepth0Boundary(prefix, full) {
+  const c0 = full.charCodeAt(prefix.length);
+  if (c0 !== 60) return false;
+  const c1 = full.charCodeAt(prefix.length + 1);
+  const isLetter = c1 >= 65 && c1 <= 90 || c1 >= 97 && c1 <= 122;
+  if (!isLetter) return false;
+  let depth = 0;
+  let i = 0;
+  const n = prefix.length;
+  while (i < n) {
+    const lt = prefix.indexOf("<", i);
+    if (lt === -1) break;
+    i = lt + 1;
+    if (i >= n) return false;
+    const ch = prefix.charCodeAt(i);
+    if (ch === 33 || ch === 63) return false;
+    let closing = false;
+    if (ch === 47) {
+      closing = true;
+      i++;
+    }
+    const nameStart = i;
+    while (i < n) {
+      const t = prefix.charCodeAt(i);
+      const nameChar = t >= 65 && t <= 90 || t >= 97 && t <= 122 || t >= 48 && t <= 57 || t === 45;
+      if (!nameChar) break;
+      i++;
+    }
+    if (i === nameStart) return false;
+    const name = prefix.slice(nameStart, i).toLowerCase();
+    const gt = prefix.indexOf(">", i);
+    if (gt === -1) return false;
+    const selfClosing = prefix.charCodeAt(gt - 1) === 47;
+    i = gt + 1;
+    if (closing) {
+      depth--;
+      if (depth < 0) return false;
+    } else if (!selfClosing && !VOID_ELEMENTS.has(name)) {
+      depth++;
+    }
+  }
+  return depth === 0;
+}
+function tailOpenBlockId(snapshot) {
+  const tail = snapshot.length > 0 ? snapshot[snapshot.length - 1] : void 0;
+  return tail && tail.open ? tail.id : null;
+}
+function decodeCodeText(html) {
+  const m = html.match(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/);
+  if (!m) return "";
+  return m[1].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+const CONTAINER_ATTR_RE = /([a-zA-Z][a-zA-Z0-9-]*)="([^"]*)"/g;
+function applyOpenTagAttrs(el, html) {
+  const gt = html.indexOf(">");
+  const open = gt < 0 ? html : html.slice(0, gt);
+  let m;
+  CONTAINER_ATTR_RE.lastIndex = 0;
+  while (m = CONTAINER_ATTR_RE.exec(open)) {
+    const name = m[1].toLowerCase();
+    if (name === "class" || name === "dir" || name === "role" || name.startsWith("data-")) {
+      el.setAttribute(name, m[2]);
+    }
+  }
+}
+function alertTitleHtml(html) {
+  const m = html.match(/<p class="markdown-alert-title"[^>]*>[\s\S]*?<\/p>/);
+  return m ? m[0] : "";
+}
+function ancestorTags(node, root) {
+  const out = [];
+  let p = node.parentNode;
+  while (p && p !== root) {
+    if (p.tagName) out.push(p.tagName.toLowerCase());
+    p = p.parentNode;
+  }
+  return out;
+}
+const SHOW_ALL = 4294967295;
+function decorateDomSubtree(root, decorators) {
+  const walker = document.createTreeWalker(root, SHOW_ALL);
+  const texts = [];
+  for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+    if (n.nodeType === 3) texts.push(n);
+  }
+  for (const t of texts) {
+    const segs = decorateSegments(t.data, decorators, ancestorTags(t, root));
+    if (segs === null) continue;
+    const frag = document.createDocumentFragment();
+    for (const s of segs) {
+      if (s.type === "text") {
+        frag.appendChild(document.createTextNode(s.text));
+        continue;
+      }
+      const replacement = s.decorator.replace(s.matchText, s.groups);
+      if (replacement == null) continue;
+      frag.appendChild(typeof replacement === "string" ? document.createTextNode(replacement) : replacement);
+    }
+    t.parentNode?.replaceChild(frag, t);
+  }
+}
+function applyUrlTransformDom(root, urlTransform) {
+  const els = root.querySelectorAll("[href],[src],[poster]");
+  const attrs = ["href", "src", "poster"];
+  els.forEach((el) => {
+    for (const attr of attrs) {
+      if (!el.hasAttribute(attr)) continue;
+      const cur = el.getAttribute(attr) ?? "";
+      const next = safeUrl(urlTransform(safeUrl(cur), { tag: el.tagName.toLowerCase(), attr }));
+      el.setAttribute(attr, next);
+    }
+  });
+}
+export {
+  mountBrookMarkdown,
+  tailOpenBlockId
+};

package/dist/element.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `<brook-markdown>` custom element — thin lifecycle glue over
+ * {@link mountBrookMarkdown}. It owns no diffing: connect mounts the DOM
+ * renderer into the element itself (LIGHT DOM, so the host app's markdown CSS
+ * reaches the content), disconnect tears the mount down. It never reimplements
+ * subscribe/patch.
+ *
+ * Two usage modes:
+ *   - **Caller-owned client** (`el.client = myClient`): the element subscribes
+ *     and mounts but NEVER destroys the client — the caller owns the
+ *     worker/stream lifecycle.
+ *   - **Self-owned client** (`markdown`/`src`/`textContent` attrs, or
+ *     `el.append()`): the element lazily creates an internal client from its
+ *     config attributes and destroys it on disconnect.
+ *
+ * Not auto-registered (SSR-unsafe): call {@link defineBrookMarkdown} from
+ * browser code.
+ */
+export declare function parseTriBool(value: string | null): boolean | undefined;
+export declare function defineBrookMarkdown(tag?: string): void;