@omnitron-dev/prism 0.2.0 → 0.3.1

package/dist/components/research-editor/index.js

@@ -0,0 +1,1592 @@
+import { researchLimits, ResearchDocument, parseResearchMarkdown, splitFrontmatter } from '../../chunk-SU3LVQ7N.js';
+import '../../chunk-GUGTDURV.js';
+import { KeyboardIcon, CheckIcon, AddIcon, DragIcon } from '../../chunk-PGHEP4JD.js';
+import '../../chunk-BJE2AKD4.js';
+import { createContext, useRef, useState, useEffect, useMemo, useImperativeHandle, useContext } from 'react';
+import { getSchema, Node, Extension } from '@tiptap/core';
+import { useEditor, useEditorState, EditorContent, ReactNodeViewRenderer, NodeViewWrapper } from '@tiptap/react';
+import { PluginKey, NodeSelection, TextSelection, Plugin, Selection } from '@tiptap/pm/state';
+import Box from '@mui/material/Box';
+import Button2 from '@mui/material/Button';
+import Dialog from '@mui/material/Dialog';
+import DialogTitle from '@mui/material/DialogTitle';
+import DialogContent from '@mui/material/DialogContent';
+import DialogActions from '@mui/material/DialogActions';
+import TextField2 from '@mui/material/TextField';
+import Autocomplete, { createFilterOptions } from '@mui/material/Autocomplete';
+import StarterKit from '@tiptap/starter-kit';
+import TaskList from '@tiptap/extension-task-list';
+import TaskItem from '@tiptap/extension-task-item';
+import { TableKit } from '@tiptap/extension-table';
+import { Decoration, DecorationSet } from '@tiptap/pm/view';
+import { flushSync } from 'react-dom';
+import { closeHistory } from '@tiptap/pm/history';
+import katex from 'katex';
+import IconButton from '@mui/material/IconButton';
+import Tooltip from '@mui/material/Tooltip';
+import GlobalStyles from '@mui/material/GlobalStyles';
+import { useTheme } from '@mui/material/styles';
+import DOMPurify from 'dompurify';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { toMarkdown } from 'mdast-util-to-markdown';
+import { gfm } from 'micromark-extension-gfm';
+import { gfmToMarkdown, gfmFromMarkdown } from 'mdast-util-gfm';
+import { math } from 'micromark-extension-math';
+import { mathToMarkdown, mathFromMarkdown } from 'mdast-util-math';
+import { directive } from 'micromark-extension-directive';
+import { directiveFromMarkdown } from 'mdast-util-directive';
+import { canSplit } from '@tiptap/pm/transform';
+import Menu from '@mui/material/Menu';
+import MenuItem from '@mui/material/MenuItem';
+
+var layoutProperties = /* @__PURE__ */ new Set([
+  "color",
+  "background-color",
+  "opacity",
+  "height",
+  "width",
+  "min-width",
+  "max-width",
+  "min-height",
+  "max-height",
+  "top",
+  "bottom",
+  "left",
+  "right",
+  "vertical-align",
+  "margin",
+  "margin-top",
+  "margin-bottom",
+  "margin-left",
+  "margin-right",
+  "padding",
+  "padding-top",
+  "padding-bottom",
+  "padding-left",
+  "padding-right",
+  "border",
+  "border-top",
+  "border-bottom",
+  "border-left",
+  "border-right",
+  "border-color",
+  "border-width",
+  "border-style",
+  "border-radius",
+  "font-size",
+  "font-weight",
+  "font-style",
+  "line-height",
+  "letter-spacing",
+  "display",
+  "visibility",
+  "text-align",
+  "white-space",
+  "transform",
+  "transform-origin"
+]);
+function sanitizeMathMarkup(html) {
+  const fragment = DOMPurify.sanitize(html, {
+    ADD_ATTR: ["contenteditable"],
+    ADD_TAGS: ["use"],
+    FORBID_TAGS: ["style", "link", "iframe", "object", "embed", "img", "image", "foreignObject"],
+    RETURN_DOM_FRAGMENT: true
+  });
+  for (const element of fragment.querySelectorAll("*")) {
+    for (const attribute of Array.from(element.attributes)) {
+      if (["href", "xlink:href", "src", "action", "formaction", "poster"].includes(attribute.name) && !(element.localName === "use" && /^#[\w-]+$/.test(attribute.value)))
+        element.removeAttribute(attribute.name);
+    }
+  }
+  for (const element of fragment.querySelectorAll("[style]")) {
+    const parsed = document.createElement("span").style;
+    parsed.cssText = element.getAttribute("style") ?? "";
+    const safe = document.createElement("span").style;
+    for (const name of Array.from(parsed)) {
+      if (layoutProperties.has(name)) safe.setProperty(name, parsed.getPropertyValue(name));
+    }
+    if (safe.cssText) element.setAttribute("style", safe.cssText);
+    else element.removeAttribute("style");
+  }
+  for (const element of fragment.querySelectorAll("[fill], [stroke]")) {
+    for (const name of ["fill", "stroke"]) {
+      const value = element.getAttribute(name);
+      if (value && /url|\\/i.test(value)) element.removeAttribute(name);
+    }
+  }
+  const wrapper = document.createElement("div");
+  wrapper.append(fragment);
+  return wrapper.innerHTML;
+}
+var defaultMathInputLabels = {
+  field: "Equation",
+  source: "LaTeX source",
+  keyboard: "Math keyboard",
+  done: "Return to document",
+  loading: "Loading equation editor\u2026",
+  unavailable: "Visual input unavailable. LaTeX editing is available.",
+  syntax: "Check the LaTeX syntax. The source is retained.",
+  limit: "Equation exceeds the configured limit."
+};
+var runtime;
+var keyboardOwner;
+function loadMathLive() {
+  return runtime ??= import('mathlive').then((module) => {
+    module.MathfieldElement.createHTML = sanitizeMathMarkup;
+    module.MathfieldElement.fontsDirectory = null;
+    module.MathfieldElement.soundsDirectory = null;
+    return module;
+  }).catch((error) => {
+    runtime = void 0;
+    throw error;
+  });
+}
+function MathInput(props) {
+  const labels = { ...defaultMathInputLabels, ...props.labels };
+  const theme = useTheme();
+  const host = useRef(null), field = useRef(void 0);
+  const editingSource = useRef(false);
+  const latest = useRef(props);
+  latest.current = props;
+  const [ready, setReady] = useState(false), [failed, setFailed] = useState(false);
+  const [source, setSource] = useState(false), [issue, setIssue] = useState();
+  function accept(value) {
+    const p = latest.current;
+    if (p.readOnly || value.length > (p.maxLength ?? 65536) || p.onChange(value) === false) {
+      if (!p.readOnly) setIssue("limit");
+      return false;
+    }
+    return true;
+  }
+  useEffect(() => {
+    let cancelled = false;
+    let dispose;
+    void loadMathLive().then(({ MathfieldElement }) => {
+      if (cancelled || !host.current) return;
+      const p = latest.current;
+      if (p.locale) MathfieldElement.locale = p.locale;
+      const mf = new MathfieldElement({
+        defaultMode: p.display ? "math" : "inline-math",
+        mathVirtualKeyboardPolicy: "manual",
+        ...p.options
+      });
+      field.current = mf;
+      mf.smartFence = false;
+      mf.removeExtraneousParentheses = false;
+      mf.readOnly = !!p.readOnly;
+      mf.setAttribute("aria-label", p.labels?.field ?? defaultMathInputLabels.field);
+      mf.setValue(p.value, { silenceNotifications: true });
+      const claimKeyboard = () => {
+        keyboardOwner = mf;
+      };
+      mf.addEventListener("focusin", claimKeyboard, true);
+      const input = (event) => {
+        event.stopPropagation();
+        const accepted = accept(mf.value);
+        if (!accepted) mf.setValue(latest.current.value, { silenceNotifications: true });
+        else setIssue(mf.errors.length ? "syntax" : void 0);
+      };
+      const move = (event) => {
+        if (!latest.current.onExit) return;
+        event.preventDefault();
+        latest.current.onExit(event.detail.direction);
+      };
+      const key = (event) => {
+        if (event.isComposing) return;
+        const p2 = latest.current;
+        if (p2.onHistory && (event.metaKey || event.ctrlKey) && ["z", "y"].includes(event.key.toLowerCase())) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          p2.onHistory(event.shiftKey || event.key.toLowerCase() === "y");
+        } else if (p2.onExit && (event.key === "Escape" || event.key === "Enter" && !event.shiftKey)) {
+          if (event.key === "Enter" && mf.mode === "latex") return;
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          p2.onExit("forward");
+        }
+      };
+      const stop = (event) => {
+        event.stopPropagation();
+        if (event.type === "beforeinput" && latest.current.onHistory) {
+          const type = event.inputType;
+          if (type === "historyUndo" || type === "historyRedo") {
+            event.preventDefault();
+            latest.current.onHistory(type === "historyRedo");
+          }
+        }
+      };
+      for (const name of ["keydown", "keyup", "keypress", "beforeinput", "paste", "cut", "copy"])
+        mf.addEventListener(name, stop);
+      mf.addEventListener("input", input);
+      mf.addEventListener("move-out", move);
+      mf.addEventListener("keydown", key, true);
+      dispose = () => {
+        if (keyboardOwner === mf) {
+          window.mathVirtualKeyboard.hide({ animate: false });
+          keyboardOwner = void 0;
+        }
+        mf.removeEventListener("focusin", claimKeyboard, true);
+        for (const name of ["keydown", "keyup", "keypress", "beforeinput", "paste", "cut", "copy"])
+          mf.removeEventListener(name, stop);
+        mf.removeEventListener("input", input);
+        mf.removeEventListener("move-out", move);
+        mf.removeEventListener("keydown", key, true);
+        mf.remove();
+        field.current = void 0;
+      };
+      host.current.replaceChildren(mf);
+      mf.menuItems = [];
+      setReady(true);
+      if (mf.errors.length) {
+        setIssue("syntax");
+        editingSource.current = true;
+        setSource(true);
+      }
+    }).catch(() => {
+      dispose?.();
+      if (!cancelled) {
+        setFailed(true);
+        setSource(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+      dispose?.();
+    };
+  }, []);
+  useEffect(() => {
+    const p = latest.current, mf = field.current;
+    if (ready && mf && p.autoFocus && !p.readOnly && !editingSource.current) {
+      keyboardOwner = mf;
+      mf.focus();
+      mf.position = p.entry === "start" ? 0 : -1;
+    }
+  }, [ready]);
+  useEffect(() => {
+    const mf = field.current;
+    if (!mf) return;
+    mf.readOnly = !!props.readOnly;
+    mf.setAttribute("aria-label", labels.field);
+    if (mf.value !== props.value) mf.setValue(props.value, { silenceNotifications: true });
+  }, [props.value, props.readOnly, labels.field, ready]);
+  useEffect(() => {
+    if (props.locale && ready)
+      void loadMathLive().then(({ MathfieldElement }) => {
+        MathfieldElement.locale = props.locale;
+      });
+  }, [props.locale, ready]);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      component: "span",
+      className: "prism-math-input",
+      sx: {
+        color: "text.primary",
+        bgcolor: "background.paper",
+        borderColor: "divider",
+        "--prism-editor-accent": theme.palette.primary.main,
+        "--prism-editor-radius": `${theme.shape.borderRadius}px`
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          GlobalStyles,
+          {
+            styles: {
+              ".ML__keyboard": {
+                "--keyboard-background": theme.palette.background.default,
+                "--keycap-background": theme.palette.background.paper,
+                "--keycap-text": theme.palette.text.primary,
+                "--keycap-background-hover": theme.palette.action.hover,
+                "--keycap-text-hover": theme.palette.text.primary,
+                "--keyboard-accent-color": theme.palette.primary.main,
+                "--keyboard-toolbar-background": theme.palette.background.paper,
+                "--keyboard-toolbar-text": theme.palette.text.secondary,
+                "--keyboard-toolbar-text-active": theme.palette.primary.main,
+                "--keycap-primary-background": theme.palette.primary.main,
+                "--keycap-primary-text": theme.palette.primary.contrastText,
+                "--keycap-secondary-background": theme.palette.action.hover,
+                "--keycap-secondary-text": theme.palette.text.primary,
+                "--keycap-border": `1px solid ${theme.palette.divider}`,
+                "--keycap-secondary-border": `1px solid ${theme.palette.divider}`,
+                "--keyboard-zindex": theme.zIndex.modal + 1
+              }
+            }
+          }
+        ),
+        !ready && /* @__PURE__ */ jsx(Box, { component: "span", role: "status", sx: { typography: "caption" }, children: failed ? labels.unavailable : labels.loading }),
+        /* @__PURE__ */ jsx("span", { ref: host, className: "prism-math-input__field" }),
+        /* @__PURE__ */ jsxs(Box, { component: "span", className: "prism-math-input__tools", children: [
+          /* @__PURE__ */ jsx(
+            Button2,
+            {
+              type: "button",
+              size: "small",
+              "aria-pressed": source,
+              onMouseDown: (e) => e.preventDefault(),
+              onClick: () => setSource(!source),
+              children: "LaTeX"
+            }
+          ),
+          /* @__PURE__ */ jsx(Tooltip, { title: labels.keyboard, children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              "aria-label": labels.keyboard,
+              type: "button",
+              size: "small",
+              disabled: !ready || props.readOnly,
+              onMouseDown: (e) => e.preventDefault(),
+              onClick: () => {
+                keyboardOwner = field.current;
+                field.current?.focus();
+                field.current?.executeCommand("toggleVirtualKeyboard");
+              },
+              children: /* @__PURE__ */ jsx(KeyboardIcon, { fontSize: "small" })
+            }
+          ) }) }),
+          props.onExit && /* @__PURE__ */ jsx(Tooltip, { title: labels.done, children: /* @__PURE__ */ jsx(IconButton, { type: "button", size: "small", "aria-label": labels.done, onClick: () => props.onExit?.("forward"), children: /* @__PURE__ */ jsx(CheckIcon, { fontSize: "small" }) }) })
+        ] }),
+        (source || !ready) && /* @__PURE__ */ jsx(
+          TextField2,
+          {
+            fullWidth: true,
+            autoFocus: !ready && props.autoFocus,
+            size: "small",
+            multiline: true,
+            maxRows: 8,
+            label: labels.source,
+            value: props.value,
+            onChange: (event) => {
+              editingSource.current = true;
+              setSource(true);
+              if (accept(event.target.value)) setIssue(void 0);
+            },
+            slotProps: { input: { readOnly: props.readOnly }, htmlInput: { spellCheck: false } },
+            onKeyDown: (event) => {
+              if (event.key === "Escape") {
+                event.stopPropagation();
+                props.onExit?.("forward");
+              }
+              if (props.onHistory && (event.ctrlKey || event.metaKey) && ["z", "y"].includes(event.key.toLowerCase())) {
+                event.preventDefault();
+                event.stopPropagation();
+                props.onHistory(event.shiftKey || event.key.toLowerCase() === "y");
+              }
+            },
+            sx: { flexBasis: "100%", mt: 1, "& textarea": { fontFamily: "monospace" } }
+          }
+        ),
+        issue && /* @__PURE__ */ jsx(Box, { component: "span", role: "status", sx: { typography: "caption", color: "text.secondary", flexBasis: "100%" }, children: labels[issue] })
+      ]
+    }
+  );
+}
+var opaque = /* @__PURE__ */ new Set([
+  "html",
+  "frontmatter",
+  "image",
+  "imageReference",
+  "linkReference",
+  "definition",
+  "footnoteDefinition",
+  "footnoteReference",
+  "containerDirective",
+  "leafDirective",
+  "textDirective"
+]);
+var hasOpaque = (n) => (n.type === "code" || n.type === "math") && !!n.meta || n.type === "list" && n.children?.some((c) => typeof c.checked === "boolean") && !n.children?.every((c) => typeof c.checked === "boolean") || n.type === "table" && Array.isArray(n.align) && n.align.some(Boolean) || opaque.has(n.type) || n.type === "code" && ["mermaid", "pintora", "prism"].includes(String(n.lang).toLowerCase()) || !!n.children?.some(hasOpaque);
+var newBlockId = () => crypto.randomUUID();
+function semantic(n) {
+  const attrs = Object.fromEntries(
+    Object.entries(n.attrs ?? {}).filter(([k, v]) => !["source", "id"].includes(k) && v != null)
+  );
+  return {
+    type: n.type,
+    ...Object.keys(attrs).length ? { attrs } : {},
+    ...n.text !== void 0 ? { text: n.text } : {},
+    ...n.marks?.length ? { marks: n.marks } : {},
+    ...n.content?.length ? { content: n.content.map(semantic) } : {}
+  };
+}
+var signature = (content) => JSON.stringify(content.map(semantic));
+function sourceDocument(source, id = newBlockId) {
+  if (source.length > researchLimits.source) throw new Error("document_limit");
+  parseResearchMarkdown(source);
+  const { body, metadata } = splitFrontmatter(source);
+  const ast = fromMarkdown(body, {
+    extensions: [gfm(), math(), directive()],
+    mdastExtensions: [gfmFromMarkdown(), mathFromMarkdown(), directiveFromMarkdown()]
+  });
+  if (metadata) {
+    const stop = metadata.end - (metadata.raw.endsWith("\r\n") ? 2 : metadata.raw.endsWith("\n") ? 1 : 0);
+    ast.children.unshift({ type: "frontmatter", position: { start: { offset: 0 }, end: { offset: stop } } });
+  }
+  let end = 0;
+  const content = (ast.children ?? []).map((n) => {
+    const start = n.position.start.offset, stop = n.position.end.offset;
+    const raw = source.slice(start, stop), prefix = source.slice(end, start);
+    end = stop;
+    const nodes = hasOpaque(n) ? [{ type: "researchSource", attrs: { raw, kind: n.type === "code" ? String(n.lang) : n.type } }] : parseResearchMarkdown(raw).doc.content;
+    const cleaned = nodes.map(cleanNode);
+    return {
+      type: "researchBlock",
+      attrs: { id: id(), raw, prefix, baseline: signature(cleaned) },
+      content: cleaned.length ? cleaned : [{ type: "paragraph" }]
+    };
+  });
+  return {
+    type: "doc",
+    attrs: { tail: source.slice(end) },
+    content: content.length ? content : [
+      {
+        type: "researchBlock",
+        attrs: { id: id(), raw: "", prefix: "", baseline: signature([{ type: "paragraph" }]) },
+        content: [{ type: "paragraph" }]
+      }
+    ]
+  };
+}
+function cleanNode(n) {
+  const attrs = Object.fromEntries(Object.entries(n.attrs ?? {}).filter(([k]) => !["source", "id"].includes(k)));
+  if (n.type === "orderedList") attrs.start ??= 1;
+  if (n.type === "codeBlock") attrs.language ||= null;
+  if (n.type === "taskItem") attrs.checked ??= false;
+  return { ...n, attrs, content: n.content?.map(cleanNode) };
+}
+function astNode(n) {
+  const children = () => (n.content ?? []).map(astNode), a = n.attrs ?? {};
+  let result;
+  switch (n.type) {
+    case "paragraph":
+      result = { type: "paragraph", children: children() };
+      break;
+    case "heading":
+      result = { type: "heading", depth: a.level, children: children() };
+      break;
+    case "text":
+      result = { type: "text", value: n.text ?? "" };
+      break;
+    case "hardBreak":
+      return { type: "break" };
+    case "horizontalRule":
+      return { type: "thematicBreak" };
+    case "blockquote":
+      return { type: "blockquote", children: children() };
+    case "codeBlock":
+      return { type: "code", lang: a.language || null, value: (n.content ?? []).map((x) => x.text ?? "").join("") };
+    case "mathBlock":
+      return { type: "math", value: a.tex ?? "" };
+    case "mathInline":
+      result = { type: "inlineMath", value: a.tex ?? "" };
+      break;
+    case "bulletList":
+    case "orderedList":
+    case "taskList":
+      return {
+        type: "list",
+        ordered: n.type === "orderedList",
+        start: a.start ?? 1,
+        spread: false,
+        children: children()
+      };
+    case "listItem":
+    case "taskItem":
+      return {
+        type: "listItem",
+        spread: false,
+        checked: n.type === "taskItem" ? !!a.checked : null,
+        children: children()
+      };
+    case "table":
+      return { type: "table", align: (n.content?.[0]?.content ?? []).map(() => null), children: children() };
+    case "tableRow":
+      return { type: "tableRow", children: children() };
+    case "tableCell":
+    case "tableHeader":
+      if ((a.colspan ?? 1) !== 1 || (a.rowspan ?? 1) !== 1 || n.content?.length !== 1 || n.content[0]?.type !== "paragraph")
+        throw Error("unsupported_table_shape");
+      return { type: "tableCell", children: (n.content ?? []).flatMap((p) => (p.content ?? []).map(astNode)) };
+    default:
+      throw new Error(`unsupported_editor_node:${n.type}`);
+  }
+  for (const mark of n.marks ?? []) {
+    const type = { bold: "strong", italic: "emphasis", strike: "delete", code: "inlineCode", link: "link" }[mark.type];
+    if (!type) throw new Error(`unsupported_editor_mark:${mark.type}`);
+    if (type === "inlineCode") result = { type, value: n.text ?? "" };
+    else
+      result = {
+        type,
+        ...type === "link" ? { url: mark.attrs?.href, title: mark.attrs?.title ?? null } : {},
+        children: [result]
+      };
+  }
+  return result;
+}
+function blockSource(block) {
+  const content = block.content ?? [];
+  if (signature(content) === block.attrs?.baseline) return String(block.attrs.raw ?? "");
+  if (content.length === 1 && content[0]?.type === "researchSource") return String(content[0].attrs?.raw ?? "");
+  return toMarkdown({ type: "root", children: content.map(astNode) }, {
+    extensions: [gfmToMarkdown(), mathToMarkdown()],
+    bullet: "-",
+    fences: true
+  }).replace(/\n$/, "");
+}
+var blockCache = /* @__PURE__ */ new WeakMap();
+function editorSource(doc) {
+  const parts = [];
+  doc.forEach((block, _offset, index) => {
+    let raw = blockCache.get(block);
+    if (raw === void 0) {
+      raw = blockSource(block.toJSON());
+      blockCache.set(block, raw);
+    }
+    const prefix = String(block.attrs.prefix ?? "");
+    const afterMetadata = index === 1 && doc.firstChild?.firstChild?.attrs.kind === "frontmatter";
+    parts.push(index === 0 || afterMetadata ? prefix : /\r?\n[ \t]*\r?\n/.test(prefix) ? prefix : "\n\n", raw);
+  });
+  return parts.join("") + String(doc.attrs.tail ?? "");
+}
+function snapshot(doc) {
+  let source;
+  return Object.freeze({
+    format: "prism-research-source/1",
+    blocks: doc.childCount,
+    getSource: () => source ??= editorSource(doc)
+  });
+}
+function hydrateSource(source, schema) {
+  const doc = sourceDocument(source);
+  for (const block of doc.content ?? [])
+    block.attrs.baseline = signature(schema.nodeFromJSON(block).toJSON().content ?? []);
+  schema.nodeFromJSON(doc).check();
+  return doc;
+}
+
+// src/components/research-editor/math-navigation.ts
+function exitMathTransaction(state, pos, before) {
+  const node = state.doc.nodeAt(pos);
+  if (!node || !["mathInline", "mathBlock"].includes(node.type.name)) return void 0;
+  const tr = state.tr;
+  let target = TextSelection.near(tr.doc.resolve(before ? pos : pos + node.nodeSize), before ? -1 : 1);
+  const neighbourMath = target instanceof NodeSelection && ["mathInline", "mathBlock"].includes(target.node.type.name) && target.from !== pos;
+  const reachableText = target instanceof TextSelection && (before ? target.from <= pos : target.from >= pos + node.nodeSize);
+  if (!neighbourMath && !reachableText) {
+    const $pos = tr.doc.resolve(pos);
+    const edge = before ? $pos.before(1) : $pos.after(1);
+    tr.insert(
+      edge,
+      state.schema.nodes.researchBlock.create({ id: newBlockId() }, state.schema.nodes.paragraph.create())
+    );
+    target = TextSelection.create(tr.doc, edge + 2);
+  }
+  return closeHistory(tr.setSelection(target)).setMeta("prismMathEntry", before ? "end" : "start").scrollIntoView();
+}
+function updateMathTransaction(state, pos, tex) {
+  const node = state.doc.nodeAt(pos);
+  if (!node || !["mathInline", "mathBlock"].includes(node.type.name)) return void 0;
+  const tr = state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, tex });
+  if (state.selection instanceof NodeSelection && state.selection.from === pos)
+    tr.setSelection(NodeSelection.create(tr.doc, pos));
+  return tr;
+}
+var mathEntryKey = new PluginKey("researchMathEntry");
+var ResearchMathContext = createContext({});
+function MathNodeView({ node, editor, getPos, selected }) {
+  const config = useContext(ResearchMathContext);
+  const display = node.type.name === "mathBlock", latex = String(node.attrs.tex);
+  const editable = config.readOnly === void 0 ? editor.isEditable : !config.readOnly;
+  const active = selected && editable;
+  const preview = useRef(null);
+  useEffect(() => {
+    if (!preview.current) return;
+    try {
+      katex.render(latex === "\\placeholder{}" ? "\\square" : latex, preview.current, {
+        displayMode: display,
+        trust: false,
+        strict: "error",
+        throwOnError: true,
+        maxExpand: 1e3,
+        maxSize: 20
+      });
+    } catch {
+      preview.current.textContent = latex || config.labels?.field || "Equation";
+    }
+  }, [latex, display, active, config.labels?.field]);
+  useEffect(() => {
+    if (active) editor.view.dispatch(closeHistory(editor.state.tr));
+    return () => {
+      if (active && !editor.isDestroyed) editor.view.dispatch(closeHistory(editor.state.tr));
+    };
+  }, [active, editor]);
+  function exit(direction) {
+    const pos = getPos();
+    if (typeof pos !== "number" || editor.isDestroyed) return;
+    const before = direction === "backward" || direction === "upward";
+    const tr = exitMathTransaction(editor.state, pos, before);
+    if (tr) flushSync(() => editor.view.dispatch(tr));
+    editor.view.focus();
+  }
+  return /* @__PURE__ */ jsx(
+    NodeViewWrapper,
+    {
+      as: display ? "div" : "span",
+      className: `prism-science__math${display ? " prism-science__math--display" : ""}`,
+      contentEditable: false,
+      children: active ? /* @__PURE__ */ jsx(
+        MathInput,
+        {
+          ...config,
+          value: latex,
+          display,
+          entry: mathEntryKey.getState(editor.state),
+          autoFocus: true,
+          onChange: (input) => {
+            const value = input || "\\placeholder{}";
+            const pos = getPos();
+            if (!editor.isEditable || typeof pos !== "number" || editor.state.doc.nodeAt(pos)?.type !== node.type)
+              return false;
+            if (value === editor.state.doc.nodeAt(pos)?.attrs.tex) return true;
+            const tr = updateMathTransaction(editor.state, pos, value);
+            if (!tr) return false;
+            editor.view.dispatch(tr);
+            return editor.state.doc.nodeAt(pos)?.attrs.tex === value;
+          },
+          onExit: exit,
+          onHistory: (redo) => {
+            if (redo) editor.commands.redo();
+            else editor.commands.undo();
+          }
+        }
+      ) : /* @__PURE__ */ jsx(
+        "span",
+        {
+          ref: preview,
+          role: editable ? "button" : "math",
+          tabIndex: editable ? 0 : void 0,
+          "aria-label": `${config.labels?.field ?? "Equation"}: ${latex}`,
+          className: "prism-science__math-preview",
+          onClick: () => {
+            const pos = getPos();
+            if (editor.isEditable && !config.readOnly && typeof pos === "number") editor.commands.setNodeSelection(pos);
+          },
+          onKeyDown: (event) => {
+            if (event.key === "Enter" || event.key === " ") {
+              event.preventDefault();
+              event.currentTarget.click();
+            }
+          }
+        }
+      )
+    }
+  );
+}
+function findBlock(doc, id) {
+  let found;
+  doc.forEach((node, pos, index) => {
+    if (node.type.name === "researchBlock" && node.attrs.id === id) found = { node, pos, index };
+  });
+  return found;
+}
+function currentBlock(editor) {
+  const { $from } = editor.state.selection;
+  if ($from.depth >= 1) return { pos: $from.before(1), index: $from.index(0) };
+  const index = $from.index(0);
+  return editor.state.doc.childCount ? {
+    pos: index >= editor.state.doc.childCount ? editor.state.doc.content.size - editor.state.doc.lastChild.nodeSize : $from.pos,
+    index: Math.min(index, editor.state.doc.childCount - 1)
+  } : void 0;
+}
+function selectMoved(tr, state, oldPos, newPos, node) {
+  const { selection } = state;
+  const within = selection.from >= oldPos && selection.to <= oldPos + node.nodeSize;
+  if (within && selection instanceof TextSelection) {
+    tr.setSelection(TextSelection.create(tr.doc, newPos + selection.anchor - oldPos, newPos + selection.head - oldPos));
+  } else if (within && selection instanceof NodeSelection) {
+    tr.setSelection(NodeSelection.create(tr.doc, newPos + selection.from - oldPos));
+  } else {
+    tr.setSelection(Selection.near(tr.doc.resolve(newPos + 1)));
+  }
+  return closeHistory(tr).scrollIntoView();
+}
+function moveBlockTransaction(state, id, beforeId) {
+  const from = findBlock(state.doc, id);
+  const before = beforeId === null ? void 0 : findBlock(state.doc, beforeId);
+  if (!from || beforeId !== null && !before || beforeId === id) return void 0;
+  const destination = before?.index ?? state.doc.childCount;
+  if (destination === from.index + 1 || destination === state.doc.childCount && from.index === destination - 1)
+    return void 0;
+  const tr = state.tr.delete(from.pos, from.pos + from.node.nodeSize);
+  const target = beforeId === null ? tr.doc.content.size : findBlock(tr.doc, beforeId).pos;
+  tr.insert(target, from.node);
+  return selectMoved(tr, state, from.pos, target, from.node);
+}
+function blockActionTransaction(state, id, action) {
+  const block = findBlock(state.doc, id);
+  if (!block) return void 0;
+  const { node, pos, index } = block;
+  if (action === "up")
+    return index > 0 ? moveBlockTransaction(state, id, String(state.doc.child(index - 1).attrs.id)) : void 0;
+  if (action === "down")
+    return index < state.doc.childCount - 1 ? moveBlockTransaction(
+      state,
+      id,
+      index + 2 < state.doc.childCount ? String(state.doc.child(index + 2).attrs.id) : null
+    ) : void 0;
+  const tr = state.tr;
+  if (action === "duplicate") {
+    const copy = node.type.create({ ...node.attrs, id: newBlockId(), prefix: "\n\n" }, node.content);
+    tr.insert(pos + node.nodeSize, copy);
+    return selectMoved(tr, state, pos, pos + node.nodeSize, copy);
+  }
+  if (state.doc.childCount === 1) {
+    tr.replaceWith(
+      pos,
+      pos + node.nodeSize,
+      node.type.create({ id: newBlockId() }, state.schema.nodes.paragraph.create())
+    );
+  } else {
+    tr.delete(pos, pos + node.nodeSize);
+  }
+  tr.setSelection(Selection.near(tr.doc.resolve(Math.min(pos + 1, tr.doc.content.size))));
+  return closeHistory(tr).scrollIntoView();
+}
+function runBlockAction(editor, action, id) {
+  if (!editor.isEditable) return false;
+  const selected = currentBlock(editor);
+  const target = id ?? (selected && String(editor.state.doc.child(selected.index).attrs.id));
+  const tr = target && blockActionTransaction(editor.state, target, action);
+  return dispatchBlockTransaction(editor, tr || void 0);
+}
+function dispatchBlockTransaction(editor, tr) {
+  if (!editor.isEditable || !tr) return false;
+  editor.view.dispatch(tr);
+  editor.view.dispatch(closeHistory(editor.state.tr));
+  editor.commands.focus();
+  return true;
+}
+var ResearchViewContext = createContext(void 0);
+function SourceView({ node, extension }) {
+  const presentation = useContext(ResearchViewContext);
+  const ref = useRef(null), [visible, setVisible] = useState(false);
+  useEffect(() => {
+    if (!ref.current) return void 0;
+    if (typeof IntersectionObserver === "undefined") {
+      setVisible(true);
+      return void 0;
+    }
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((e) => e.isIntersecting)) {
+          setVisible(true);
+          observer.disconnect();
+        }
+      },
+      { rootMargin: "200px" }
+    );
+    observer.observe(ref.current);
+    return () => observer.disconnect();
+  }, []);
+  return /* @__PURE__ */ jsx(NodeViewWrapper, { className: "prism-science__source-block", contentEditable: false, children: /* @__PURE__ */ jsxs("div", { ref, children: [
+    /* @__PURE__ */ jsx("span", { className: "prism-science__kind", children: String(node.attrs.kind) }),
+    visible ? /* @__PURE__ */ jsx(
+      ResearchDocument,
+      {
+        source: String(node.attrs.raw),
+        widgets: presentation?.widgets ?? extension.options.widgets,
+        labels: presentation?.labels ?? extension.options.labels
+      }
+    ) : /* @__PURE__ */ jsx("pre", { children: String(node.attrs.raw).slice(0, 160) })
+  ] }) });
+}
+function researchExtensions(widgets = {}, limits, labels) {
+  const Doc = Node.create({
+    name: "doc",
+    topNode: true,
+    content: "researchBlock+",
+    addAttributes: () => ({ tail: { default: "" } })
+  });
+  const Block = Node.create({
+    name: "researchBlock",
+    content: "block+",
+    group: "researchGroup",
+    defining: true,
+    draggable: true,
+    addAttributes: () => ({
+      id: { default: null },
+      raw: { default: "" },
+      prefix: { default: "" },
+      baseline: { default: "" }
+    }),
+    parseHTML: () => [{ tag: "div[data-research-block]" }],
+    renderHTML: ({ node }) => ["div", { "data-research-block": node.attrs.id, class: "prism-science__block" }, 0],
+    addKeyboardShortcuts() {
+      return {
+        "Mod-Alt-ArrowUp": () => runBlockAction(this.editor, "up"),
+        "Mod-Alt-ArrowDown": () => runBlockAction(this.editor, "down"),
+        Enter: () => {
+          if (!this.editor.isEditable) return false;
+          const { state, view } = this.editor, { $from, $to } = state.selection;
+          if (!$from.sameParent($to) || $from.depth !== 2 || !["paragraph", "heading"].includes($from.parent.type.name))
+            return false;
+          const next = $from.parentOffset === $from.parent.content.size ? state.schema.nodes.paragraph : $from.parent.type;
+          const types = [
+            { type: state.schema.nodes.researchBlock, attrs: { id: newBlockId() } },
+            { type: next, attrs: $from.parent.attrs }
+          ];
+          const tr = state.tr.deleteSelection();
+          if (!canSplit(tr.doc, tr.selection.from, 2, types)) return false;
+          view.dispatch(tr.split(tr.selection.from, 2, types).scrollIntoView());
+          return true;
+        }
+      };
+    }
+  });
+  const Source = Node.create({
+    name: "researchSource",
+    group: "block",
+    atom: true,
+    selectable: true,
+    addOptions: () => ({ widgets, labels }),
+    addAttributes: () => ({ raw: { default: "" }, kind: { default: "source" } }),
+    parseHTML: () => [
+      {
+        tag: "pre[data-research-source]",
+        priority: 100,
+        preserveWhitespace: "full",
+        getAttrs: (element) => ({
+          raw: element.getAttribute("data-source") ?? element.textContent ?? "",
+          kind: element.getAttribute("data-research-source") ?? "source"
+        })
+      }
+    ],
+    renderHTML: ({ node }) => [
+      "pre",
+      { "data-research-source": node.attrs.kind, "data-source": node.attrs.raw },
+      node.attrs.raw
+    ],
+    addNodeView: () => ReactNodeViewRenderer(SourceView)
+  });
+  const mathNode = (name) => Node.create({
+    name,
+    marks: name === "mathInline" ? "bold italic strike link" : "",
+    group: name === "mathInline" ? "inline" : "block",
+    inline: name === "mathInline",
+    atom: true,
+    selectable: true,
+    addAttributes: () => ({ tex: { default: "" } }),
+    parseHTML: () => [
+      {
+        tag: name === "mathInline" ? "span[data-math-inline]" : "div[data-math-block]",
+        getAttrs: (element) => ({ tex: element.getAttribute("data-tex") ?? element.textContent ?? "" })
+      }
+    ],
+    renderHTML: ({ node }) => [
+      name === "mathInline" ? "span" : "div",
+      {
+        [name === "mathInline" ? "data-math-inline" : "data-math-block"]: true,
+        "data-tex": String(node.attrs.tex)
+      },
+      String(node.attrs.tex)
+    ],
+    addNodeView: () => ReactNodeViewRenderer(MathNodeView, {
+      // Shadow-DOM math input is not a native INPUT/TEXTAREA. Letting its keys
+      // reach ProseMirror would replace the selected atom with ordinary text.
+      stopEvent: ({ event }) => event.target instanceof Element && !!event.target.closest(".prism-math-input")
+    }),
+    addKeyboardShortcuts() {
+      const enter = (backward) => {
+        if (!this.editor.isEditable || !this.editor.state.selection.empty) return false;
+        const { $from } = this.editor.state.selection;
+        const next = backward ? $from.nodeBefore : $from.nodeAfter;
+        if (next?.type.name !== "mathInline") return false;
+        const pos = backward ? $from.pos - next.nodeSize : $from.pos;
+        this.editor.view.dispatch(
+          this.editor.state.tr.setSelection(NodeSelection.create(this.editor.state.doc, pos)).setMeta("prismMathEntry", backward ? "end" : "start")
+        );
+        return true;
+      };
+      return { ArrowLeft: () => enter(true), ArrowRight: () => enter(false) };
+    }
+  });
+  const Ids = Extension.create({
+    name: "researchIds",
+    addProseMirrorPlugins() {
+      return [
+        new Plugin({
+          key: mathEntryKey,
+          state: { init: () => "end", apply: (tr, value) => tr.getMeta("prismMathEntry") ?? value }
+        }),
+        new Plugin({
+          props: {
+            decorations(state) {
+              const { from, to, empty } = state.selection;
+              const decorations = [];
+              state.doc.forEach((node, pos) => {
+                if (empty ? from >= pos && from < pos + node.nodeSize : from < pos + node.nodeSize && to > pos)
+                  decorations.push(
+                    Decoration.node(pos, pos + node.nodeSize, { class: empty ? "is-current" : "is-selected" })
+                  );
+              });
+              return DecorationSet.create(state.doc, decorations);
+            }
+          },
+          filterTransaction(tr) {
+            if (!tr.docChanged || !limits) return true;
+            try {
+              if (snapshot(tr.doc).getSource().length <= limits.source) return true;
+            } catch {
+            }
+            limits.onLimit?.();
+            return false;
+          },
+          appendTransaction(transactions, _old, state) {
+            if (!transactions.some((t) => t.docChanged)) return null;
+            const seen = /* @__PURE__ */ new Set(), tr = state.tr;
+            state.doc.forEach((node, pos) => {
+              const id = node.attrs.id;
+              if (!id || seen.has(id)) tr.setNodeMarkup(pos, void 0, { ...node.attrs, id: newBlockId() });
+              else seen.add(id);
+            });
+            return tr.docChanged ? tr.setMeta("addToHistory", false) : null;
+          }
+        })
+      ];
+    }
+  });
+  return [
+    Doc,
+    Block,
+    StarterKit.configure({ document: false, underline: false, link: { openOnClick: false }, trailingNode: false }),
+    TaskList,
+    TaskItem.configure({ nested: true, a11y: { checkboxLabel: (node) => node.textContent } }),
+    TableKit.configure({ table: { resizable: false } }),
+    Source,
+    mathNode("mathInline"),
+    mathNode("mathBlock"),
+    Ids
+  ];
+}
+function BlockControls({
+  editor,
+  container,
+  labels,
+  readOnly,
+  onInsert,
+  onSource
+}) {
+  const [anchor, setAnchor] = useState();
+  const [menu, setMenu] = useState();
+  const [dropTop, setDropTop] = useState();
+  const dragged = useRef(void 0);
+  useEffect(() => {
+    const host = container.current;
+    if (!host || readOnly) {
+      setAnchor(void 0);
+      setMenu(void 0);
+      setDropTop(void 0);
+      return void 0;
+    }
+    let hovered;
+    let frame = 0;
+    const selectedElement = () => {
+      const selected3 = currentBlock(editor);
+      const element = selected3 && editor.view.nodeDOM(selected3.pos);
+      return element instanceof HTMLElement ? element : void 0;
+    };
+    const update = () => {
+      frame = 0;
+      const element = hovered && editor.view.dom.contains(hovered) ? hovered : selectedElement();
+      const id = element?.getAttribute("data-research-block");
+      if (!id || !element) {
+        setAnchor(void 0);
+        return;
+      }
+      const top = element.getBoundingClientRect().top - host.getBoundingClientRect().top;
+      setAnchor((old) => old?.id === id && old.top === top ? old : { id, top });
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(update);
+    };
+    const elementAt = (target) => {
+      const element = target instanceof Element ? target.closest("[data-research-block]") : null;
+      return element && editor.view.dom.contains(element) ? element : void 0;
+    };
+    const pointer = (event) => {
+      if (dragged.current) return;
+      const element = elementAt(event.target);
+      if (element) {
+        hovered = element;
+        schedule();
+      }
+    };
+    const selected2 = () => {
+      hovered = void 0;
+      schedule();
+    };
+    const clearDrop = () => {
+      dragged.current = void 0;
+      setDropTop(void 0);
+    };
+    const destination = (event) => {
+      const element = elementAt(event.target);
+      if (!element) return void 0;
+      const id = element.getAttribute("data-research-block");
+      const block = findBlock(editor.state.doc, id);
+      if (!block) return void 0;
+      const rect = element.getBoundingClientRect();
+      const before = event.clientY < rect.top + rect.height / 2;
+      return {
+        id: before ? id : block.index + 1 < editor.state.doc.childCount ? String(editor.state.doc.child(block.index + 1).attrs.id) : null,
+        top: (before ? rect.top : rect.bottom) - host.getBoundingClientRect().top
+      };
+    };
+    const over = (event) => {
+      if (!dragged.current || !editor.isEditable) return;
+      const target = destination(event);
+      if (!target) {
+        setDropTop(void 0);
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+      setDropTop(target.top);
+    };
+    const drop = (event) => {
+      if (!dragged.current) return;
+      event.preventDefault();
+      event.stopPropagation();
+      const target = destination(event);
+      const tr = editor.isEditable && target && moveBlockTransaction(editor.state, dragged.current, target.id);
+      clearDrop();
+      if (tr) dispatchBlockTransaction(editor, tr);
+    };
+    host.addEventListener("pointermove", pointer);
+    host.addEventListener("dragover", over, true);
+    host.addEventListener("drop", drop, true);
+    window.addEventListener("dragend", clearDrop);
+    editor.on("selectionUpdate", selected2);
+    editor.on("transaction", selected2);
+    const observer = typeof ResizeObserver !== "undefined" ? new ResizeObserver(schedule) : void 0;
+    observer?.observe(host);
+    window.addEventListener("resize", schedule);
+    update();
+    return () => {
+      cancelAnimationFrame(frame);
+      observer?.disconnect();
+      host.removeEventListener("pointermove", pointer);
+      host.removeEventListener("dragover", over, true);
+      host.removeEventListener("drop", drop, true);
+      window.removeEventListener("dragend", clearDrop);
+      window.removeEventListener("resize", schedule);
+      editor.off("selectionUpdate", selected2);
+      editor.off("transaction", selected2);
+      dragged.current = void 0;
+    };
+  }, [editor, container, readOnly]);
+  if (readOnly || !anchor) return null;
+  const selected = menu && findBlock(editor.state.doc, menu.id);
+  function action(kind) {
+    if (menu) runBlockAction(editor, kind, menu.id);
+    setMenu(void 0);
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: "prism-science__gutter", style: { top: anchor.top }, role: "group", "aria-label": labels.blockMenu, children: [
+      /* @__PURE__ */ jsx(
+        IconButton,
+        {
+          type: "button",
+          title: labels.insert,
+          "aria-label": labels.insert,
+          onMouseDown: (e) => e.preventDefault(),
+          onClick: () => onInsert(anchor.id),
+          children: /* @__PURE__ */ jsx(AddIcon, { fontSize: "small" })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        IconButton,
+        {
+          type: "button",
+          title: labels.dragBlock,
+          "aria-label": labels.blockMenu,
+          "aria-haspopup": "menu",
+          "aria-expanded": !!menu,
+          draggable: true,
+          onDragStart: (event) => {
+            if (!editor.isEditable || !findBlock(editor.state.doc, anchor.id)) {
+              event.preventDefault();
+              return;
+            }
+            dragged.current = anchor.id;
+            event.dataTransfer.effectAllowed = "move";
+            event.dataTransfer.setData("application/x-prism-block", anchor.id);
+            setMenu(void 0);
+          },
+          onClick: (event) => setMenu({ id: anchor.id, element: event.currentTarget }),
+          children: /* @__PURE__ */ jsx(DragIcon, { fontSize: "small" })
+        }
+      )
+    ] }),
+    dropTop !== void 0 && /* @__PURE__ */ jsx("div", { className: "prism-science__drop-line", style: { top: dropTop }, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsxs(Menu, { open: !!menu, anchorEl: menu?.element, onClose: () => setMenu(void 0), children: [
+      /* @__PURE__ */ jsx(
+        MenuItem,
+        {
+          disabled: !selected,
+          onClick: () => {
+            if (menu) onSource(menu.id);
+            setMenu(void 0);
+          },
+          children: labels.editBlock
+        }
+      ),
+      /* @__PURE__ */ jsx(MenuItem, { disabled: !selected || selected.index === 0, onClick: () => action("up"), children: labels.up }),
+      /* @__PURE__ */ jsx(
+        MenuItem,
+        {
+          disabled: !selected || selected.index === editor.state.doc.childCount - 1,
+          onClick: () => action("down"),
+          children: labels.down
+        }
+      ),
+      /* @__PURE__ */ jsx(MenuItem, { disabled: !selected, onClick: () => action("duplicate"), children: labels.duplicate }),
+      /* @__PURE__ */ jsx(MenuItem, { disabled: !selected, onClick: () => action("remove"), children: labels.remove })
+    ] })
+  ] });
+}
+var defaultResearchEditorLabels = {
+  editor: "Research document",
+  insert: "Insert block",
+  search: "Find a block",
+  source: "Document source",
+  editBlock: "Block source",
+  up: "Move block up",
+  down: "Move block down",
+  duplicate: "Duplicate block",
+  remove: "Delete block",
+  undo: "Undo",
+  redo: "Redo",
+  bold: "Bold",
+  italic: "Italic",
+  link: "Link",
+  inlineMath: "Inline equation",
+  apply: "Apply",
+  cancel: "Cancel",
+  invalid: "This source cannot be applied. Check the document limits and structure.",
+  limit: "Document exceeds the configured source limit.",
+  hint: "Type / for a new block. Ctrl/\u2318 + Shift + M inserts an equation. Arrow keys move between text and math.",
+  paragraph: "Text",
+  heading: "Heading",
+  list: "Bullet list",
+  ordered: "Numbered list",
+  tasks: "Task list",
+  quote: "Quote",
+  code: "Code",
+  equation: "Equation",
+  diagram: "Diagram",
+  table: "Table",
+  widget: "Interactive block",
+  blocks: "blocks",
+  blockMenu: "Block actions",
+  dragBlock: "Drag to move; click for block actions. Keyboard: Ctrl/Command + Alt + Up/Down."
+};
+var filterInsertions = createFilterOptions({
+  stringify: (recipe) => [recipe.label, ...recipe.keywords ?? []].join(" ")
+});
+var noWidgets = Object.freeze({});
+var noInsertions = [];
+function ResearchEditor({
+  initialSource,
+  onChange,
+  ref,
+  readOnly = false,
+  labels: overrides,
+  widgets = noWidgets,
+  previewLabels,
+  insertions = noInsertions,
+  maxSourceLength = researchLimits.source,
+  blockControls = true,
+  math: math2,
+  className,
+  sx
+}) {
+  const presentation = useMemo(() => ({ widgets, labels: previewLabels }), [widgets, previewLabels]);
+  const labels = useMemo(() => ({ ...defaultResearchEditorLabels, ...overrides }), [overrides]);
+  const workspace = useRef(null);
+  const notify = useRef(onChange);
+  notify.current = onChange;
+  const [palette, setPalette] = useState(false), [dialog, setDialog] = useState(), [invalid, setInvalid] = useState("");
+  const extensions = useMemo(
+    () => researchExtensions(widgets, { source: maxSourceLength, onLimit: () => setInvalid(labels.limit) }, previewLabels),
+    [widgets, maxSourceLength, labels.limit, previewLabels]
+  );
+  const [initial] = useState(() => hydrateSource(initialSource, getSchema(extensions)));
+  const editor = useEditor({
+    extensions,
+    content: initial,
+    editable: !readOnly,
+    immediatelyRender: false,
+    shouldRerenderOnTransaction: false,
+    editorProps: {
+      attributes: { role: "textbox", "aria-multiline": "true", "aria-label": labels.editor },
+      handleKeyDown: (view, event) => {
+        if (!readOnly && !event.isComposing && (event.metaKey || event.ctrlKey) && event.shiftKey && event.key.toLowerCase() === "m") {
+          event.preventDefault();
+          insertInlineMath();
+          return true;
+        }
+        if (event.key === "/" && !event.isComposing && !view.composing && view.state.selection.empty && view.state.selection.$from.parent.type.name === "paragraph" && view.state.selection.$from.parent.content.size === 0) {
+          event.preventDefault();
+          setPalette(true);
+          return true;
+        }
+        return false;
+      }
+    },
+    onUpdate: ({ editor: e }) => {
+      setInvalid("");
+      notify.current?.(snapshot(e.state.doc));
+    }
+  });
+  useImperativeHandle(
+    ref,
+    () => ({
+      getSnapshot: () => editor ? snapshot(editor.state.doc) : { format: "prism-research-source/1", blocks: initial.content?.length ?? 0, getSource: () => initialSource },
+      focus: () => {
+        editor?.commands.focus();
+      }
+    }),
+    [editor, initial, initialSource]
+  );
+  useEffect(() => {
+    editor?.setEditable(!readOnly, false);
+    if (readOnly) {
+      setPalette(false);
+      setDialog(void 0);
+    }
+  }, [editor, readOnly]);
+  const selection = useEditorState({
+    editor,
+    selector: ({ editor: e }) => e ? {
+      bold: e.isActive("bold"),
+      italic: e.isActive("italic"),
+      index: currentBlock(e)?.index ?? 0,
+      blocks: e.state.doc.childCount,
+      undo: e.can().undo(),
+      redo: e.can().redo()
+    } : null
+  });
+  const blockIndex = selection?.index ?? (editor ? currentBlock(editor)?.index : void 0) ?? 0;
+  const blockCount = selection?.blocks ?? editor?.state.doc.childCount ?? initial.content?.length ?? 1;
+  const recipes = useMemo(
+    () => [
+      { id: "text", label: labels.paragraph, source: "" },
+      { id: "heading", label: labels.heading, source: "## " },
+      { id: "list", label: labels.list, source: "- " },
+      { id: "ordered", label: labels.ordered, source: "1. " },
+      { id: "tasks", label: labels.tasks, source: "- [ ] " },
+      { id: "quote", label: labels.quote, source: "> " },
+      { id: "code", label: labels.code, source: "```\n\n```" },
+      { id: "equation", label: labels.equation, source: "$$\n\\placeholder{}\n$$" },
+      { id: "diagram", label: labels.diagram, source: "```mermaid\nflowchart LR\n  A[Source] --> B[Question]\n```" },
+      { id: "table", label: labels.table, source: "| A | B |\n| --- | --- |\n|  |  |" },
+      ...insertions
+    ],
+    [labels, insertions]
+  );
+  function insertInlineMath() {
+    if (!editor?.isEditable) return;
+    if (editor.state.selection instanceof NodeSelection && editor.state.selection.node.type.name === "mathInline")
+      return;
+    const tr = editor.state.tr.replaceSelectionWith(editor.schema.nodes.mathInline.create({ tex: "\\placeholder{}" }));
+    tr.setSelection(NodeSelection.create(tr.doc, tr.selection.from - 1));
+    editor.view.dispatch(tr.setMeta("prismMathEntry", "start"));
+  }
+  function applyDocument(source) {
+    if (!editor) return;
+    if (source.length > maxSourceLength) throw Error("document_limit");
+    const json = hydrateSource(source, editor.schema), doc = editor.schema.nodeFromJSON(json);
+    editor.view.dispatch(
+      editor.state.tr.replaceWith(0, editor.state.doc.content.size, doc.content).setDocAttribute("tail", doc.attrs.tail).scrollIntoView()
+    );
+  }
+  function insert(recipe) {
+    if (!editor?.isEditable) return;
+    const selected = currentBlock(editor), old = selected && editor.state.doc.child(selected.index);
+    const blocks = hydrateSource(recipe.source, editor.schema).content ?? [];
+    const simple = {
+      heading: { type: "heading", attrs: { level: 2 } },
+      list: { type: "bulletList", content: [{ type: "listItem", content: [{ type: "paragraph" }] }] },
+      ordered: { type: "orderedList", content: [{ type: "listItem", content: [{ type: "paragraph" }] }] },
+      tasks: {
+        type: "taskList",
+        content: [{ type: "taskItem", attrs: { checked: false }, content: [{ type: "paragraph" }] }]
+      },
+      quote: { type: "blockquote", content: [{ type: "paragraph" }] }
+    };
+    if (simple[recipe.id] && blocks[0]) {
+      blocks[0].content = [simple[recipe.id]];
+      blocks[0].attrs.baseline = "";
+    }
+    const empty = old?.childCount === 1 && old.firstChild?.type.name === "paragraph" && old.firstChild.content.size === 0;
+    const from = selected ? selected.pos + (empty ? 0 : old.nodeSize) : editor.state.doc.content.size;
+    const to = empty ? from + old.nodeSize : from;
+    const tr = editor.state.tr.replaceWith(
+      from,
+      to,
+      blocks.map((b) => editor.schema.nodeFromJSON(b))
+    );
+    const first = tr.doc.nodeAt(from)?.firstChild;
+    tr.setSelection(
+      first?.isAtom && !first.isTextblock ? NodeSelection.create(tr.doc, from + 1) : TextSelection.near(tr.doc.resolve(Math.min(from + 2, tr.doc.content.size)))
+    );
+    editor.view.dispatch(tr.scrollIntoView());
+    setPalette(false);
+    editor.commands.focus();
+  }
+  function openSource(id) {
+    if (!editor?.isEditable) return;
+    const block = id ? findBlock(editor.state.doc, id) : currentBlock(editor);
+    if (!block) return;
+    setDialog({ kind: "block", pos: block.pos, text: blockSource(editor.state.doc.child(block.index).toJSON()) });
+  }
+  function applyDialog(text) {
+    if (!editor?.isEditable || !dialog) return;
+    try {
+      if (dialog.kind === "document") applyDocument(text);
+      else if (dialog.kind === "block") {
+        const old = editor.state.doc.nodeAt(dialog.pos);
+        if (!old) throw Error("stale_selection");
+        const blocks = hydrateSource(text, editor.schema).content;
+        blocks[0].attrs = { ...blocks[0].attrs, id: old.attrs.id, prefix: old.attrs.prefix };
+        const tr = editor.state.tr.replaceWith(
+          dialog.pos,
+          dialog.pos + old.nodeSize,
+          blocks.map((b) => editor.schema.nodeFromJSON(b))
+        );
+        if (snapshot(tr.doc).getSource().length > maxSourceLength) throw Error("document_limit");
+        editor.view.dispatch(tr.scrollIntoView());
+      } else {
+        if (text && !/^(https?:\/\/|mailto:)/i.test(text)) throw Error("invalid_link");
+        const chain = editor.chain().focus().extendMarkRange("link");
+        if (text) chain.setLink({ href: text }).run();
+        else chain.unsetLink().run();
+      }
+      setDialog(void 0);
+      setInvalid("");
+      editor.commands.focus();
+    } catch {
+      setInvalid(labels.invalid);
+    }
+  }
+  const button = (label, action, disabled = false, pressed, icon) => /* @__PURE__ */ jsx(
+    Button2,
+    {
+      size: "small",
+      startIcon: icon,
+      variant: pressed ? "contained" : "text",
+      type: "button",
+      title: label,
+      "aria-label": label,
+      "aria-pressed": pressed,
+      disabled: readOnly || !editor || disabled,
+      onMouseDown: (e) => e.preventDefault(),
+      onClick: () => action(),
+      children: label
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: ["prism-science", className].filter(Boolean).join(" "),
+      sx: [
+        (theme) => ({
+          "--prism-editor-border": theme.palette.divider,
+          "--prism-editor-bg": theme.palette.background.paper,
+          "--prism-editor-muted": theme.palette.text.secondary,
+          "--prism-editor-accent": theme.palette.primary.main,
+          "--prism-editor-radius": `${theme.shape.borderRadius}px`
+        }),
+        ...Array.isArray(sx) ? sx : [sx]
+      ],
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "prism-science__toolbar", role: "toolbar", "aria-label": labels.editor, children: [
+          button(labels.insert, () => setPalette(true), false, void 0, /* @__PURE__ */ jsx(AddIcon, {})),
+          button(
+            labels.bold,
+            () => {
+              editor?.chain().focus().toggleBold().run();
+            },
+            false,
+            selection?.bold
+          ),
+          button(
+            labels.italic,
+            () => {
+              editor?.chain().focus().toggleItalic().run();
+            },
+            false,
+            selection?.italic
+          ),
+          button(labels.link, () => setDialog({ kind: "link", text: String(editor?.getAttributes("link").href ?? "") })),
+          button(labels.inlineMath, insertInlineMath),
+          button(
+            labels.undo,
+            () => {
+              editor?.chain().focus().undo().run();
+            },
+            !selection?.undo
+          ),
+          button(
+            labels.redo,
+            () => {
+              editor?.chain().focus().redo().run();
+            },
+            !selection?.redo
+          ),
+          button(labels.source, () => {
+            if (editor) setDialog({ kind: "document", text: snapshot(editor.state.doc).getSource() });
+          })
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "prism-science__hint", children: labels.hint }),
+        invalid && !dialog && /* @__PURE__ */ jsx("p", { role: "alert", children: invalid }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            ref: workspace,
+            className: `prism-science__workspace${blockControls ? " prism-science__workspace--controls" : ""}`,
+            children: [
+              /* @__PURE__ */ jsx(ResearchViewContext.Provider, { value: presentation, children: /* @__PURE__ */ jsx(ResearchMathContext.Provider, { value: { ...math2, readOnly }, children: /* @__PURE__ */ jsx(EditorContent, { editor, className: "prism-science__content" }) }) }),
+              editor && blockControls && /* @__PURE__ */ jsx(
+                BlockControls,
+                {
+                  editor,
+                  container: workspace,
+                  labels,
+                  readOnly,
+                  onSource: openSource,
+                  onInsert: (id) => {
+                    if (!editor.isEditable) return;
+                    const block = findBlock(editor.state.doc, id);
+                    if (block) {
+                      editor.commands.setNodeSelection(block.pos);
+                      setPalette(true);
+                    }
+                  }
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "prism-science__block-tools", role: "group", "aria-label": labels.editBlock, children: [
+          /* @__PURE__ */ jsxs("span", { "aria-live": "polite", "aria-atomic": "true", children: [
+            blockIndex + 1,
+            " / ",
+            blockCount,
+            " ",
+            labels.blocks
+          ] }),
+          button(labels.editBlock, openSource),
+          button(
+            labels.up,
+            () => {
+              if (editor) runBlockAction(editor, "up");
+            },
+            blockIndex === 0
+          ),
+          button(
+            labels.down,
+            () => {
+              if (editor) runBlockAction(editor, "down");
+            },
+            blockIndex === blockCount - 1
+          ),
+          button(labels.duplicate, () => {
+            if (editor) runBlockAction(editor, "duplicate");
+          }),
+          button(labels.remove, () => {
+            if (editor) runBlockAction(editor, "remove");
+          })
+        ] }),
+        /* @__PURE__ */ jsxs(Dialog, { open: palette, onClose: () => setPalette(false), fullWidth: true, maxWidth: "sm", children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: labels.insert }),
+          /* @__PURE__ */ jsx(DialogContent, { children: /* @__PURE__ */ jsx(
+            Autocomplete,
+            {
+              value: null,
+              openText: labels.insert,
+              closeText: labels.cancel,
+              options: recipes,
+              filterOptions: filterInsertions,
+              getOptionLabel: (r) => r.label,
+              onChange: (_e, value) => {
+                if (value) insert(value);
+              },
+              renderInput: (params) => /* @__PURE__ */ jsx(TextField2, { ...params, autoFocus: true, label: labels.search, margin: "dense" }),
+              openOnFocus: true,
+              disablePortal: true
+            }
+          ) }),
+          /* @__PURE__ */ jsx(DialogActions, { children: /* @__PURE__ */ jsx(Button2, { onClick: () => setPalette(false), children: labels.cancel }) })
+        ] }),
+        dialog && /* @__PURE__ */ jsx(
+          SourceDialog,
+          {
+            title: dialog.kind === "document" ? labels.source : dialog.kind === "link" ? labels.link : labels.editBlock,
+            initial: dialog.text,
+            maxLength: maxSourceLength,
+            labels,
+            error: invalid,
+            onCancel: () => {
+              setDialog(void 0);
+              setInvalid("");
+            },
+            onApply: applyDialog
+          },
+          `${dialog.kind}:${dialog.pos}`
+        )
+      ]
+    }
+  );
+}
+function SourceDialog({
+  title,
+  initial,
+  maxLength,
+  labels,
+  error,
+  onCancel,
+  onApply
+}) {
+  const [text, setText] = useState(initial);
+  return /* @__PURE__ */ jsxs(Dialog, { open: true, onClose: onCancel, fullWidth: true, maxWidth: "md", children: [
+    /* @__PURE__ */ jsx(DialogTitle, { children: title }),
+    /* @__PURE__ */ jsxs(DialogContent, { children: [
+      /* @__PURE__ */ jsx(
+        TextField2,
+        {
+          label: title,
+          value: text,
+          onChange: (e) => setText(e.target.value),
+          multiline: true,
+          minRows: 5,
+          maxRows: 20,
+          fullWidth: true,
+          autoFocus: true,
+          margin: "dense",
+          slotProps: { htmlInput: { maxLength, spellCheck: false } }
+        }
+      ),
+      error && /* @__PURE__ */ jsx("p", { role: "alert", children: error })
+    ] }),
+    /* @__PURE__ */ jsxs(DialogActions, { children: [
+      /* @__PURE__ */ jsx(Button2, { onClick: onCancel, children: labels.cancel }),
+      /* @__PURE__ */ jsx(Button2, { onClick: () => onApply(text), variant: "contained", children: labels.apply })
+    ] })
+  ] });
+}
+
+export { MathInput, ResearchEditor, defaultMathInputLabels, defaultResearchEditorLabels };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map