@moraya/core 0.1.0

package/dist/commands.js

@@ -0,0 +1,976 @@
+// src/commands.ts
+import {
+  toggleMark,
+  setBlockType,
+  wrapIn,
+  lift
+} from "prosemirror-commands";
+import { wrapInList, liftListItem } from "prosemirror-schema-list";
+
+// src/schema.ts
+import { Schema, Fragment } from "prosemirror-model";
+import katex from "katex";
+
+// src/types.ts
+var NULL_MEDIA_RESOLVER_SENTINEL = /* @__PURE__ */ Symbol("@moraya/core:null-media-resolver");
+
+// src/schema.ts
+function extractHtmlAttr(html, name) {
+  const re = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i");
+  const m = html.match(re);
+  return m ? m[1] ?? m[2] ?? m[3] ?? null : null;
+}
+function extractAllHtmlAttrs(html) {
+  const attrs = {};
+  const re = /([a-zA-Z_][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    const name = m[1];
+    if (!name) continue;
+    attrs[name.toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+  }
+  return attrs;
+}
+function showBrokenImage(container, sourceText) {
+  container.textContent = "";
+  container.className = (container.className.replace(/\bhtml-img-wrapper\b|\bimage-node\b/, "").trim() + " broken-image").trim();
+  const icon = document.createElement("span");
+  icon.className = "broken-image-icon";
+  container.appendChild(icon);
+  const code2 = document.createElement("code");
+  code2.className = "broken-image-src";
+  code2.textContent = sourceText;
+  container.appendChild(code2);
+}
+function htmlTagToStyle(openTag) {
+  const tagMatch = openTag.match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
+  if (!tagMatch || !tagMatch[1]) return "";
+  const tagName = tagMatch[1].toLowerCase();
+  switch (tagName) {
+    case "font": {
+      const parts = [];
+      const color = extractHtmlAttr(openTag, "color");
+      if (color) parts.push(`color: ${color}`);
+      const size = extractHtmlAttr(openTag, "size");
+      if (size) {
+        const sizeMap = {
+          "1": "0.63em",
+          "2": "0.82em",
+          "3": "1em",
+          "4": "1.13em",
+          "5": "1.5em",
+          "6": "2em",
+          "7": "3em"
+        };
+        parts.push(`font-size: ${sizeMap[size] || size}`);
+      }
+      const face = extractHtmlAttr(openTag, "face");
+      if (face) parts.push(`font-family: ${face}`);
+      return parts.join("; ");
+    }
+    case "span":
+    case "div":
+      return extractHtmlAttr(openTag, "style") || "";
+    default:
+      return "";
+  }
+}
+var documentBaseDir = "";
+function isAbsoluteFilePath(src) {
+  if (!src) return false;
+  if (src.startsWith("/") && !src.startsWith("//")) return true;
+  if (/^[A-Z]:[\\/]/i.test(src)) return true;
+  return false;
+}
+function isRelativePath(src) {
+  if (!src) return false;
+  if (/^(https?:|data:|blob:|javascript:|vbscript:|tauri:|\/\/)/i.test(src)) return false;
+  if (src.startsWith("/") || /^[A-Z]:[\\/]/i.test(src)) return false;
+  return true;
+}
+function resolveRelativePath(src) {
+  if (!documentBaseDir) return src;
+  let rel = src.replace(/^\.\//, "");
+  const sep = documentBaseDir.includes("\\") ? "\\" : "/";
+  let base = documentBaseDir.endsWith(sep) ? documentBaseDir.slice(0, -1) : documentBaseDir;
+  while (rel.startsWith("../") || rel.startsWith("..\\")) {
+    rel = rel.slice(3);
+    const lastSep = base.lastIndexOf(sep);
+    if (lastSep > 0) base = base.slice(0, lastSep);
+  }
+  return `${base}${sep}${rel}`;
+}
+function loadLocalImageSrc(img, src, mediaResolver) {
+  let path;
+  try {
+    path = decodeURIComponent(src);
+  } catch {
+    path = src;
+  }
+  mediaResolver.loadLocalImage(path).then((url) => {
+    if (url) img.src = url;
+    else img.dispatchEvent(new Event("error"));
+  }).catch(() => {
+    img.dispatchEvent(new Event("error"));
+  });
+}
+function setMediaSrc(el, src, mediaResolver) {
+  if (isAbsoluteFilePath(src)) {
+    mediaResolver.loadLocalMedia(src).then((url) => {
+      if (!url) return;
+      el.src = url;
+      if (el instanceof HTMLMediaElement) el.load();
+    }).catch(() => {
+    });
+  } else if (isRelativePath(src)) {
+    mediaResolver.loadLocalMedia(resolveRelativePath(src)).then((url) => {
+      if (!url) return;
+      el.src = url;
+      if (el instanceof HTMLMediaElement) el.load();
+    }).catch(() => {
+    });
+  } else if (/^https?:\/\//i.test(src)) {
+    if (el instanceof HTMLVideoElement) {
+      el.src = src;
+      el.load();
+    } else {
+      mediaResolver.loadRemoteMedia(src).then((url) => {
+        if (!url) return;
+        el.src = url;
+        if (el instanceof HTMLMediaElement) el.load();
+      }).catch(() => {
+      });
+    }
+  } else {
+    el.src = src;
+  }
+}
+function createMediaElement(tagName, value, mediaResolver) {
+  const wrapper = document.createElement("span");
+  wrapper.dataset.type = "html-inline";
+  wrapper.dataset.value = value;
+  wrapper.className = "html-media-wrapper";
+  wrapper.contentEditable = "false";
+  const el = document.createElement(tagName);
+  const stopForControls = (ev) => ev.stopPropagation();
+  el.addEventListener("mousedown", stopForControls);
+  el.addEventListener("click", stopForControls);
+  el.addEventListener("pointerdown", stopForControls);
+  const openTagMatch = value.match(new RegExp(`^<${tagName}\\b[^>]*>`, "i"));
+  const openTag = openTagMatch ? openTagMatch[0] : "";
+  const attrs = extractAllHtmlAttrs(openTag);
+  for (const [key, val] of Object.entries(attrs)) {
+    if (key === "src") continue;
+    if (key.startsWith("on")) continue;
+    el.setAttribute(key, val);
+  }
+  const strippedTag = openTag.replace(/=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/g, "");
+  const boolAttrs = ["controls", "autoplay", "loop", "muted", "playsinline"];
+  for (const attr of boolAttrs) {
+    if (!(attr in attrs) && new RegExp(`\\b${attr}\\b`, "i").test(strippedTag)) {
+      el.setAttribute(attr, "");
+    }
+  }
+  if (tagName === "audio" && !attrs.preload) {
+    el.setAttribute("preload", "auto");
+  }
+  const sourceRe = /<source\b[^>]*\/?>/gi;
+  let srcMatch;
+  while ((srcMatch = sourceRe.exec(value)) !== null) {
+    const srcAttrs = extractAllHtmlAttrs(srcMatch[0]);
+    if (!srcAttrs.src) continue;
+    const source = document.createElement("source");
+    if (srcAttrs.type) source.type = srcAttrs.type;
+    setMediaSrc(source, srcAttrs.src, mediaResolver);
+    el.appendChild(source);
+  }
+  if (attrs.src) {
+    setMediaSrc(el, attrs.src, mediaResolver);
+  }
+  wrapper.appendChild(el);
+  return wrapper;
+}
+var doc = {
+  content: "block+"
+};
+var text = { group: "inline" };
+var paragraph = {
+  content: "inline*",
+  group: "block",
+  parseDOM: [{ tag: "p" }],
+  toDOM() {
+    return ["p", 0];
+  }
+};
+var heading = {
+  attrs: {
+    id: { default: "" },
+    level: { default: 1 }
+  },
+  content: "inline*",
+  group: "block",
+  defining: true,
+  parseDOM: [1, 2, 3, 4, 5, 6].map((level) => ({
+    tag: `h${level}`,
+    getAttrs(dom) {
+      return { level, id: dom.getAttribute("id") || "" };
+    }
+  })),
+  toDOM(node) {
+    const attrs = {};
+    if (node.attrs.id) attrs.id = node.attrs.id;
+    return [`h${node.attrs.level}`, attrs, 0];
+  }
+};
+var blockquote = {
+  content: "block+",
+  group: "block",
+  defining: true,
+  parseDOM: [{ tag: "blockquote" }],
+  toDOM() {
+    return ["blockquote", 0];
+  }
+};
+var code_block = {
+  content: "text*",
+  group: "block",
+  marks: "",
+  defining: true,
+  code: true,
+  attrs: {
+    language: { default: "text" }
+  },
+  parseDOM: [{
+    tag: "pre",
+    preserveWhitespace: "full",
+    getAttrs(dom) {
+      return { language: dom.dataset.language || "text" };
+    }
+  }],
+  toDOM(node) {
+    return ["pre", { "data-language": node.attrs.language || void 0 }, ["code", 0]];
+  }
+};
+var horizontal_rule = {
+  group: "block",
+  parseDOM: [{ tag: "hr" }],
+  toDOM() {
+    return ["hr"];
+  }
+};
+var bullet_list = {
+  content: "list_item+",
+  group: "block",
+  parseDOM: [{ tag: "ul" }],
+  toDOM() {
+    return ["ul", 0];
+  }
+};
+var ordered_list = {
+  content: "list_item+",
+  group: "block",
+  attrs: {
+    order: { default: 1 }
+  },
+  parseDOM: [{
+    tag: "ol",
+    getAttrs(dom) {
+      return { order: dom.hasAttribute("start") ? +(dom.getAttribute("start") || 1) : 1 };
+    }
+  }],
+  toDOM(node) {
+    return node.attrs.order === 1 ? ["ol", 0] : ["ol", { start: node.attrs.order }, 0];
+  }
+};
+var list_item = {
+  content: "paragraph block*",
+  group: "listItem",
+  defining: true,
+  attrs: {
+    label: { default: "\u2022" },
+    listType: { default: "bullet" },
+    spread: { default: "true" },
+    checked: { default: null }
+  },
+  parseDOM: [
+    {
+      tag: 'li[data-item-type="task"]',
+      getAttrs(dom) {
+        return {
+          label: dom.dataset.label,
+          listType: dom.dataset.listType,
+          spread: dom.dataset.spread,
+          checked: dom.dataset.checked ? dom.dataset.checked === "true" : null
+        };
+      }
+    },
+    {
+      tag: "li",
+      getAttrs(dom) {
+        return {
+          label: dom.dataset.label || "\u2022",
+          listType: dom.dataset.listType || "bullet",
+          spread: dom.dataset.spread || "true"
+        };
+      }
+    }
+  ],
+  toDOM(node) {
+    if (node.attrs.checked != null) {
+      return ["li", {
+        "data-item-type": "task",
+        "data-label": node.attrs.label,
+        "data-list-type": node.attrs.listType,
+        "data-spread": node.attrs.spread,
+        "data-checked": String(node.attrs.checked)
+      }, 0];
+    }
+    return ["li", {
+      "data-label": node.attrs.label,
+      "data-list-type": node.attrs.listType,
+      "data-spread": node.attrs.spread
+    }, 0];
+  }
+};
+var hardbreak = {
+  inline: true,
+  group: "inline",
+  selectable: false,
+  attrs: {
+    isInline: { default: false }
+  },
+  parseDOM: [
+    { tag: "br" },
+    {
+      tag: 'span[data-type="hardbreak"]',
+      getAttrs() {
+        return { isInline: true };
+      }
+    }
+  ],
+  toDOM() {
+    return ["span", { "data-type": "hardbreak", "class": "hardbreak-marker" }, "\n"];
+  },
+  leafText() {
+    return "\n";
+  }
+};
+var html_block = {
+  content: "text*",
+  group: "block",
+  marks: "",
+  code: true,
+  defining: true,
+  parseDOM: [{
+    tag: 'div[data-type="html"]',
+    preserveWhitespace: "full"
+  }],
+  toDOM() {
+    return ["div", { "data-type": "html" }, ["pre", 0]];
+  }
+};
+var table = {
+  content: "table_header_row table_row+",
+  group: "block",
+  tableRole: "table",
+  isolating: true,
+  parseDOM: [{ tag: "table" }],
+  toDOM() {
+    return ["table", ["tbody", 0]];
+  }
+};
+var table_header_row = {
+  content: "(table_header)*",
+  tableRole: "row",
+  parseDOM: [
+    { tag: "tr[data-is-header]" },
+    {
+      tag: "tr",
+      getAttrs(dom) {
+        const hasHeader = dom.querySelector("th");
+        return hasHeader ? {} : false;
+      }
+    }
+  ],
+  toDOM() {
+    return ["tr", { "data-is-header": "true" }, 0];
+  }
+};
+var table_row = {
+  content: "(table_cell)*",
+  tableRole: "row",
+  parseDOM: [{ tag: "tr" }],
+  toDOM() {
+    return ["tr", 0];
+  }
+};
+var table_header = {
+  content: "paragraph+",
+  tableRole: "header_cell",
+  attrs: {
+    alignment: { default: "left" },
+    colspan: { default: 1 },
+    rowspan: { default: 1 },
+    colwidth: { default: null }
+  },
+  isolating: true,
+  parseDOM: [{
+    tag: "th",
+    getAttrs(dom) {
+      return {
+        alignment: dom.style.textAlign || "left",
+        colspan: Number(dom.getAttribute("colspan") || 1),
+        rowspan: Number(dom.getAttribute("rowspan") || 1),
+        colwidth: null
+      };
+    }
+  }],
+  toDOM(node) {
+    return ["th", { style: `text-align: ${node.attrs.alignment || "left"}` }, 0];
+  }
+};
+var table_cell = {
+  content: "paragraph+",
+  tableRole: "cell",
+  attrs: {
+    alignment: { default: "left" },
+    colspan: { default: 1 },
+    rowspan: { default: 1 },
+    colwidth: { default: null }
+  },
+  isolating: true,
+  parseDOM: [{
+    tag: "td",
+    getAttrs(dom) {
+      return {
+        alignment: dom.style.textAlign || "left",
+        colspan: Number(dom.getAttribute("colspan") || 1),
+        rowspan: Number(dom.getAttribute("rowspan") || 1),
+        colwidth: null
+      };
+    }
+  }],
+  toDOM(node) {
+    return ["td", { style: `text-align: ${node.attrs.alignment || "left"}` }, 0];
+  }
+};
+var math_inline = {
+  group: "inline",
+  content: "text*",
+  inline: true,
+  atom: true,
+  parseDOM: [{
+    tag: 'span[data-type="math_inline"]',
+    getContent(dom, schema2) {
+      if (!(dom instanceof HTMLElement)) return Fragment.empty;
+      const value = dom.dataset.value ?? "";
+      if (!value) return Fragment.empty;
+      return Fragment.from(schema2.text(value));
+    }
+  }],
+  toDOM(node) {
+    const code2 = node.textContent;
+    const dom = document.createElement("span");
+    dom.dataset.type = "math_inline";
+    dom.dataset.value = code2;
+    try {
+      katex.render(code2, dom);
+    } catch {
+      dom.textContent = code2;
+      dom.classList.add("math-error");
+      dom.setAttribute("data-math-type", "inline");
+    }
+    return dom;
+  }
+};
+var math_block = {
+  content: "text*",
+  group: "block",
+  marks: "",
+  defining: true,
+  atom: true,
+  isolating: true,
+  attrs: {
+    value: { default: "" }
+  },
+  parseDOM: [{
+    tag: 'div[data-type="math_block"]',
+    preserveWhitespace: "full",
+    getAttrs(dom) {
+      return { value: dom.dataset.value ?? "" };
+    }
+  }],
+  toDOM(node) {
+    const code2 = node.attrs.value;
+    const dom = document.createElement("div");
+    dom.dataset.type = "math_block";
+    dom.dataset.value = code2;
+    try {
+      katex.render(code2, dom, { displayMode: true });
+    } catch {
+      dom.textContent = code2;
+      dom.classList.add("math-error");
+      dom.setAttribute("data-math-type", "block");
+    }
+    return dom;
+  }
+};
+var defList = {
+  content: "(defListTerm | defListDescription)+",
+  group: "block",
+  defining: true,
+  parseDOM: [{ tag: "dl" }],
+  toDOM() {
+    return ["dl", { class: "definition-list" }, 0];
+  }
+};
+var defListTerm = {
+  content: "inline*",
+  group: "block",
+  defining: true,
+  parseDOM: [{ tag: "dt" }],
+  toDOM() {
+    return ["dt", 0];
+  }
+};
+var defListDescription = {
+  content: "block+",
+  group: "block",
+  defining: true,
+  parseDOM: [{ tag: "dd" }],
+  toDOM() {
+    return ["dd", 0];
+  }
+};
+var strong = {
+  parseDOM: [
+    {
+      tag: "b",
+      getAttrs(dom) {
+        return dom.style.fontWeight !== "normal" && null;
+      }
+    },
+    { tag: "strong" },
+    {
+      style: "font-weight",
+      getAttrs(value) {
+        return /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
+      }
+    }
+  ],
+  toDOM() {
+    return ["strong", 0];
+  }
+};
+var em = {
+  parseDOM: [
+    { tag: "i" },
+    { tag: "em" },
+    {
+      style: "font-style",
+      getAttrs(value) {
+        return value === "italic" && null;
+      }
+    }
+  ],
+  toDOM() {
+    return ["em", 0];
+  }
+};
+var code = {
+  priority: 100,
+  code: true,
+  inclusive: false,
+  parseDOM: [{ tag: "code" }],
+  toDOM() {
+    return ["code", 0];
+  }
+};
+var link = {
+  attrs: {
+    href: {},
+    title: { default: null }
+  },
+  inclusive: false,
+  parseDOM: [{
+    tag: "a[href]",
+    getAttrs(dom) {
+      return {
+        href: dom.getAttribute("href"),
+        title: dom.getAttribute("title")
+      };
+    }
+  }],
+  toDOM(mark) {
+    const attrs = { href: mark.attrs.href };
+    if (mark.attrs.title) attrs.title = mark.attrs.title;
+    return ["a", attrs, 0];
+  }
+};
+var strike_through = {
+  parseDOM: [
+    { tag: "del" },
+    { tag: "s" },
+    {
+      style: "text-decoration",
+      getAttrs(value) {
+        return value === "line-through" && null;
+      }
+    }
+  ],
+  toDOM() {
+    return ["del", 0];
+  }
+};
+var html_mark = {
+  attrs: {
+    openTag: { default: "" },
+    closeTag: { default: "" }
+  },
+  excludes: "",
+  // Allow nesting multiple html_marks (e.g., <font><u>text</u></font>)
+  parseDOM: [{
+    tag: '[data-type="html-mark"]',
+    getAttrs(dom) {
+      return {
+        openTag: dom.dataset.openTag ?? "",
+        closeTag: dom.dataset.closeTag ?? ""
+      };
+    }
+  }],
+  toDOM(mark) {
+    const openTag = mark.attrs.openTag;
+    const tagMatch = openTag.match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
+    const tagName = tagMatch && tagMatch[1] ? tagMatch[1].toLowerCase() : "span";
+    const attrs = {
+      "data-type": "html-mark",
+      "data-open-tag": openTag,
+      "data-close-tag": mark.attrs.closeTag
+    };
+    const semanticTags = ["sub", "sup", "u", "ins", "mark", "small", "big", "kbd", "abbr"];
+    if (semanticTags.includes(tagName)) {
+      return [tagName, attrs, 0];
+    }
+    const style = htmlTagToStyle(openTag);
+    if (style) attrs.style = style;
+    return ["span", attrs, 0];
+  }
+};
+function buildImageNodeSpec(mediaResolver) {
+  return {
+    inline: true,
+    group: "inline",
+    selectable: true,
+    draggable: true,
+    marks: "",
+    atom: true,
+    defining: true,
+    isolating: true,
+    attrs: {
+      src: { default: "" },
+      alt: { default: "" },
+      title: { default: "" }
+    },
+    parseDOM: [{
+      tag: "img[src]",
+      getAttrs(dom) {
+        return {
+          src: dom.getAttribute("src") || "",
+          alt: dom.getAttribute("alt") || "",
+          title: dom.getAttribute("title") || dom.getAttribute("alt") || ""
+        };
+      }
+    }],
+    toDOM(node) {
+      const container = document.createElement("span");
+      container.className = "image-node";
+      const img = document.createElement("img");
+      if (node.attrs.alt) img.alt = node.attrs.alt;
+      if (node.attrs.title) img.title = node.attrs.title;
+      const titleStr = node.attrs.title || "";
+      const widthMatch = titleStr.match(/^width=(\d+%?)$/);
+      const widthVal = widthMatch?.[1];
+      if (widthVal) {
+        img.style.width = widthVal.includes("%") ? widthVal : `${widthVal}px`;
+        img.style.maxWidth = "none";
+      }
+      img.onerror = () => {
+        const alt = node.attrs.alt ? `![${node.attrs.alt}]` : "![]";
+        const title = node.attrs.title ? ` "${node.attrs.title}"` : "";
+        showBrokenImage(container, `${alt}(${node.attrs.src}${title})`);
+      };
+      const src = node.attrs.src;
+      if (isAbsoluteFilePath(src)) {
+        loadLocalImageSrc(img, src, mediaResolver);
+      } else if (isRelativePath(src)) {
+        loadLocalImageSrc(img, resolveRelativePath(src), mediaResolver);
+      } else {
+        img.src = src;
+      }
+      container.appendChild(img);
+      return container;
+    }
+  };
+}
+function buildHtmlInlineNodeSpec(mediaResolver) {
+  return {
+    group: "inline",
+    inline: true,
+    atom: true,
+    attrs: {
+      value: { default: "" }
+    },
+    parseDOM: [{
+      tag: 'span[data-type="html-inline"]',
+      getAttrs(dom) {
+        return { value: dom.dataset.value ?? "" };
+      }
+    }],
+    toDOM(node) {
+      const value = node.attrs.value;
+      if (/^<img\s/i.test(value)) {
+        const wrapper = document.createElement("span");
+        wrapper.dataset.type = "html-inline";
+        wrapper.dataset.value = value;
+        wrapper.className = "html-img-wrapper";
+        const attrs = extractAllHtmlAttrs(value);
+        const src = attrs.src || "";
+        if (src) {
+          const img = document.createElement("img");
+          for (const [key, val] of Object.entries(attrs)) {
+            if (key === "src") continue;
+            if (key === "onerror" || key === "onload" || key.startsWith("on")) continue;
+            img.setAttribute(key, val);
+          }
+          img.onerror = () => {
+            showBrokenImage(wrapper, value);
+          };
+          if (isAbsoluteFilePath(src)) {
+            loadLocalImageSrc(img, src, mediaResolver);
+          } else if (isRelativePath(src)) {
+            loadLocalImageSrc(img, resolveRelativePath(src), mediaResolver);
+          } else {
+            img.src = src;
+          }
+          wrapper.appendChild(img);
+        } else {
+          showBrokenImage(wrapper, value);
+        }
+        return wrapper;
+      }
+      if (/^<video\b/i.test(value)) return createMediaElement("video", value, mediaResolver);
+      if (/^<audio\b/i.test(value)) return createMediaElement("audio", value, mediaResolver);
+      return ["span", { "data-type": "html-inline", "data-value": value }];
+    }
+  };
+}
+function buildNodes(mediaResolver) {
+  return {
+    doc,
+    text,
+    paragraph,
+    heading,
+    blockquote,
+    code_block,
+    horizontal_rule,
+    bullet_list,
+    ordered_list,
+    list_item,
+    image: buildImageNodeSpec(mediaResolver),
+    hardbreak,
+    html_block,
+    html_inline: buildHtmlInlineNodeSpec(mediaResolver),
+    table,
+    table_header_row,
+    table_row,
+    table_header,
+    table_cell,
+    math_inline,
+    math_block,
+    defList,
+    defListTerm,
+    defListDescription
+  };
+}
+var marks = {
+  html_mark,
+  strong,
+  em,
+  code,
+  link,
+  strike_through
+};
+var nullMediaResolver = {
+  [NULL_MEDIA_RESOLVER_SENTINEL]: true,
+  async loadLocalImage() {
+    return "";
+  },
+  async loadLocalMedia() {
+    return "";
+  },
+  async loadRemoteMedia(url) {
+    return url;
+  }
+};
+var defaultSchema = new Schema({
+  nodes: buildNodes(nullMediaResolver),
+  marks
+});
+
+// src/commands.ts
+var schema = defaultSchema;
+function markType(name) {
+  const m = schema.marks[name];
+  if (!m) throw new Error(`[@moraya/core] mark "${name}" not in schema`);
+  return m;
+}
+function nodeType(name) {
+  const n = schema.nodes[name];
+  if (!n) throw new Error(`[@moraya/core] node "${name}" not in schema`);
+  return n;
+}
+var toggleBold = (state, dispatch) => toggleMark(markType("strong"))(state, dispatch);
+var toggleItalic = (state, dispatch) => toggleMark(markType("em"))(state, dispatch);
+var toggleStrikethrough = (state, dispatch) => toggleMark(markType("strike_through"))(state, dispatch);
+var toggleCode = (state, dispatch) => toggleMark(markType("code"))(state, dispatch);
+function setHeading(level) {
+  return (state, dispatch) => setBlockType(nodeType("heading"), { level })(state, dispatch);
+}
+var toggleBlockquote = (state, dispatch) => {
+  const $from = state.selection.$from;
+  for (let d = $from.depth; d > 0; d--) {
+    if ($from.node(d).type.name === "blockquote") {
+      return lift(state, dispatch);
+    }
+  }
+  return wrapIn(nodeType("blockquote"))(state, dispatch);
+};
+var toggleOrderedList = (state, dispatch) => wrapInList(nodeType("ordered_list"))(state, dispatch);
+var toggleBulletList = (state, dispatch) => wrapInList(nodeType("bullet_list"))(state, dispatch);
+function makeToggleList(typeName) {
+  return (state, dispatch, view) => {
+    const listType = state.schema.nodes[typeName];
+    const listItemType = state.schema.nodes.list_item;
+    if (!listType || !listItemType) return false;
+    const { $from } = state.selection;
+    for (let d = $from.depth; d >= 0; d--) {
+      if ($from.node(d).type === listType) {
+        return liftListItem(listItemType)(state, dispatch, view);
+      }
+    }
+    return wrapInList(listType)(state, dispatch, view);
+  };
+}
+var wrapInBulletList = makeToggleList("bullet_list");
+var wrapInOrderedList = makeToggleList("ordered_list");
+var wrapInTaskList = (state, dispatch) => {
+  const bulletListType = state.schema.nodes.bullet_list;
+  const listItemType = state.schema.nodes.list_item;
+  if (!bulletListType || !listItemType) return false;
+  if (!wrapInList(bulletListType)(state)) return false;
+  if (!dispatch) return true;
+  let listTr;
+  wrapInList(bulletListType)(state, (tr) => {
+    listTr = tr;
+  });
+  if (!listTr) return false;
+  const { from, to } = listTr.selection;
+  const updates = [];
+  listTr.doc.nodesBetween(
+    Math.max(0, from - 200),
+    Math.min(listTr.doc.content.size, to + 200),
+    (node, pos) => {
+      if (node.type === listItemType && node.attrs.checked === null) {
+        updates.push({ pos, attrs: { ...node.attrs, checked: false } });
+      }
+    }
+  );
+  for (let i = updates.length - 1; i >= 0; i--) {
+    const u = updates[i];
+    listTr.setNodeMarkup(u.pos, void 0, u.attrs);
+  }
+  dispatch(listTr.scrollIntoView());
+  return true;
+};
+var toggleCodeBlock = (state, dispatch) => {
+  const cb = nodeType("code_block");
+  if (state.selection.$from.parent.type === cb) {
+    return setBlockType(nodeType("paragraph"))(state, dispatch);
+  }
+  return setBlockType(cb)(state, dispatch);
+};
+var insertHorizontalRule = (state, dispatch) => {
+  if (dispatch) {
+    dispatch(state.tr.replaceSelectionWith(nodeType("horizontal_rule").create()));
+  }
+  return true;
+};
+var insertTable = (state, dispatch) => {
+  const tableType = schema.nodes.table;
+  if (!tableType) {
+    if (dispatch) {
+      const text2 = "\n\n| Col 1 | Col 2 | Col 3 |\n|---|---|---|\n|   |   |   |\n|   |   |   |\n\n";
+      dispatch(state.tr.insertText(text2));
+    }
+    return true;
+  }
+  return false;
+};
+var insertMathBlock = (state, dispatch) => {
+  const mathBlock = schema.nodes.math_block;
+  if (!mathBlock) {
+    if (dispatch) {
+      dispatch(state.tr.insertText("\n$$\n\\\n$$\n"));
+    }
+    return true;
+  }
+  if (dispatch) {
+    const node = mathBlock.create({ value: "" });
+    dispatch(state.tr.replaceSelectionWith(node));
+  }
+  return true;
+};
+function toggleLink(href) {
+  return (state, dispatch) => {
+    const link2 = markType("link");
+    const { from, to } = state.selection;
+    if (state.doc.rangeHasMark(from, to, link2)) {
+      if (dispatch) dispatch(state.tr.removeMark(from, to, link2));
+      return true;
+    }
+    if (!href) return false;
+    if (dispatch) {
+      dispatch(state.tr.addMark(from, to, link2.create({ href })));
+    }
+    return true;
+  };
+}
+function insertImage(src, alt) {
+  return (state, dispatch) => {
+    const img = nodeType("image").create({ src, alt: alt ?? null });
+    if (dispatch) {
+      dispatch(state.tr.replaceSelectionWith(img));
+    }
+    return true;
+  };
+}
+export {
+  insertHorizontalRule,
+  insertImage,
+  insertMathBlock,
+  insertTable,
+  setHeading,
+  toggleBlockquote,
+  toggleBold,
+  toggleBulletList,
+  toggleCode,
+  toggleCodeBlock,
+  toggleItalic,
+  toggleLink,
+  toggleOrderedList,
+  toggleStrikethrough,
+  wrapInBulletList,
+  wrapInOrderedList,
+  wrapInTaskList
+};
+//# sourceMappingURL=commands.js.map