@reiwuzen/blocky 1.1.2 → 1.3.0

package/dist/index.js

@@ -1,16 +1,910 @@
-// ─── Content ───────────────────────────────────────────────────────────────────
-export { insertAt, deleteLastChar, deleteRange, replaceRange, splitBlock, mergeBlocks } from "./engine/content";
-// ─── Format ────────────────────────────────────────────────────────────────────
-export { formatNodes, toggleBold, toggleItalic, toggleUnderline, toggleStrikethrough, toggleHighlight, toggleColor, setLink, removeLink, mergeAdjacentNodes } from "./engine/format";
-// ─── Transform ─────────────────────────────────────────────────────────────────
-export { applyMarkdownTransform, changeBlockType, toggleTodo, indentBlock, outdentBlock } from "./engine/transform";
-// ─── Serializer ────────────────────────────────────────────────────────────────
-export { serialize, deserialize, serializeNodes, deserializeNodes, toPlainText, toMarkdown } from "./engine/serializer";
-// ─── Cursor ───────────────────────────────────────────────────────────────────
-export { flatToPosition, flatToSelection, positionToFlat, } from './engine/cursor';
-// ─── History ───────────────────────────────────────────────────────────────────
-export { createHistory, push, undo, redo, canUndo, canRedo, currentBlocks } from "./engine/history";
-// ─── Utils ─────────────────────────────────────────────────────────────────────
-export { generateId, createBlock, insertBlockAfter, deleteBlock, duplicateBlock, moveBlock } from "./utils/block";
-export { blockDeleteLastChar, blockDeleteRange, blockInsertAt, blockReplaceRange } from './engine/block';
-//# sourceMappingURL=index.js.map
+// src/utils/block.ts
+import { Result } from "@reiwuzen/result";
+import { v7 } from "uuid";
+function generateId(fn) {
+  return fn ? fn() : v7();
+}
+var defaultContent = {
+  paragraph: [],
+  heading1: [],
+  heading2: [],
+  heading3: [],
+  bullet: [],
+  number: [],
+  todo: [],
+  code: [{ type: "code", text: "" }],
+  equation: [{ type: "equation", latex: "" }]
+};
+var defaultMeta = {
+  paragraph: {},
+  heading1: {},
+  heading2: {},
+  heading3: {},
+  bullet: { depth: 0 },
+  number: { depth: 0 },
+  todo: { depth: 0 },
+  code: {},
+  equation: {}
+};
+function createBlock(type, idFn) {
+  return Result.try(() => {
+    const block = {
+      id: generateId(idFn),
+      type,
+      meta: defaultMeta[type],
+      content: defaultContent[type]
+    };
+    return block;
+  });
+}
+function createBlockAfter(blocks, afterId, type, idFn) {
+  return createBlock(type, idFn).andThen((newBlock) => {
+    const index = blocks.findIndex((b) => b.id === afterId);
+    if (index === -1) return Result.Err(`[BlockNotFound]: ${afterId}`);
+    const next = [...blocks];
+    next.splice(index + 1, 0, newBlock);
+    return Result.Ok({ blocks: next, newId: newBlock.id });
+  });
+}
+function insertBlockAfter(blocks, afterId, insertBlock) {
+  const targetBlockIndex = blocks.findIndex((b) => b.id === afterId);
+  if (targetBlockIndex === -1) {
+    return Result.Err(`No block found with id: ${afterId}`);
+  }
+  const newBlocks = [
+    ...blocks.slice(0, targetBlockIndex + 1),
+    insertBlock,
+    ...blocks.slice(targetBlockIndex + 1)
+  ];
+  return Result.Ok({
+    blocks: newBlocks,
+    newFocusId: insertBlock.id
+  });
+}
+function deleteBlock(blocks, id) {
+  const index = blocks.findIndex((b) => b.id === id);
+  const prevId = blocks[index - 1]?.id ?? blocks[index + 1]?.id ?? "";
+  return { blocks: blocks.filter((b) => b.id !== id), prevId };
+}
+function duplicateBlock(incoming, newId = crypto.randomUUID()) {
+  return {
+    ...incoming,
+    id: newId,
+    meta: { ...incoming.meta },
+    content: incoming.content.map((node) => ({ ...node }))
+  };
+}
+function duplicateBlockAfter(blocks, id, newId) {
+  const targetBlock = blocks.find((b) => b.id === id);
+  if (targetBlock == null) return Result.Err(`[BlockNotFound]: ${id}`);
+  const dup = duplicateBlock(targetBlock, newId);
+  return insertBlockAfter(blocks, id, dup);
+}
+function moveBlock(blocks, id, direction) {
+  const index = blocks.findIndex((b) => b.id === id);
+  if (index === -1)
+    return Result.Err(`Block with id "${id}" not found`);
+  if (direction === "up" && index === 0)
+    return Result.Ok([...blocks]);
+  if (direction === "down" && index === blocks.length - 1)
+    return Result.Ok([...blocks]);
+  const next = [...blocks];
+  const swapIndex = direction === "up" ? index - 1 : index + 1;
+  [next[index], next[swapIndex]] = [next[swapIndex], next[index]];
+  return Result.Ok(next);
+}
+
+// src/engine/content.ts
+import { Result as Result3 } from "@reiwuzen/result";
+
+// src/engine/format.ts
+import { Result as Result2 } from "@reiwuzen/result";
+function validateSelection(nodes, sel) {
+  const { startIndex, startOffset, endIndex, endOffset } = sel;
+  if (startIndex < 0 || endIndex >= nodes.length)
+    return Result2.Err(
+      `indices [${startIndex}, ${endIndex}] out of bounds (length=${nodes.length})`
+    );
+  if (startIndex > endIndex)
+    return Result2.Err(`startIndex (${startIndex}) > endIndex (${endIndex})`);
+  const startNode = nodes[startIndex];
+  const endNode = nodes[endIndex];
+  if (!isTextNode(startNode) || !isTextNode(endNode))
+    return Result2.Err(`Selection must start and end on a text node`);
+  if (startOffset < 0 || startOffset > startNode.text.length)
+    return Result2.Err(
+      `startOffset (${startOffset}) out of bounds for "${startNode.text}"`
+    );
+  if (endOffset < 0 || endOffset > endNode.text.length)
+    return Result2.Err(
+      `endOffset (${endOffset}) out of bounds for "${endNode.text}"`
+    );
+  if (startIndex === endIndex && startOffset >= endOffset)
+    return Result2.Err(
+      `startOffset (${startOffset}) must be < endOffset (${endOffset}) within same node`
+    );
+  if (!nodes.slice(startIndex, endIndex + 1).every(isTextNode))
+    return Result2.Err(`Selection contains non-text nodes (code/equation)`);
+  return Result2.Ok(void 0);
+}
+function isTextNode(node) {
+  return node.type === "text";
+}
+function isFormatActive(nodes, sel, format, value = true) {
+  return nodes.slice(sel.startIndex, sel.endIndex + 1).every((n) => n[format] === value);
+}
+function applyFormat(node, format, value, remove) {
+  const next = { ...node };
+  if (remove) {
+    delete next[format];
+  } else {
+    next[format] = value;
+  }
+  return next;
+}
+function splitNode(node, start, end, format, value, remove) {
+  const parts = [];
+  if (start > 0)
+    parts.push({ ...node, text: node.text.slice(0, start) });
+  parts.push(
+    applyFormat({ ...node, text: node.text.slice(start, end) }, format, value, remove)
+  );
+  if (end < node.text.length)
+    parts.push({ ...node, text: node.text.slice(end) });
+  return parts;
+}
+function formatNodes(nodes, sel, format, value = true) {
+  return validateSelection(nodes, sel).map(() => {
+    const { startIndex, startOffset, endIndex, endOffset } = sel;
+    const textNodes = nodes;
+    const remove = isFormatActive(textNodes, sel, format, value);
+    const result = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (i < startIndex || i > endIndex) {
+        result.push(node);
+        continue;
+      }
+      if (!isTextNode(node)) {
+        result.push(node);
+        continue;
+      }
+      const isSingle = startIndex === endIndex;
+      const isFirst = i === startIndex;
+      const isLast = i === endIndex;
+      if (isSingle) {
+        result.push(...splitNode(node, startOffset, endOffset, format, value, remove));
+      } else if (isFirst) {
+        result.push(...splitNode(node, startOffset, node.text.length, format, value, remove));
+      } else if (isLast) {
+        result.push(...splitNode(node, 0, endOffset, format, value, remove));
+      } else {
+        result.push(applyFormat(node, format, value, remove));
+      }
+    }
+    return mergeAdjacentNodes(result);
+  });
+}
+function mergeAdjacentNodes(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    const prev = result[result.length - 1];
+    if (prev && isTextNode(prev) && isTextNode(node) && formatsMatch(prev, node)) {
+      result[result.length - 1] = { ...prev, text: prev.text + node.text };
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+}
+function formatsMatch(a, b) {
+  const keys = [
+    "bold",
+    "italic",
+    "underline",
+    "strikethrough",
+    "highlighted",
+    "color",
+    "link"
+  ];
+  return keys.every((k) => a[k] === b[k]);
+}
+var toggleBold = (nodes, sel) => formatNodes(nodes, sel, "bold");
+var toggleItalic = (nodes, sel) => formatNodes(nodes, sel, "italic");
+var toggleUnderline = (nodes, sel) => formatNodes(nodes, sel, "underline");
+var toggleStrikethrough = (nodes, sel) => formatNodes(nodes, sel, "strikethrough");
+var toggleHighlight = (nodes, sel, color = "yellow") => formatNodes(nodes, sel, "highlighted", color);
+var toggleColor = (nodes, sel, color) => formatNodes(nodes, sel, "color", color);
+var setLink = (nodes, sel, href) => formatNodes(nodes, sel, "link", href);
+var removeLink = (nodes, sel) => formatNodes(nodes, sel, "link", void 0);
+
+// src/engine/content.ts
+function isClean(node) {
+  return node.bold === void 0 && node.italic === void 0 && node.underline === void 0 && node.strikethrough === void 0 && node.highlighted === void 0 && node.color === void 0 && node.link === void 0;
+}
+function getTextLength(node) {
+  if (node.type === "text" || node.type === "code") return node.text.length;
+  if (node.type === "equation") return node.latex.length;
+  return 0;
+}
+function tryMerge(a, b) {
+  if (a.type !== b.type) return null;
+  if (a.type === "code" && b.type === "code") return { ...a, text: a.text + b.text };
+  if (a.type === "equation" && b.type === "equation") return { ...a, latex: a.latex + b.latex };
+  if (a.type === "text" && b.type === "text") {
+    if (isClean(a) && isClean(b) || formatsMatch(a, b))
+      return { ...a, text: a.text + b.text };
+  }
+  return null;
+}
+function sliceNode(node, start, end) {
+  if (start >= end) return null;
+  if (node.type === "text") {
+    const text = node.text.slice(start, end);
+    return text.length ? { ...node, text } : null;
+  }
+  if (node.type === "code") {
+    const text = node.text.slice(start, end);
+    return text.length ? { ...node, text } : null;
+  }
+  if (node.type === "equation") {
+    const latex = node.latex.slice(start, end);
+    return latex.length ? { ...node, latex } : null;
+  }
+  return null;
+}
+function insertAt(block, nodeIndex, offset, incoming) {
+  if (block.type === "code") {
+    if (incoming.type !== "code")
+      return Result3.Err(`code block only accepts a code node, got "${incoming.type}"`);
+    const node = block.content[0];
+    if (offset < 0 || offset > node.text.length)
+      return Result3.Err(`offset (${offset}) out of bounds for code node`);
+    const text = node.text.slice(0, offset) + incoming.text + node.text.slice(offset);
+    return Result3.Ok([{ ...node, text }]);
+  }
+  if (block.type === "equation") {
+    if (incoming.type !== "equation")
+      return Result3.Err(`equation block only accepts an equation node, got "${incoming.type}"`);
+    const node = block.content[0];
+    if (offset < 0 || offset > node.latex.length)
+      return Result3.Err(`offset (${offset}) out of bounds for equation node`);
+    const latex = node.latex.slice(0, offset) + incoming.latex + node.latex.slice(offset);
+    return Result3.Ok([{ ...node, latex }]);
+  }
+  const content = block.content;
+  if (content.length === 0) {
+    return Result3.Ok([incoming]);
+  }
+  if (nodeIndex < 0 || nodeIndex >= content.length)
+    return Result3.Err(`nodeIndex (${nodeIndex}) out of bounds (length=${content.length})`);
+  const target = content[nodeIndex];
+  const targetLen = getTextLength(target);
+  if (offset < 0 || offset > targetLen)
+    return Result3.Err(`offset (${offset}) out of bounds for node at index ${nodeIndex}`);
+  const before = content.slice(0, nodeIndex);
+  const after = content.slice(nodeIndex + 1);
+  const middle = [];
+  const left = sliceNode(target, 0, offset);
+  if (left) middle.push(left);
+  if (middle.length > 0) {
+    const merged = tryMerge(middle[middle.length - 1], incoming);
+    if (merged) middle[middle.length - 1] = merged;
+    else middle.push(incoming);
+  } else {
+    middle.push(incoming);
+  }
+  const right = sliceNode(target, offset, targetLen);
+  if (right) {
+    const merged = tryMerge(middle[middle.length - 1], right);
+    if (merged) middle[middle.length - 1] = merged;
+    else middle.push(right);
+  }
+  const result = [];
+  for (const node of [...before, ...middle, ...after]) {
+    const prev = result[result.length - 1];
+    const merged = prev ? tryMerge(prev, node) : null;
+    if (merged) result[result.length - 1] = merged;
+    else result.push(node);
+  }
+  return Result3.Ok(result);
+}
+function deleteLastChar(block) {
+  if (block.type === "code") {
+    const node = block.content[0];
+    if (!node.text.length) return Result3.Err("Nothing to delete");
+    return Result3.Ok([{ ...node, text: node.text.slice(0, -1) }]);
+  }
+  if (block.type === "equation") {
+    const node = block.content[0];
+    if (!node.latex.length) return Result3.Err("Nothing to delete");
+    return Result3.Ok([{ ...node, latex: node.latex.slice(0, -1) }]);
+  }
+  const next = [...block.content];
+  for (let i = next.length - 1; i >= 0; i--) {
+    const node = next[i];
+    if (node.type === "text" || node.type === "code") {
+      const trimmed = node.text.slice(0, -1);
+      if (!trimmed.length) next.splice(i, 1);
+      else next[i] = { ...node, text: trimmed };
+      return Result3.Ok(next);
+    }
+    if (node.type === "equation") {
+      const trimmed = node.latex.slice(0, -1);
+      if (!trimmed.length) next.splice(i, 1);
+      else next[i] = { ...node, latex: trimmed };
+      return Result3.Ok(next);
+    }
+  }
+  return Result3.Err("Nothing to delete");
+}
+function deleteRange(block, startNodeIndex, startOffset, endNodeIndex, endOffset) {
+  if (block.type === "code") {
+    const node = block.content[0];
+    if (startOffset < 0 || endOffset > node.text.length || startOffset > endOffset)
+      return Result3.Err(`invalid range [${startOffset}, ${endOffset}] for code node`);
+    const text = node.text.slice(0, startOffset) + node.text.slice(endOffset);
+    return Result3.Ok([{ ...node, text }]);
+  }
+  if (block.type === "equation") {
+    const node = block.content[0];
+    if (startOffset < 0 || endOffset > node.latex.length || startOffset > endOffset)
+      return Result3.Err(`invalid range [${startOffset}, ${endOffset}] for equation node`);
+    const latex = node.latex.slice(0, startOffset) + node.latex.slice(endOffset);
+    return Result3.Ok([{ ...node, latex }]);
+  }
+  const nodes = block.content;
+  if (startNodeIndex < 0 || endNodeIndex >= nodes.length)
+    return Result3.Err(`node indices [${startNodeIndex}, ${endNodeIndex}] out of bounds`);
+  if (startNodeIndex > endNodeIndex)
+    return Result3.Err(`startNodeIndex (${startNodeIndex}) > endNodeIndex (${endNodeIndex})`);
+  const startNode = nodes[startNodeIndex];
+  const endNode = nodes[endNodeIndex];
+  if (startOffset < 0 || startOffset > getTextLength(startNode))
+    return Result3.Err(`startOffset (${startOffset}) out of bounds`);
+  if (endOffset < 0 || endOffset > getTextLength(endNode))
+    return Result3.Err(`endOffset (${endOffset}) out of bounds`);
+  const before = nodes.slice(0, startNodeIndex);
+  const after = nodes.slice(endNodeIndex + 1);
+  const middle = [];
+  const left = sliceNode(startNode, 0, startOffset);
+  if (left) middle.push(left);
+  const right = sliceNode(endNode, endOffset, getTextLength(endNode));
+  if (right) {
+    const merged = middle.length > 0 ? tryMerge(middle[middle.length - 1], right) : null;
+    if (merged) middle[middle.length - 1] = merged;
+    else middle.push(right);
+  }
+  const result = [];
+  for (const node of [...before, ...middle, ...after]) {
+    const prev = result[result.length - 1];
+    const merged = prev ? tryMerge(prev, node) : null;
+    if (merged) result[result.length - 1] = merged;
+    else result.push(node);
+  }
+  return Result3.Ok(result);
+}
+function splitBlock(block, nodeIndex, offset) {
+  if (block.type === "code" || block.type === "equation")
+    return Result3.Err(`splitBlock is not supported for "${block.type}" blocks`);
+  const nodes = block.content;
+  if (nodes.length > 0 && (nodeIndex < 0 || nodeIndex >= nodes.length))
+    return Result3.Err(`nodeIndex (${nodeIndex}) out of bounds`);
+  const target = nodes[nodeIndex] ?? null;
+  const targetLen = target ? getTextLength(target) : 0;
+  if (offset < 0 || offset > targetLen)
+    return Result3.Err(`offset (${offset}) out of bounds`);
+  const beforeNodes = [
+    ...nodes.slice(0, nodeIndex),
+    ...target && offset > 0 ? [sliceNode(target, 0, offset)].filter(Boolean) : []
+  ];
+  const afterNodes = [
+    ...target && offset < targetLen ? [sliceNode(target, offset, targetLen)].filter(Boolean) : [],
+    ...nodes.slice(nodeIndex + 1)
+  ];
+  const original = {
+    ...block,
+    content: beforeNodes
+  };
+  const newBlock = {
+    id: generateId(),
+    type: "paragraph",
+    content: afterNodes,
+    meta: {}
+  };
+  return Result3.Ok([original, newBlock]);
+}
+function mergeBlocks(blockA, blockB) {
+  if (blockA.type === "code" || blockA.type === "equation")
+    return Result3.Err(`mergeBlocks: blockA cannot be of type "${blockA.type}"`);
+  if (blockB.type === "code" || blockB.type === "equation")
+    return Result3.Err(`mergeBlocks: blockB cannot be of type "${blockB.type}"`);
+  const nodesA = blockA.content;
+  const nodesB = blockB.content;
+  const result = [...nodesA];
+  for (const node of nodesB) {
+    const prev = result[result.length - 1];
+    const merged = prev ? tryMerge(prev, node) : null;
+    if (merged) result[result.length - 1] = merged;
+    else result.push(node);
+  }
+  return Result3.Ok({
+    ...blockA,
+    content: result
+  });
+}
+function replaceRange(block, startNodeIndex, startOffset, endNodeIndex, endOffset, incoming) {
+  return deleteRange(block, startNodeIndex, startOffset, endNodeIndex, endOffset).andThen(
+    (content) => insertAt(
+      { ...block, content },
+      startNodeIndex,
+      startOffset,
+      incoming
+    )
+  );
+}
+
+// src/engine/transform.ts
+import { Result as Result4 } from "@reiwuzen/result";
+var TRIGGERS = {
+  "-": "bullet",
+  "1.": "number",
+  "[]": "todo",
+  "#": "heading1",
+  "##": "heading2",
+  "###": "heading3"
+};
+function getRawText(block) {
+  const first = block.content[0];
+  if (!first || first.type !== "text") return "";
+  return first.text;
+}
+function stripPrefix(block, prefix) {
+  const first = block.content[0];
+  if (!first || first.type !== "text") return block.content;
+  const stripped = first.text.slice(prefix.length + 1);
+  if (stripped.length === 0) return [];
+  return [{ ...first, text: stripped }, ...block.content.slice(1)];
+}
+function buildMeta(type) {
+  switch (type) {
+    case "bullet":
+    case "number":
+    case "todo":
+      return { depth: 0 };
+    case "heading1":
+    case "heading2":
+    case "heading3":
+      return {};
+  }
+}
+function applyMarkdownTransform(block, cursorOffset) {
+  if (block.type !== "paragraph")
+    return Result4.Ok({ block, converted: false });
+  const text = getRawText(block);
+  const match = Object.keys(TRIGGERS).sort((a, b) => b.length - a.length).find((trigger) => text === trigger || text.startsWith(trigger + " "));
+  if (!match)
+    return Result4.Ok({ block, converted: false });
+  const triggerEnd = match.length + 1;
+  if (cursorOffset < triggerEnd)
+    return Result4.Ok({ block, converted: false });
+  const targetType = TRIGGERS[match];
+  const strippedContent = stripPrefix(block, match);
+  const converted = {
+    id: block.id,
+    type: targetType,
+    content: strippedContent,
+    meta: buildMeta(targetType)
+  };
+  return Result4.Ok({ block: converted, converted: true });
+}
+function changeBlockType(block, targetType) {
+  if (block.type === targetType)
+    return Result4.Ok(block);
+  const content = deriveContent(block, targetType);
+  const meta = buildMetaForTarget(targetType);
+  return Result4.Ok({
+    id: block.id,
+    type: targetType,
+    content,
+    meta
+  });
+}
+function extractText(block) {
+  if (block.type === "code") return block.content[0].text;
+  if (block.type === "equation") return block.content[0].latex;
+  return block.content.map((n) => {
+    if (n.type === "text") return n.text;
+    if (n.type === "code") return n.text;
+    if (n.type === "equation") return n.latex;
+    return "";
+  }).join("");
+}
+function deriveContent(block, targetType) {
+  const text = extractText(block);
+  if (targetType === "code")
+    return [{ type: "code", text }];
+  if (targetType === "equation")
+    return [{ type: "equation", latex: text }];
+  if (block.type === "code" || block.type === "equation") {
+    return text.length ? [{ type: "text", text }] : [];
+  }
+  return block.content;
+}
+function buildMetaForTarget(targetType) {
+  switch (targetType) {
+    case "bullet":
+    case "number":
+    case "todo":
+      return { depth: 0 };
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "paragraph":
+    case "code":
+    case "equation":
+      return {};
+  }
+}
+function toggleTodo(block) {
+  if (block.type !== "todo")
+    return Result4.Err(`toggleTodo expects a "todo" block, got "${block.type}"`);
+  const todo = block;
+  const checked = todo.meta.checked ? void 0 : true;
+  const meta = checked ? { ...todo.meta, checked } : (({ checked: _, ...rest }) => rest)(todo.meta);
+  return Result4.Ok({ ...todo, meta });
+}
+var MAX_DEPTH = 6;
+function isIndentable(block) {
+  return block.type === "bullet" || block.type === "number" || block.type === "todo";
+}
+function indentBlock(block) {
+  if (!isIndentable(block))
+    return Result4.Err(`indentBlock only supports bullet, number, todo \u2014 got "${block.type}"`);
+  if (block.meta.depth >= MAX_DEPTH)
+    return Result4.Err(`already at max depth (${MAX_DEPTH})`);
+  return Result4.Ok({
+    ...block,
+    meta: { ...block.meta, depth: block.meta.depth + 1 }
+  });
+}
+function outdentBlock(block) {
+  if (!isIndentable(block))
+    return Result4.Err(`outdentBlock only supports bullet, number, todo \u2014 got "${block.type}"`);
+  if (block.meta.depth <= 0)
+    return Result4.Err(`already at min depth (0)`);
+  return Result4.Ok({
+    ...block,
+    meta: { ...block.meta, depth: block.meta.depth - 1 }
+  });
+}
+
+// src/engine/serializer.ts
+import { Result as Result5 } from "@reiwuzen/result";
+function serialize(blocks) {
+  return Result5.try(() => JSON.stringify(blocks));
+}
+function deserialize(json) {
+  return Result5.try(() => JSON.parse(json)).mapErr(() => "Invalid JSON string").andThen((parsed) => {
+    if (!Array.isArray(parsed))
+      return Result5.Err("Expected an array at top level");
+    const validTypes = /* @__PURE__ */ new Set([
+      "paragraph",
+      "heading1",
+      "heading2",
+      "heading3",
+      "bullet",
+      "number",
+      "todo",
+      "code",
+      "equation"
+    ]);
+    for (let i = 0; i < parsed.length; i++) {
+      const block = parsed[i];
+      if (typeof block !== "object" || block === null)
+        return Result5.Err(`Block at index ${i} is not an object`);
+      if (typeof block.id !== "string" || !block.id.length)
+        return Result5.Err(`Block at index ${i} has invalid id`);
+      if (!validTypes.has(block.type))
+        return Result5.Err(`Block at index ${i} has unknown type "${block.type}"`);
+      if (typeof block.meta !== "object" || block.meta === null)
+        return Result5.Err(`Block at index ${i} has invalid meta`);
+      if (!Array.isArray(block.content))
+        return Result5.Err(`Block at index ${i} has invalid content`);
+      const contentErr = validateContent(block.content, block.type, i);
+      if (contentErr) return Result5.Err(contentErr);
+    }
+    return Result5.Ok(parsed);
+  });
+}
+function validateContent(content, type, blockIndex) {
+  const isLeaf = type === "code" || type === "equation";
+  if (isLeaf && content.length !== 1)
+    return `Block at index ${blockIndex} (${type}) must have exactly 1 content node`;
+  for (let i = 0; i < content.length; i++) {
+    const node = content[i];
+    const err = validateNode(node, blockIndex, i);
+    if (err) return err;
+  }
+  return null;
+}
+function validateNode(node, blockIndex, nodeIndex) {
+  const prefix = `Block[${blockIndex}].content[${nodeIndex}]`;
+  if (typeof node !== "object" || node === null)
+    return `${prefix} is not an object`;
+  const n = node;
+  if (n.type === "text") {
+    if (typeof n.text !== "string")
+      return `${prefix} text node missing "text" string`;
+    return null;
+  }
+  if (n.type === "code") {
+    if (typeof n.text !== "string")
+      return `${prefix} code node missing "text" string`;
+    return null;
+  }
+  if (n.type === "equation") {
+    if (typeof n.latex !== "string")
+      return `${prefix} equation node missing "latex" string`;
+    return null;
+  }
+  return `${prefix} has unknown node type "${n.type}"`;
+}
+function serializeNodes(nodes) {
+  return Result5.try(() => JSON.stringify(nodes));
+}
+function deserializeNodes(json) {
+  return Result5.try(() => JSON.parse(json)).mapErr(() => "Invalid JSON string").andThen((parsed) => {
+    if (!Array.isArray(parsed))
+      return Result5.Err("Expected an array of nodes");
+    for (let i = 0; i < parsed.length; i++) {
+      const err = validateNode(parsed[i], 0, i);
+      if (err) return Result5.Err(err);
+    }
+    return Result5.Ok(parsed);
+  });
+}
+function toPlainText(nodes) {
+  return nodes.map((n) => {
+    if (n.type === "text") return n.text;
+    if (n.type === "code") return n.text;
+    if (n.type === "equation") return n.latex;
+    return "";
+  }).join("");
+}
+function nodesToMarkdown(nodes) {
+  return nodes.map((n) => {
+    if (n.type === "code") return `\`${n.text}\``;
+    if (n.type === "equation") return `$${n.latex}$`;
+    let text = n.text;
+    if (n.bold) text = `**${text}**`;
+    if (n.italic) text = `*${text}*`;
+    if (n.underline) text = `<u>${text}</u>`;
+    if (n.strikethrough) text = `~~${text}~~`;
+    if (n.link) text = `[${text}](${n.link})`;
+    return text;
+  }).join("");
+}
+function toMarkdown(blocks) {
+  return blocks.map((block) => {
+    switch (block.type) {
+      case "paragraph":
+        return nodesToMarkdown(block.content);
+      case "heading1":
+        return `# ${nodesToMarkdown(block.content)}`;
+      case "heading2":
+        return `## ${nodesToMarkdown(block.content)}`;
+      case "heading3":
+        return `### ${nodesToMarkdown(block.content)}`;
+      case "bullet": {
+        const indent = "  ".repeat(block.meta.depth);
+        return `${indent}- ${nodesToMarkdown(block.content)}`;
+      }
+      case "number": {
+        const indent = "  ".repeat(block.meta.depth);
+        return `${indent}1. ${nodesToMarkdown(block.content)}`;
+      }
+      case "todo": {
+        const indent = "  ".repeat(block.meta.depth);
+        const checkbox = block.meta.checked ? "[x]" : "[ ]";
+        return `${indent}- ${checkbox} ${nodesToMarkdown(block.content)}`;
+      }
+      case "code": {
+        const lang = block.meta.language ?? "";
+        return `\`\`\`${lang}
+${block.content[0].text}
+\`\`\``;
+      }
+      case "equation":
+        return `$$${block.content[0].latex}$$`;
+    }
+  }).join("\n\n");
+}
+
+// src/engine/cursor.ts
+import { Result as Result6 } from "@reiwuzen/result";
+function getTextLength2(node) {
+  if (node.type === "text" || node.type === "code") return node.text.length;
+  if (node.type === "equation") return node.latex.length;
+  return 0;
+}
+function flatToPosition(block, flatOffset) {
+  if (block.type === "code" || block.type === "equation") {
+    const node = block.content[0];
+    const len = getTextLength2(node);
+    if (flatOffset < 0 || flatOffset > len)
+      return Result6.Err(`flatOffset (${flatOffset}) out of bounds (length=${len})`);
+    return Result6.Ok({ nodeIndex: 0, offset: flatOffset });
+  }
+  const nodes = block.content;
+  if (flatOffset < 0)
+    return Result6.Err(`flatOffset (${flatOffset}) cannot be negative`);
+  let accumulated = 0;
+  for (let i = 0; i < nodes.length; i++) {
+    const len = getTextLength2(nodes[i]);
+    if (flatOffset <= accumulated + len) {
+      return Result6.Ok({ nodeIndex: i, offset: flatOffset - accumulated });
+    }
+    accumulated += len;
+  }
+  if (flatOffset === accumulated) {
+    const last = nodes.length - 1;
+    return Result6.Ok({ nodeIndex: Math.max(0, last), offset: getTextLength2(nodes[last]) });
+  }
+  return Result6.Err(
+    `flatOffset (${flatOffset}) out of bounds (total length=${accumulated})`
+  );
+}
+function flatToSelection(block, start, end) {
+  if (start > end)
+    return Result6.Err(`start (${start}) cannot be greater than end (${end})`);
+  return flatToPosition(block, start).andThen(
+    (startPos) => flatToPosition(block, end).map((endPos) => ({
+      startIndex: startPos.nodeIndex,
+      startOffset: startPos.offset,
+      endIndex: endPos.nodeIndex,
+      endOffset: endPos.offset
+    }))
+  );
+}
+function positionToFlat(block, nodeIndex, offset) {
+  if (block.type === "code" || block.type === "equation")
+    return Result6.Ok(offset);
+  const nodes = block.content;
+  if (nodeIndex < 0 || nodeIndex >= nodes.length)
+    return Result6.Err(`nodeIndex (${nodeIndex}) out of bounds`);
+  let flat = 0;
+  for (let i = 0; i < nodeIndex; i++) {
+    flat += getTextLength2(nodes[i]);
+  }
+  return Result6.Ok(flat + offset);
+}
+
+// src/engine/history.ts
+import { Result as Result7 } from "@reiwuzen/result";
+function createHistory(initialBlocks) {
+  return {
+    past: [],
+    present: { blocks: initialBlocks, timestamp: Date.now() },
+    future: []
+  };
+}
+function push(history, blocks, maxSize = 100) {
+  const past = [...history.past, history.present].slice(-maxSize);
+  return {
+    past,
+    present: { blocks, timestamp: Date.now() },
+    future: []
+  };
+}
+function undo(history) {
+  if (history.past.length === 0)
+    return Result7.Err("Nothing to undo");
+  const previous = history.past[history.past.length - 1];
+  return Result7.Ok({
+    past: history.past.slice(0, -1),
+    present: previous,
+    future: [history.present, ...history.future]
+  });
+}
+function redo(history) {
+  if (history.future.length === 0)
+    return Result7.Err("Nothing to redo");
+  const next = history.future[0];
+  return Result7.Ok({
+    past: [...history.past, history.present],
+    present: next,
+    future: history.future.slice(1)
+  });
+}
+var canUndo = (history) => history.past.length > 0;
+var canRedo = (history) => history.future.length > 0;
+var currentBlocks = (history) => history.present.blocks;
+
+// src/engine/block.ts
+function blockInsertAt(block, nodeIndex, offset, incoming) {
+  return insertAt(block, nodeIndex, offset, incoming).map(
+    (content) => ({
+      ...block,
+      content
+    })
+  );
+}
+function blockDeleteLastChar(block) {
+  return deleteLastChar(block).map(
+    (content) => ({
+      ...block,
+      content
+    })
+  );
+}
+function blockDeleteRange(block, startNodeIndex, startOffset, endNodeIndex, endOffset) {
+  return deleteRange(
+    block,
+    startNodeIndex,
+    startOffset,
+    endNodeIndex,
+    endOffset
+  ).map((content) => ({ ...block, content }));
+}
+function blockReplaceRange(block, startNodeIndex, startOffset, endNodeIndex, endOffset, incoming) {
+  return replaceRange(
+    block,
+    startNodeIndex,
+    startOffset,
+    endNodeIndex,
+    endOffset,
+    incoming
+  ).map((content) => ({ ...block, content }));
+}
+export {
+  applyMarkdownTransform,
+  blockDeleteLastChar,
+  blockDeleteRange,
+  blockInsertAt,
+  blockReplaceRange,
+  canRedo,
+  canUndo,
+  changeBlockType,
+  createBlock,
+  createBlockAfter,
+  createHistory,
+  currentBlocks,
+  deleteBlock,
+  deleteLastChar,
+  deleteRange,
+  deserialize,
+  deserializeNodes,
+  duplicateBlock,
+  duplicateBlockAfter,
+  flatToPosition,
+  flatToSelection,
+  formatNodes,
+  generateId,
+  indentBlock,
+  insertAt,
+  insertBlockAfter,
+  mergeAdjacentNodes,
+  mergeBlocks,
+  moveBlock,
+  outdentBlock,
+  positionToFlat,
+  push,
+  redo,
+  removeLink,
+  replaceRange,
+  serialize,
+  serializeNodes,
+  setLink,
+  splitBlock,
+  toMarkdown,
+  toPlainText,
+  toggleBold,
+  toggleColor,
+  toggleHighlight,
+  toggleItalic,
+  toggleStrikethrough,
+  toggleTodo,
+  toggleUnderline,
+  undo
+};