deepresearch-flow 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

deepresearch_flow/paper/snapshot/text.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+from markdown_it import MarkdownIt
+
+
+_HTML_TABLE_RE = re.compile(r"<table\b.*?</table>", re.IGNORECASE | re.DOTALL)
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+
+
+def _is_cjk_char(ch: str) -> bool:
+    code = ord(ch)
+    return (
+        0x3400 <= code <= 0x4DBF  # CJK Unified Ideographs Extension A
+        or 0x4E00 <= code <= 0x9FFF  # CJK Unified Ideographs
+        or 0xF900 <= code <= 0xFAFF  # CJK Compatibility Ideographs
+        or 0x3040 <= code <= 0x309F  # Hiragana
+        or 0x30A0 <= code <= 0x30FF  # Katakana
+        or 0xAC00 <= code <= 0xD7AF  # Hangul syllables
+    )
+
+
+def insert_cjk_spaces(text: str) -> str:
+    out: list[str] = []
+    prev_cjk = False
+    for ch in text:
+        cur_cjk = _is_cjk_char(ch)
+        if prev_cjk and cur_cjk:
+            out.append(" ")
+        out.append(ch)
+        prev_cjk = cur_cjk
+    return "".join(out)
+
+
+def remove_cjk_spaces(text: str) -> str:
+    if " " not in text:
+        return text
+    chars = list(text)
+    out: list[str] = []
+    for idx, ch in enumerate(chars):
+        if ch == " " and 0 < idx < len(chars) - 1:
+            if _is_cjk_char(chars[idx - 1]) and _is_cjk_char(chars[idx + 1]):
+                continue
+        out.append(ch)
+    return "".join(out)
+
+
+def merge_adjacent_markers(text: str, *, start_marker: str = "[[[", end_marker: str = "]]]") -> str:
+    needle = f"{end_marker}{start_marker}"
+    while needle in text:
+        text = text.replace(needle, "")
+    return text
+
+
+def _md_renderer() -> MarkdownIt:
+    md = MarkdownIt("commonmark", {"html": False, "linkify": False})
+    md.enable("table")
+    return md
+
+
+def markdown_to_plain_text(markdown: str) -> str:
+    if not markdown:
+        return ""
+    text = _HTML_TABLE_RE.sub(" ", markdown)
+    md = _md_renderer()
+    tokens = md.parse(text)
+
+    out: list[str] = []
+    in_table = 0
+    for token in tokens:
+        if token.type == "table_open":
+            in_table += 1
+            continue
+        if token.type == "table_close":
+            in_table = max(0, in_table - 1)
+            continue
+        if in_table:
+            continue
+        if token.type != "inline":
+            continue
+        for child in token.children or []:
+            if child.type in {"text", "code_inline"}:
+                out.append(child.content)
+            elif child.type == "softbreak":
+                out.append("\n")
+            elif child.type == "hardbreak":
+                out.append("\n")
+            elif child.type == "image":
+                if child.content:
+                    out.append(child.content)
+
+    collapsed = _WS_RE.sub(" ", " ".join(out)).strip()
+    collapsed = _TAG_RE.sub(" ", collapsed)
+    return _WS_RE.sub(" ", collapsed).strip()
+
+
+def normalize_query_punctuation(text: str) -> str:
+    if not text:
+        return ""
+    return re.sub(r"[，。、《》、；：！？（）【】「」『』·…—]+", " ", text)
+
+
+def split_mixed_cjk_latin(token: str) -> list[str]:
+    if not token:
+        return []
+    parts: list[str] = []
+    buf: list[str] = []
+    buf_is_cjk: bool | None = None
+    for ch in token:
+        cur_is_cjk = _is_cjk_char(ch)
+        if buf_is_cjk is None or cur_is_cjk == buf_is_cjk:
+            buf.append(ch)
+            buf_is_cjk = cur_is_cjk
+            continue
+        parts.append("".join(buf))
+        buf = [ch]
+        buf_is_cjk = cur_is_cjk
+    if buf:
+        parts.append("".join(buf))
+    return parts
+
+
+def rewrite_search_query(user_query: str) -> str:
+    cleaned = normalize_query_punctuation(user_query)
+    cleaned = _WS_RE.sub(" ", cleaned).strip()
+    if not cleaned:
+        return ""
+
+    out: list[str] = []
+    for raw in cleaned.split(" "):
+        if not raw:
+            continue
+        upper = raw.upper()
+        if upper in {"AND", "OR"}:
+            out.append(upper)
+            continue
+
+        segments = split_mixed_cjk_latin(raw)
+        for seg in segments:
+            if not seg:
+                continue
+            if all(_is_cjk_char(ch) for ch in seg):
+                phrase = insert_cjk_spaces(seg)
+                out.append(f"\"{phrase}\"")
+            else:
+                safe = re.sub(r"[^0-9A-Za-z._+-]+", "", seg)
+                if safe:
+                    out.append(safe.lower())
+
+    return " ".join(out)
+

deepresearch_flow/paper/template_registry.py

@@ -24,6 +24,7 @@ class TemplateBundle:
 class StageDefinition:
     name: str
     fields: list[str]
+    depends_on: list[str] | None = None
 
 
 _TEMPLATES: dict[str, TemplateBundle] = {
@@ -34,6 +35,13 @@ _TEMPLATES: dict[str, TemplateBundle] = {
         schema_file="default_paper_schema.json",
         render_template="default_paper.md.j2",
     ),
+    "simple_phi": TemplateBundle(
+        name="simple_phi",
+        prompt_system="simple_phi_system.j2",
+        prompt_user="simple_phi_user.j2",
+        schema_file="default_paper_schema.json",
+        render_template="default_paper.md.j2",
+    ),
     "deep_read": TemplateBundle(
         name="deep_read",
         prompt_system="deep_read_system.j2",
@@ -41,6 +49,13 @@ _TEMPLATES: dict[str, TemplateBundle] = {
         schema_file="deep_read_schema.json",
         render_template="deep_read.md.j2",
     ),
+    "deep_read_phi": TemplateBundle(
+        name="deep_read_phi",
+        prompt_system="deep_read_phi_system.j2",
+        prompt_user="deep_read_phi_user.j2",
+        schema_file="deep_read_phi_schema.json",
+        render_template="deep_read_phi.md.j2",
+    ),
     "eight_questions": TemplateBundle(
         name="eight_questions",
         prompt_system="eight_questions_system.j2",
@@ -48,6 +63,13 @@ _TEMPLATES: dict[str, TemplateBundle] = {
         schema_file="eight_questions_schema.json",
         render_template="eight_questions.md.j2",
     ),
+    "eight_questions_phi": TemplateBundle(
+        name="eight_questions_phi",
+        prompt_system="eight_questions_phi_system.j2",
+        prompt_user="eight_questions_phi_user.j2",
+        schema_file="eight_questions_schema.json",
+        render_template="eight_questions.md.j2",
+    ),
     "three_pass": TemplateBundle(
         name="three_pass",
         prompt_system="three_pass_system.j2",
@@ -75,6 +97,14 @@ _STAGES: dict[str, list[StageDefinition]] = {
         StageDefinition("module_g", ["module_g"]),
         StageDefinition("module_h", ["module_h"]),
     ],
+    "deep_read_phi": [
+        StageDefinition("module_m1", ["module_m1"]),
+        StageDefinition("module_m2", ["module_m2"]),
+        StageDefinition("module_m3", ["module_m3"]),
+        StageDefinition("module_m4", ["module_m4"]),
+        StageDefinition("module_m5", ["module_m5"]),
+        StageDefinition("module_m6", ["module_m6"]),
+    ],
     "eight_questions": [
         StageDefinition(
             "questions_1to4",
@@ -85,6 +115,16 @@ _STAGES: dict[str, list[StageDefinition]] = {
             ["question5", "question6", "question7", "question8"],
         ),
     ],
+    "eight_questions_phi": [
+        StageDefinition(
+            "questions_1to4",
+            ["question1", "question2", "question3", "question4"],
+        ),
+        StageDefinition(
+            "questions_5to8",
+            ["question5", "question6", "question7", "question8"],
+        ),
+    ],
     "three_pass": [
         StageDefinition("step1_summary", ["step1_summary"]),
         StageDefinition("step2_analysis", ["step2_analysis"]),

deepresearch_flow/paper/templates/deep_read.md.j2

@@ -3,6 +3,10 @@
 {% set is_zh = output_language == "zh" %}
 **{{ "作者 / Authors" if is_zh else "Authors" }}:** {{ paper_authors | join(", ") }}
 
+{% if paper_institutions %}
+**{{ "单位 / Institutions" if is_zh else "Institutions" }}:** {{ paper_institutions | join(", ") }}
+{% endif %}
+
 {% if output_language %}
 **{{ "输出语言 / Output Language" if is_zh else "Output Language" }}:** {{ output_language }}
 {% endif %}

deepresearch_flow/paper/templates/deep_read_phi.md.j2

@@ -0,0 +1,44 @@
+# {{ paper_title }}
+
+{% set is_zh = output_language == "zh" %}
+**{{ "作者 / Authors" if is_zh else "Authors" }}:** {{ paper_authors | join(", ") }}
+
+{% if paper_institutions %}
+**{{ "单位 / Institutions" if is_zh else "Institutions" }}:** {{ paper_institutions | join(", ") }}
+{% endif %}
+
+{% if output_language %}
+**{{ "输出语言 / Output Language" if is_zh else "Output Language" }}:** {{ output_language }}
+{% endif %}
+
+{% if publication_date %}
+**{{ "发表日期 / Publication Date" if is_zh else "Publication Date" }}:** {{ publication_date }}
+{% endif %}
+
+{% if publication_venue %}
+**{{ "期刊/会议 / Publication Venue" if is_zh else "Publication Venue" }}:** {{ publication_venue }}
+{% endif %}
+
+## {{ "模块 M1：对齐目标 + 输入校验 + 论文地图 + Exhibit全量索引 + markmap大纲脑图" if is_zh else "Module M1: Alignment + Input Check + Paper Map + Exhibit Index + Markmap" }}
+
+{{ module_m1 }}
+
+## {{ "模块 M2：第一遍鸟瞰 + Exhibit客观打分排序" if is_zh else "Module M2: First Pass Overview + Exhibit Scoring" }}
+
+{{ module_m2 }}
+
+## {{ "模块 M3：概念与术语工程 + 辩论谱系" if is_zh else "Module M3: Concepts + Debate Lineage" }}
+
+{{ module_m3 }}
+
+## {{ "模块 M4：论证重建 + Top Exhibits 深读（上半）" if is_zh else "Module M4: Argument Map + Top Exhibits (Part 1)" }}
+
+{{ module_m4 }}
+
+## {{ "模块 M5：深度审视 + objection mining + Top Exhibits 深读（下半）" if is_zh else "Module M5: Deep Review + Objection Mining + Top Exhibits (Part 2)" }}
+
+{{ module_m5 }}
+
+## {{ "模块 M6：写作级产出包" if is_zh else "Module M6: Writing-Ready Output Pack" }}
+
+{{ module_m6 }}

deepresearch_flow/paper/templates/default_paper.md.j2

@@ -3,6 +3,10 @@
 {% set is_zh = output_language == "zh" %}
 **{{ "作者 / Authors" if is_zh else "Authors" }}:** {{ paper_authors | join(", ") }}
 
+{% if paper_institutions %}
+**{{ "单位 / Institutions" if is_zh else "Institutions" }}:** {{ paper_institutions | join(", ") }}
+{% endif %}
+
 {% if output_language %}
 **{{ "输出语言 / Output Language" if is_zh else "Output Language" }}:** {{ output_language }}
 {% endif %}

deepresearch_flow/paper/templates/eight_questions.md.j2

@@ -4,6 +4,10 @@
 
 **{{ "作者 / Authors" if is_zh else "Authors" }}:** {{ paper_authors | join(", ") }}
 
+{% if paper_institutions %}
+**{{ "单位 / Institutions" if is_zh else "Institutions" }}:** {{ paper_institutions | join(", ") }}
+{% endif %}
+
 {% if output_language %}
 **{{ "输出语言 / Output Language" if is_zh else "Output Language" }}:** {{ output_language }}
 {% endif %}

deepresearch_flow/paper/web/app.py

@@ -91,7 +91,7 @@ def create_app(
         pdf_roots=pdf_roots,
     )
     md = create_md_renderer()
-    static_base_url = static_base_url or os.getenv("PAPER_DB_STATIC_BASE_URL")
+    static_base_url = static_base_url or os.getenv("PAPER_DB_STATIC_BASE") or os.getenv("PAPER_DB_STATIC_BASE_URL")
     static_mode = _normalize_static_mode(static_mode or os.getenv("PAPER_DB_STATIC_MODE"))
     resolved_mode = _resolve_static_mode(static_mode, static_base_url)
     export_dir_value = static_export_dir or os.getenv("PAPER_DB_STATIC_EXPORT_DIR")
@@ -111,7 +111,12 @@ def create_app(
     asset_config = None
     if resolved_mode == "prod":
         if not static_base_url:
-            logger.warning("Static mode set to prod without base URL; falling back to dev asset routes.")
+            logger.warning(
+                "Static mode set to prod without base URL; falling back to dev asset routes "
+                "(static_mode=%s, static_base_url=%s)",
+                static_mode,
+                static_base_url or "<empty>",
+            )
             resolved_mode = "dev"
         else:
             asset_config = build_static_assets(
@@ -149,8 +154,10 @@ def create_app(
         )
     elif pdf_roots:
         logger.warning(
-            "PDF.js viewer assets not found at %s; PDF Viewer mode will be unavailable.",
+            "PDF.js viewer assets not found at %s; PDF Viewer mode will be unavailable "
+            "(pdf_roots=%d).",
             PDFJS_STATIC_DIR,
+            len(pdf_roots),
         )
     if STATIC_DIR.exists():
         routes.append(

deepresearch_flow/paper/web/markdown.py

@@ -41,13 +41,88 @@ def strip_paragraph_wrapped_tables(text: str) -> str:
 
 
 def normalize_footnote_definitions(text: str) -> str:
-    """Normalize footnote definitions to the markdown-it footnote format."""
+    """Normalize footnotes and numbered notes to markdown-it footnote format."""
     lines = text.splitlines()
-    for idx, line in enumerate(lines):
+    out: list[str] = []
+    in_fence = False
+    fence_char = ""
+    fence_len = 0
+    in_notes = False
+    notes_level: int | None = None
+    notes_heading_re = re.compile(
+        r"^#{1,6}\s*(参考文献|参考资料|参考书目|文献|引用|注释|脚注|notes?|references?|bibliography|works\s+cited|citations?)\b",
+        re.IGNORECASE,
+    )
+    notes_heading_plain_re = re.compile(
+        r"^(参考文献|参考资料|参考书目|文献|引用|注释|脚注|notes?|references?|bibliography|works\s+cited|citations?)\s*:?$",
+        re.IGNORECASE,
+    )
+    last_note_index: int | None = None
+
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith(("```", "~~~")):
+            run_len = 0
+            while run_len < len(stripped) and stripped[run_len] == stripped[0]:
+                run_len += 1
+            if not in_fence:
+                in_fence = True
+                fence_char = stripped[0]
+                fence_len = run_len
+            elif stripped[0] == fence_char and run_len >= fence_len:
+                in_fence = False
+                fence_char = ""
+                fence_len = 0
+            out.append(line)
+            continue
+
+        if in_fence:
+            out.append(line)
+            continue
+
+        heading_match = notes_heading_re.match(stripped)
+        if heading_match:
+            in_notes = True
+            notes_level = len(stripped.split(" ")[0].lstrip("#"))
+            last_note_index = None
+        elif notes_heading_plain_re.match(stripped):
+            in_notes = True
+            notes_level = None
+            last_note_index = None
+        elif re.match(r"^#{1,6}\s+", stripped):
+            if notes_level is not None:
+                level = len(stripped.split(" ")[0].lstrip("#"))
+                if level <= notes_level:
+                    in_notes = False
+                    notes_level = None
+                    last_note_index = None
+
         match = re.match(r"^\[\^([0-9]+)\]\s+", line)
         if match:
-            lines[idx] = re.sub(r"^\[\^([0-9]+)\]\s+", r"[^\1]: ", line)
-    return "\n".join(lines)
+            out.append(re.sub(r"^\[\^([0-9]+)\]\s+", r"[^\1]: ", line))
+            continue
+
+        if in_notes:
+            list_match = re.match(r"^\s*(\d{1,4})[.)]\s+", line)
+            if list_match:
+                number = list_match.group(1)
+                rest = line[list_match.end() :].strip()
+                out.append(f"[^{number}]: {rest}")
+                last_note_index = len(out) - 1
+                continue
+            if last_note_index is not None:
+                if line.strip() == "":
+                    out.append(line)
+                    last_note_index = None
+                    continue
+                if line.startswith((" ", "\t")):
+                    out[last_note_index] = f"{out[last_note_index]} {line.strip()}"
+                    continue
+
+        line = re.sub(r"(?<!\^)\[(\d{1,4})\]", r"[^\1]", line)
+        out.append(line)
+
+    return "\n".join(out)
 
 
 def normalize_markdown_images(text: str) -> str:
@@ -115,6 +190,68 @@ def normalize_fenced_code_blocks(text: str) -> str:
     return "\n".join(out)
 
 
+def normalize_mermaid_blocks(text: str) -> str:
+    """Keep mermaid fences clean by moving legend text outside the block."""
+    lines = text.splitlines()
+    out: list[str] = []
+    in_mermaid = False
+    fence_char = ""
+    fence_len = 0
+    mermaid_lines: list[str] = []
+    legend_lines: list[str] = []
+
+    def is_legend(line: str) -> bool:
+        stripped = line.strip()
+        if not stripped:
+            return False
+        if stripped.startswith("图例") or stripped.lower().startswith("legend"):
+            return True
+        return "节点定位" in stripped
+
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith(("```", "~~~")):
+            run_len = 0
+            while run_len < len(stripped) and stripped[run_len] == stripped[0]:
+                run_len += 1
+            rest = stripped[run_len:].strip()
+            if not in_mermaid and rest.lower().startswith("mermaid"):
+                in_mermaid = True
+                fence_char = stripped[0]
+                fence_len = run_len
+                mermaid_lines = []
+                legend_lines = []
+                out.append(line)
+                continue
+            if in_mermaid and stripped[0] == fence_char and run_len >= fence_len and rest == "":
+                out.extend(mermaid_lines)
+                out.append(line)
+                out.extend(legend_lines)
+                in_mermaid = False
+                fence_char = ""
+                fence_len = 0
+                mermaid_lines = []
+                legend_lines = []
+                continue
+            out.append(line)
+            continue
+
+        if in_mermaid:
+            if is_legend(line):
+                legend_lines.append(line)
+            else:
+                mermaid_lines.append(line)
+            continue
+
+        out.append(line)
+
+    if in_mermaid:
+        out.extend(mermaid_lines)
+        out.extend(legend_lines)
+
+    return "\n".join(out)
+
+
 def normalize_unbalanced_fences(text: str) -> str:
     """Drop unmatched opening fences so later content still renders."""
     lines = text.splitlines()
@@ -122,6 +259,7 @@ def normalize_unbalanced_fences(text: str) -> str:
     in_fence = False
     fence_char = ""
     fence_len = 0
+    fence_has_content = False
     fence_open_indices: list[int] = []
     fence_re = re.compile(r"([`~]{3,})(.*)$")
 
@@ -135,19 +273,46 @@ def normalize_unbalanced_fences(text: str) -> str:
                 run = match.group(1)
                 fence = run[0]
                 run_len = len(run)
+                rest = match.group(2) or ""
+                has_info = bool(rest.strip())
                 if not in_fence:
                     in_fence = True
                     fence_char = fence
                     fence_len = run_len
+                    fence_has_content = False
                     fence_open_indices.append(len(out))
                     is_fence = True
-                elif fence == fence_char and run_len >= fence_len:
-                    in_fence = False
-                    fence_char = ""
-                    fence_len = 0
+                elif fence == fence_char and run_len >= fence_len and not has_info:
+                    if not fence_has_content:
+                        if fence_open_indices:
+                            out.pop(fence_open_indices[-1])
+                            fence_open_indices.pop()
+                        in_fence = True
+                        fence_char = fence
+                        fence_len = run_len
+                        fence_has_content = False
+                        fence_open_indices.append(len(out))
+                        is_fence = True
+                    else:
+                        in_fence = False
+                        fence_char = ""
+                        fence_len = 0
+                        fence_has_content = False
+                        is_fence = True
+                elif fence == fence_char and run_len >= fence_len and has_info:
+                    if fence_open_indices:
+                        out.pop(fence_open_indices[-1])
+                        fence_open_indices.pop()
+                    in_fence = True
+                    fence_char = fence
+                    fence_len = run_len
+                    fence_has_content = False
+                    fence_open_indices.append(len(out))
                     is_fence = True
 
         out.append(line)
+        if in_fence and not is_fence and line.strip():
+            fence_has_content = True
 
     if in_fence and fence_open_indices:
         out.pop(fence_open_indices[-1])
@@ -534,6 +699,7 @@ def extract_html_table_placeholders(text: str) -> tuple[str, dict[str, str]]:
 
 def render_markdown_with_math_placeholders(md: MarkdownIt, text: str) -> str:
     """Render markdown with math, images, and tables properly escaped."""
+    text = normalize_mermaid_blocks(text)
     text = normalize_fenced_code_blocks(text)
     text = normalize_unbalanced_fences(text)
     text = strip_paragraph_wrapped_tables(text)

deepresearch_flow/paper/web/static/css/main.css

@@ -223,11 +223,18 @@ header a {
 
 .markmap {
   width: 100%;
-  height: 420px;
   border: 1px solid #e2e8f0;
   border-radius: 12px;
   background: #ffffff;
   margin: 12px 0;
+  padding: 8px;
+  overflow-x: auto;
+}
+
+.markmap > svg {
+  width: 100%;
+  min-height: 240px;
+  display: block;
 }
 
 /* Utilities */

deepresearch_flow/paper/web/static/js/detail.js

@@ -421,24 +421,58 @@
     var content = document.getElementById('content');
     if (!content) return;
 
-    // Markmap: convert fenced markmap blocks to svg mindmaps
-    if (window.markmap && window.markmap.Transformer && window.markmap.Markmap) {
-      var transformer = new window.markmap.Transformer();
-      document.querySelectorAll('code.language-markmap').forEach(function(code) {
-        var pre = code.parentElement;
-        if (!pre) return;
-        var svg = document.createElement('svg');
-        svg.className = 'markmap';
-        pre.replaceWith(svg);
+    // Markmap: convert fenced markmap blocks to autoloader containers
+    var markmapBlocks = 0;
+    document.querySelectorAll('code.language-markmap').forEach(function(code) {
+      var pre = code.parentElement;
+      if (!pre) return;
+      var wrapper = document.createElement('div');
+      wrapper.className = 'markmap';
+      var template = document.createElement('script');
+      template.type = 'text/template';
+      template.textContent = code.textContent || '';
+      wrapper.appendChild(template);
+      pre.replaceWith(wrapper);
+      markmapBlocks += 1;
+    });
+    function resizeMarkmaps() {
+      document.querySelectorAll('.markmap svg').forEach(function(svg) {
         try {
-          var result = transformer.transform(code.textContent || '');
-          window.markmap.Markmap.create(svg, null, result.root);
+          var bbox = svg.getBBox();
+          if (!bbox || !bbox.height) {
+            svg.style.height = '800px';
+            svg.style.width = '100%';
+            return;
+          }
+          var height = Math.ceil(bbox.height * 2);
+          svg.style.height = height + 'px';
+          if (bbox.width && bbox.width > svg.clientWidth) {
+            svg.style.width = Math.ceil(bbox.width * 2) + 'px';
+            if (svg.parentElement) {
+              svg.parentElement.style.overflowX = 'auto';
+            }
+          } else {
+            svg.style.width = '100%';
+          }
         } catch (err) {
-          // Ignore markmap parse errors
+          // Ignore sizing errors
         }
       });
     }
 
+    if (markmapBlocks && window.markmap && window.markmap.autoLoader && window.markmap.autoLoader.renderAll) {
+      window.markmap.autoLoader.renderAll();
+      setTimeout(resizeMarkmaps, 120);
+      setTimeout(resizeMarkmaps, 600);
+      setTimeout(resizeMarkmaps, 1600);
+      if (!window.__markmapResizeBound) {
+        window.__markmapResizeBound = true;
+        window.addEventListener('resize', function() {
+          setTimeout(resizeMarkmaps, 120);
+        });
+      }
+    }
+
     // Mermaid: convert fenced code blocks to mermaid divs
     document.querySelectorAll('code.language-mermaid').forEach(function(code) {
       var pre = code.parentElement;