quoin-editor 0.4.2 → 1.0.0

package/dist/chunk-HJIQT3S5.js

@@ -0,0 +1,4047 @@
+import {
+  sameValue
+} from "./chunk-NOKWNK2O.js";
+import {
+  ALERT_TONES,
+  MAX_MARKER_NUMBER,
+  PALETTE,
+  addMark,
+  addMarkRange,
+  atom,
+  blockById,
+  blockPlainText,
+  cellKey,
+  compareRegionNames,
+  coreAtomSpecs,
+  coreBlockSpecs,
+  coreMarkSpecs,
+  createBlockCodec,
+  createDoc,
+  createSchema,
+  documentNodes,
+  engineBlocksOf,
+  equalInline,
+  fromMarkdown,
+  hasMark,
+  indexOfBlock,
+  inlineLength,
+  inlinePlainText,
+  inlineText,
+  isPaletteColor,
+  isQuoinType,
+  isRecord,
+  linkClose,
+  marksAt,
+  newId,
+  nodeLength,
+  normalizeInline,
+  orderedStart,
+  parseInline,
+  parseLine,
+  removeMark,
+  removeMarkRange,
+  replaceBlocks,
+  replaceInline,
+  requireBlockIndex,
+  sameItems,
+  sameMark,
+  sameMarkSet,
+  sanitizeHref,
+  serializeInline,
+  sliceInline,
+  specFor,
+  startsHtmlBlock,
+  str,
+  text,
+  updateBlock,
+  writtenAttrs
+} from "./chunk-LCQSG4M6.js";
+
+// src/engine/transform/step.ts
+var StepError = class extends Error {
+};
+var identityMap = (pos) => pos;
+
+// src/engine/transform/step-access.ts
+function requireBlock(doc, id) {
+  const block = blockById(doc, id);
+  if (block === void 0) throw new StepError(`no block "${id}"`);
+  return block;
+}
+function requireRegion(block, region) {
+  if (!Object.hasOwn(block.regions, region)) throw new StepError(`block "${block.id}" has no region "${region}"`);
+  return block.regions[region];
+}
+function requireRange(block, region, from, to) {
+  const inline = requireRegion(block, region);
+  const length = inlineLength(inline);
+  if (!(Number.isInteger(from) && Number.isInteger(to) && from >= 0 && from <= to && to <= length)) {
+    throw new StepError(`range ${from} to ${to} is outside 0 to ${length} in "${block.id}" ${region}`);
+  }
+  return inline;
+}
+function requireSpan(start, count2, length) {
+  if (!(Number.isInteger(start) && Number.isInteger(count2) && start >= 0 && count2 >= 0 && start + count2 <= length)) {
+    throw new StepError(`blocks ${start} to ${start + count2} are outside 0 to ${length}`);
+  }
+}
+function withRegion(block, region, inline) {
+  return { ...block, regions: { ...block.regions, [region]: inline } };
+}
+
+// src/engine/transform/attrs-steps.ts
+function patchAttrs(attrs, patch) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(attrs), ...Object.keys(patch)]);
+  return Object.fromEntries(
+    [...keys].filter((key) => !(Object.hasOwn(patch, key) && patch[key] === void 0)).map((key) => [key, Object.hasOwn(patch, key) ? patch[key] : attrs[key]])
+  );
+}
+function patchChangesAttrs(attrs, patch) {
+  return Object.keys(patch).some(
+    (key) => patch[key] === void 0 ? Object.hasOwn(attrs, key) : !sameValue(attrs[key], patch[key])
+  );
+}
+function previousValues(attrs, patch) {
+  return Object.fromEntries(
+    Object.keys(patch).map((key) => [key, Object.hasOwn(attrs, key) ? attrs[key] : void 0])
+  );
+}
+function patchToJSON(patch) {
+  return Object.fromEntries(
+    Object.entries(patch).map(([key, value]) => [key, value === void 0 ? { $delete: true } : value])
+  );
+}
+function patchFromJSON(json) {
+  const isMarker = (value) => typeof value === "object" && value !== null && value.$delete === true;
+  return Object.fromEntries(Object.entries(json).map(([key, value]) => [key, isMarker(value) ? void 0 : value]));
+}
+function setAttrsStep(block, patch) {
+  return Object.freeze({
+    stepType: "setAttrs",
+    apply(doc) {
+      requireBlock(doc, block);
+      return { doc: updateBlock(doc, block, (b) => ({ ...b, attrs: patchAttrs(b.attrs, patch) })), map: identityMap };
+    },
+    invert: (before) => setAttrsStep(block, previousValues(requireBlock(before, block).attrs, patch)),
+    toJSON: () => ({ stepType: "setAttrs", block, patch: patchToJSON(patch) })
+  });
+}
+function setIndentStep(block, indent2) {
+  return Object.freeze({
+    stepType: "setIndent",
+    apply(doc) {
+      requireBlock(doc, block);
+      if (!Number.isInteger(indent2) || indent2 < 0) {
+        throw new StepError(`indent ${indent2} is not a non-negative integer`);
+      }
+      return { doc: updateBlock(doc, block, (b) => ({ ...b, indent: indent2 })), map: identityMap };
+    },
+    invert: (before) => setIndentStep(block, requireBlock(before, block).indent),
+    toJSON: () => ({ stepType: "setIndent", block, indent: indent2 })
+  });
+}
+
+// src/engine/transform/block-edges.ts
+function orderedRegions(block) {
+  return Object.keys(block.regions).sort(compareRegionNames);
+}
+function firstRegion(block) {
+  return orderedRegions(block)[0] ?? null;
+}
+function blockStart(block) {
+  return { block: block.id, region: firstRegion(block) ?? "", offset: 0 };
+}
+function blockEnd(block) {
+  const region = orderedRegions(block).at(-1);
+  return {
+    block: block.id,
+    region: region ?? "",
+    offset: region === void 0 ? 0 : inlineLength(block.regions[region])
+  };
+}
+function clampPos(block, pos) {
+  if (!Object.hasOwn(block.regions, pos.region)) return blockStart(block);
+  const length = inlineLength(block.regions[pos.region]);
+  return pos.offset > length ? { ...pos, offset: length } : pos;
+}
+
+// src/engine/transform/block-steps.ts
+function insertBlocksStep(index, blocks) {
+  return Object.freeze({
+    stepType: "insertBlocks",
+    apply(doc) {
+      requireSpan(index, 0, doc.blocks.length);
+      const ids = /* @__PURE__ */ new Set();
+      for (const { id } of blocks) {
+        if (doc.index.has(id) || ids.has(id)) throw new StepError(`block "${id}" is already in the document`);
+        ids.add(id);
+      }
+      return { doc: replaceBlocks(doc, index, 0, blocks), map: identityMap };
+    },
+    invert: () => removeBlocksStep(index, blocks.length),
+    toJSON: () => ({ stepType: "insertBlocks", index, blocks })
+  });
+}
+function removeBlocksStep(index, count2) {
+  return Object.freeze({
+    stepType: "removeBlocks",
+    apply(doc) {
+      requireSpan(index, count2, doc.blocks.length);
+      const removed = new Set(doc.blocks.slice(index, index + count2).map((block) => block.id));
+      const preceding = doc.blocks[index - 1];
+      const following = doc.blocks[index + count2];
+      const map = (pos, assoc = 1) => {
+        if (!removed.has(pos.block)) return pos;
+        const before = preceding && blockEnd(preceding);
+        const after = following && blockStart(following);
+        return (assoc === -1 ? before ?? after : after ?? before) ?? pos;
+      };
+      return { doc: replaceBlocks(doc, index, count2, []), map };
+    },
+    invert: (before) => insertBlocksStep(index, before.blocks.slice(index, index + count2)),
+    toJSON: () => ({ stepType: "removeBlocks", index, count: count2 })
+  });
+}
+function moveBlocksStep(from, count2, to) {
+  return Object.freeze({
+    stepType: "moveBlocks",
+    apply(doc) {
+      requireSpan(from, count2, doc.blocks.length);
+      requireSpan(to, count2, doc.blocks.length);
+      const moved2 = doc.blocks.slice(from, from + count2);
+      const rest = [...doc.blocks.slice(0, from), ...doc.blocks.slice(from + count2)];
+      return { doc: createDoc([...rest.slice(0, to), ...moved2, ...rest.slice(to)]), map: identityMap };
+    },
+    invert: () => moveBlocksStep(to, count2, from),
+    toJSON: () => ({ stepType: "moveBlocks", from, count: count2, to })
+  });
+}
+var keepsRegions = (before, after) => Object.entries(before.regions).every(
+  ([name, inline]) => Object.hasOwn(after.regions, name) && equalInline(inline, after.regions[name])
+);
+function replaceBlockStep(block) {
+  const clamp = (pos) => pos.block === block.id ? clampPos(block, pos) : pos;
+  return Object.freeze({
+    stepType: "replaceBlock",
+    apply(doc) {
+      const map = keepsRegions(requireBlock(doc, block.id), block) ? identityMap : clamp;
+      return { doc: updateBlock(doc, block.id, () => block), map };
+    },
+    invert: (before) => replaceBlockStep(requireBlock(before, block.id)),
+    toJSON: () => ({ stepType: "replaceBlock", block })
+  });
+}
+
+// src/engine/transform/replace-inline-step.ts
+function replaceInlineStep(block, region, from, to, slice) {
+  const inserted = inlineLength(slice);
+  const map = (pos, assoc = 1) => {
+    if (pos.block !== block || pos.region !== region || pos.offset < from) return pos;
+    if (pos.offset > to) return { ...pos, offset: pos.offset + inserted - (to - from) };
+    return { ...pos, offset: assoc === -1 ? from : from + inserted };
+  };
+  return Object.freeze({
+    stepType: "replaceInline",
+    apply(doc) {
+      const inline = requireRange(requireBlock(doc, block), region, from, to);
+      const next = updateBlock(doc, block, (b) => withRegion(b, region, replaceInline(inline, from, to, slice)));
+      return { doc: next, map };
+    },
+    invert(before) {
+      const inline = requireRange(requireBlock(before, block), region, from, to);
+      return replaceInlineStep(block, region, from, from + inserted, sliceInline(inline, from, to));
+    },
+    toJSON: () => ({ stepType: "replaceInline", block, region, from, to, slice })
+  });
+}
+
+// src/engine/transform/mark-steps.ts
+function markStep(stepType, target, mark, change) {
+  const { block, region, from, to } = target;
+  return Object.freeze({
+    stepType,
+    apply(doc) {
+      const inline = requireRange(requireBlock(doc, block), region, from, to);
+      return { doc: updateBlock(doc, block, (b) => withRegion(b, region, change(inline))), map: identityMap };
+    },
+    invert(before) {
+      const inline = requireRange(requireBlock(before, block), region, from, to);
+      return replaceInlineStep(block, region, from, to, sliceInline(inline, from, to));
+    },
+    toJSON: () => ({ stepType, ...target, mark })
+  });
+}
+function addMarkStep(block, region, from, to, mark) {
+  return markStep("addMark", { block, region, from, to }, mark, (inline) => addMarkRange(inline, from, to, mark));
+}
+function removeMarkStep(block, region, from, to, mark) {
+  return markStep(
+    "removeMark",
+    { block, region, from, to },
+    mark,
+    (inline) => removeMarkRange(inline, from, to, mark)
+  );
+}
+
+// src/engine/model/common-ends.ts
+var isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+var isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+function commonPrefix(a, b) {
+  const limit = Math.min(a.length, b.length);
+  let length = 0;
+  while (length < limit && a.charCodeAt(length) === b.charCodeAt(length)) length++;
+  return length > 0 && isHighSurrogate(a.charCodeAt(length - 1)) ? length - 1 : length;
+}
+function commonSuffix(a, b) {
+  const limit = Math.min(a.length, b.length);
+  let length = 0;
+  while (length < limit && a.charCodeAt(a.length - 1 - length) === b.charCodeAt(b.length - 1 - length)) length++;
+  return length > 0 && isLowSurrogate(a.charCodeAt(a.length - length)) ? length - 1 : length;
+}
+
+// src/engine/transform/map-text-change.ts
+function mapTextChange(before, after) {
+  const from = commonPrefix(before, after);
+  const inserted = from + commonSuffix(before, after) >= before.length;
+  return (offset, assoc) => offset > from || offset === from && inserted && assoc > 0 ? Math.max(offset + after.length - before.length, from) : offset;
+}
+
+// src/engine/transform/replace-doc-step.ts
+function replaceDocStep(next) {
+  return Object.freeze({
+    stepType: "replaceDoc",
+    apply(doc) {
+      const regionMaps = /* @__PURE__ */ new Map();
+      const map = (pos, assoc = 1) => {
+        const { block, region } = pos;
+        const survivor = blockById(next, block);
+        if (survivor !== void 0) {
+          const key = JSON.stringify([block, region]);
+          let regionMap = regionMaps.get(key);
+          if (regionMap === void 0) {
+            const before = inlineText(blockById(doc, block)?.regions[region] ?? []);
+            regionMap = mapTextChange(before, inlineText(survivor.regions[region] ?? []));
+            regionMaps.set(key, regionMap);
+          }
+          const offset = regionMap(pos.offset, assoc);
+          return clampPos(survivor, offset === pos.offset ? pos : { ...pos, offset });
+        }
+        const nearest = next.blocks[Math.min(doc.index.get(block) ?? 0, next.blocks.length - 1)];
+        return nearest === void 0 ? pos : blockStart(nearest);
+      };
+      return { doc: next, map };
+    },
+    invert: (before) => replaceDocStep(before),
+    toJSON: () => ({ stepType: "replaceDoc", blocks: next.blocks })
+  });
+}
+
+// src/engine/transform/split-join-steps.ts
+function splitBlockStep(block, region, offset, created) {
+  const map = (pos, assoc = 1) => {
+    if (pos.block !== block || pos.region !== region) return pos;
+    if (pos.offset < offset || pos.offset === offset && assoc === -1) return pos;
+    return { block: created.id, region: created.region, offset: pos.offset - offset };
+  };
+  return Object.freeze({
+    stepType: "splitBlock",
+    apply(doc) {
+      const target = requireBlock(doc, block);
+      const inline = requireRange(target, region, offset, offset);
+      if (doc.index.has(created.id)) throw new StepError(`block "${created.id}" is already in the document`);
+      const tail = {
+        id: created.id,
+        type: created.type,
+        indent: created.indent,
+        attrs: created.attrs,
+        regions: { ...created.regions, [created.region]: sliceInline(inline, offset, inlineLength(inline)) }
+      };
+      const head = withRegion(target, region, sliceInline(inline, 0, offset));
+      return { doc: replaceBlocks(doc, indexOfBlock(doc, block), 1, [head, tail]), map };
+    },
+    invert: () => joinBlocksStep(block, region, created.id, created.region),
+    toJSON: () => ({ stepType: "splitBlock", block, region, offset, created })
+  });
+}
+function joinBlocksStep(target, targetRegion, source, sourceRegion) {
+  return Object.freeze({
+    stepType: "joinBlocks",
+    apply(doc) {
+      const first = requireBlock(doc, target);
+      const second = requireBlock(doc, source);
+      const index = indexOfBlock(doc, target);
+      if (indexOfBlock(doc, source) !== index + 1) throw new StepError(`block "${source}" does not follow "${target}"`);
+      const head = requireRegion(first, targetRegion);
+      const length = inlineLength(head);
+      const merged = replaceInline(head, length, length, requireRegion(second, sourceRegion));
+      const map = (pos) => pos.block === source ? { block: target, region: targetRegion, offset: length + (pos.region === sourceRegion ? pos.offset : 0) } : pos;
+      return { doc: replaceBlocks(doc, index, 2, [withRegion(first, targetRegion, merged)]), map };
+    },
+    invert(before) {
+      const { id, type, attrs, indent: indent2, regions } = requireBlock(before, source);
+      const length = inlineLength(requireRegion(requireBlock(before, target), targetRegion));
+      const created = { id, type, attrs, indent: indent2, region: sourceRegion, regions };
+      return splitBlockStep(target, targetRegion, length, created);
+    },
+    toJSON: () => ({ stepType: "joinBlocks", target, targetRegion, source, sourceRegion })
+  });
+}
+
+// src/engine/transform/step-json.ts
+var isRegions = (value) => isRecord(value) && Object.values(value).every(Array.isArray);
+var isMark = (value) => isRecord(value) && typeof value.type === "string" && (value.attrs === void 0 || isRecord(value.attrs));
+var isBlockShape = (value) => isRecord(value) && typeof value.id === "string" && typeof value.type === "string" && Number.isInteger(value.indent) && isRecord(value.attrs);
+var isBlock = (value) => isBlockShape(value) && isRegions(value.regions);
+var isCreated = (value) => isBlockShape(value) && typeof value.region === "string" && (value.regions === void 0 || isRegions(value.regions));
+var isString = (value) => typeof value === "string";
+var isInteger = (value) => Number.isInteger(value);
+var isInline = (value) => Array.isArray(value);
+var isMarkOrType = (value) => isString(value) || isMark(value);
+var areBlocks = (value) => Array.isArray(value) && value.every(isBlock);
+function docOf(blocks) {
+  if (new Set(blocks.map((block) => block.id)).size !== blocks.length) {
+    throw new StepError("a replaceDoc step repeats a block id");
+  }
+  return createDoc(blocks);
+}
+function reader(json) {
+  const read = (key, accept) => {
+    const value = json[key];
+    if (!accept(value)) throw new StepError(`invalid "${key}" in a ${json.stepType} step`);
+    return value;
+  };
+  return {
+    string: (key) => read(key, isString),
+    integer: (key) => read(key, isInteger),
+    inline: (key) => read(key, isInline),
+    record: (key) => read(key, isRecord),
+    mark: (key) => read(key, isMark),
+    markOrType: (key) => read(key, isMarkOrType),
+    block: (key) => read(key, isBlock),
+    blocks: (key) => read(key, areBlocks),
+    created: (key) => read(key, isCreated)
+  };
+}
+function stepFromJSON(json) {
+  const get = reader(json);
+  switch (json.stepType) {
+    case "replaceInline":
+      return replaceInlineStep(
+        get.string("block"),
+        get.string("region"),
+        get.integer("from"),
+        get.integer("to"),
+        get.inline("slice")
+      );
+    case "addMark":
+      return addMarkStep(
+        get.string("block"),
+        get.string("region"),
+        get.integer("from"),
+        get.integer("to"),
+        get.mark("mark")
+      );
+    case "removeMark":
+      return removeMarkStep(
+        get.string("block"),
+        get.string("region"),
+        get.integer("from"),
+        get.integer("to"),
+        get.markOrType("mark")
+      );
+    case "setAttrs":
+      return setAttrsStep(get.string("block"), patchFromJSON(get.record("patch")));
+    case "setIndent":
+      return setIndentStep(get.string("block"), get.integer("indent"));
+    case "insertBlocks":
+      return insertBlocksStep(get.integer("index"), get.blocks("blocks"));
+    case "removeBlocks":
+      return removeBlocksStep(get.integer("index"), get.integer("count"));
+    case "moveBlocks":
+      return moveBlocksStep(get.integer("from"), get.integer("count"), get.integer("to"));
+    case "replaceBlock":
+      return replaceBlockStep(get.block("block"));
+    case "replaceDoc":
+      return replaceDocStep(docOf(get.blocks("blocks")));
+    case "splitBlock":
+      return splitBlockStep(get.string("block"), get.string("region"), get.integer("offset"), get.created("created"));
+    case "joinBlocks":
+      return joinBlocksStep(
+        get.string("target"),
+        get.string("targetRegion"),
+        get.string("source"),
+        get.string("sourceRegion")
+      );
+    default:
+      throw new StepError(`unknown step type "${json.stepType}"`);
+  }
+}
+
+// src/engine/model/position.ts
+function comparePos(doc, a, b) {
+  return requireBlockIndex(doc, a.block) - requireBlockIndex(doc, b.block) || compareRegionNames(a.region, b.region) || a.offset - b.offset;
+}
+function orderedRange(doc, anchor, head) {
+  return comparePos(doc, anchor, head) <= 0 ? { from: anchor, to: head } : { from: head, to: anchor };
+}
+
+// src/engine/state/selection.ts
+function textSelection(anchor, head = anchor) {
+  return { kind: "text", anchor, head };
+}
+function nodeSelection(block) {
+  return { kind: "node", block };
+}
+function blockRangeSelection(anchor, head = anchor) {
+  return { kind: "blocks", anchor, head };
+}
+var samePos = (a, b) => a.block === b.block && a.region === b.region && a.offset === b.offset;
+function isCollapsed(selection) {
+  return selection?.kind === "text" && samePos(selection.anchor, selection.head);
+}
+function sameSelection(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  switch (a.kind) {
+    case "text":
+      return b.kind === "text" && samePos(a.anchor, b.anchor) && samePos(a.head, b.head);
+    case "node":
+      return b.kind === "node" && a.block === b.block;
+    case "blocks":
+      return b.kind === "blocks" && a.anchor === b.anchor && a.head === b.head;
+  }
+}
+function selectionRange(doc, selection) {
+  return selection?.kind === "text" ? orderedRange(doc, selection.anchor, selection.head) : null;
+}
+function selectedBlockIds(doc, selection) {
+  if (selection === null) return [];
+  if (selection.kind === "node") return [selection.block];
+  const ends = selection.kind === "text" ? [selection.anchor.block, selection.head.block] : [selection.anchor, selection.head];
+  const [first, second] = ends.map((id) => requireBlockIndex(doc, id));
+  return doc.blocks.slice(Math.min(first, second), Math.max(first, second) + 1).map((block) => block.id);
+}
+function isBackward(doc, selection) {
+  if (selection.kind === "text") {
+    const { anchor, head } = selection;
+    return doc.index.has(anchor.block) && doc.index.has(head.block) && comparePos(doc, anchor, head) > 0;
+  }
+  return doc.index.has(selection.anchor) && doc.index.has(selection.head) && indexOfBlock(doc, selection.anchor) > indexOfBlock(doc, selection.head);
+}
+var blockProbe = (block) => ({ block, region: "", offset: 0 });
+function mapSelection(selection, map, doc) {
+  if (selection.kind === "node") {
+    const block = map(blockProbe(selection.block), 1).block;
+    return block === selection.block ? selection : nodeSelection(block);
+  }
+  const anchorAssoc = doc !== void 0 && isBackward(doc, selection) ? -1 : 1;
+  if (selection.kind === "blocks") {
+    const anchor2 = map(blockProbe(selection.anchor), anchorAssoc).block;
+    const head2 = map(blockProbe(selection.head), 1).block;
+    return anchor2 === selection.anchor && head2 === selection.head ? selection : blockRangeSelection(anchor2, head2);
+  }
+  const anchor = map(selection.anchor, anchorAssoc);
+  const head = map(selection.head, 1);
+  return anchor === selection.anchor && head === selection.head ? selection : textSelection(anchor, head);
+}
+function primaryRegion(schema, block) {
+  const spec = specFor(schema, block.type);
+  if (spec.flow === "text" && spec.primaryRegion !== void 0 && Object.hasOwn(block.regions, spec.primaryRegion)) {
+    return spec.primaryRegion;
+  }
+  return firstRegion(block);
+}
+function flowEdge(schema, block, atEnd) {
+  const region = specFor(schema, block.type).flow === "text" ? primaryRegion(schema, block) : null;
+  return region === null ? null : { block: block.id, region, offset: atEnd ? inlineLength(block.regions[region]) : 0 };
+}
+function edge(doc, schema, blockId, atEnd) {
+  const block = doc.blocks[requireBlockIndex(doc, blockId)];
+  const flow = flowEdge(schema, block, atEnd);
+  if (flow !== null) return textSelection(flow);
+  if (Object.keys(block.regions).length === 0) return nodeSelection(blockId);
+  return textSelection(atEnd ? blockEnd(block) : blockStart(block));
+}
+function startOf(doc, schema, blockId) {
+  return edge(doc, schema, blockId, false);
+}
+function endOf(doc, schema, blockId) {
+  return edge(doc, schema, blockId, true);
+}
+function defaultSelection(doc, schema) {
+  return doc.blocks.length === 0 ? null : startOf(doc, schema, doc.blocks[0].id);
+}
+function validatePos(doc, schema, pos) {
+  const block = blockById(doc, pos.block);
+  if (block === void 0) return null;
+  if (!Object.hasOwn(block.regions, pos.region)) {
+    const region = primaryRegion(schema, block);
+    return region === null ? nodeSelection(block.id) : { block: block.id, region, offset: 0 };
+  }
+  const length = inlineLength(block.regions[pos.region]);
+  return pos.offset >= 0 && pos.offset <= length ? pos : { ...pos, offset: Math.min(Math.max(pos.offset, 0), length) };
+}
+function nearestFlow(doc, schema, from, to, atEnd) {
+  const step = atEnd ? -1 : 1;
+  for (let index = from; index !== to + step; index += step) {
+    const pos = flowEdge(schema, doc.blocks[index], atEnd);
+    if (pos !== null) return pos;
+  }
+  return null;
+}
+var inFlow = (doc, schema, pos) => flowEdge(schema, doc.blocks[requireBlockIndex(doc, pos.block)], false)?.region === pos.region;
+function clampToFlow(doc, schema, selection) {
+  const { anchor, head } = selection;
+  if (anchor.block === head.block) return selection;
+  const backward = comparePos(doc, anchor, head) > 0;
+  const [from, to] = backward ? [head, anchor] : [anchor, head];
+  const first = requireBlockIndex(doc, from.block);
+  const last = requireBlockIndex(doc, to.block);
+  const start = inFlow(doc, schema, from) ? from : nearestFlow(doc, schema, first + 1, last, false);
+  const end = inFlow(doc, schema, to) ? to : nearestFlow(doc, schema, last - 1, first, true);
+  if (start === from && end === to) return selection;
+  if (start === null || end === null || comparePos(doc, start, end) > 0) {
+    return blockRangeSelection(anchor.block, head.block);
+  }
+  return backward ? textSelection(end, start) : textSelection(start, end);
+}
+function validateText(doc, schema, selection) {
+  const head = validatePos(doc, schema, selection.head);
+  const anchor = validatePos(doc, schema, selection.anchor);
+  if (head === null || anchor === null) return defaultSelection(doc, schema);
+  if ("kind" in head) return head;
+  if ("kind" in anchor) return anchor;
+  const valid = anchor === selection.anchor && head === selection.head ? selection : textSelection(anchor, head);
+  return clampToFlow(doc, schema, valid);
+}
+function validateNode(doc, schema, selection) {
+  const block = blockById(doc, selection.block);
+  if (block === void 0) return defaultSelection(doc, schema);
+  return specFor(schema, block.type).flow === "text" ? startOf(doc, schema, block.id) : selection;
+}
+function validateSelection(doc, schema, selection) {
+  if (doc.blocks.length === 0) return null;
+  if (selection === null) return defaultSelection(doc, schema);
+  switch (selection.kind) {
+    case "node":
+      return validateNode(doc, schema, selection);
+    case "blocks":
+      return doc.index.has(selection.anchor) && doc.index.has(selection.head) ? selection : defaultSelection(doc, schema);
+    case "text":
+      return validateText(doc, schema, selection);
+  }
+}
+
+// src/engine/commands/collapsed-toggle.ts
+var isClosedToggle = ({ type, attrs }) => type === "TOGGLE" && attrs.open !== true;
+function hidingToggle(doc, index, isClosed = isClosedToggle) {
+  if (index < 2) return null;
+  let limit = doc.blocks[index - 1].indent;
+  let hiding = null;
+  for (let at = index - 2; at >= 0 && limit > 0; at--) {
+    const { indent: indent2 } = doc.blocks[at];
+    if (indent2 >= limit) continue;
+    limit = indent2;
+    if (isClosed(doc.blocks[at])) hiding = at;
+  }
+  return hiding;
+}
+
+// src/engine/state/visible-selection.ts
+var hiderOf = (doc, id) => hidingToggle(doc, requireBlockIndex(doc, id) + 1);
+function toggleEnd(doc, schema, toggle) {
+  const end = endOf(doc, schema, doc.blocks[toggle].id);
+  return end.kind === "text" ? end.head : blockEnd(doc.blocks[toggle]);
+}
+function visibleText(doc, schema, selection) {
+  const [anchor, head] = [selection.anchor, selection.head].map((pos) => {
+    const hider = hiderOf(doc, pos.block);
+    return hider === null ? pos : toggleEnd(doc, schema, hider);
+  });
+  return anchor === selection.anchor && head === selection.head ? selection : textSelection(anchor, head);
+}
+function visibleBlocks(doc, schema, selection) {
+  const ids = [selection.anchor, selection.head];
+  const indexes = ids.map((id) => requireBlockIndex(doc, id));
+  const from = Math.min(...indexes);
+  const to = Math.max(...indexes);
+  const hiders = indexes.map((index) => hidingToggle(doc, index + 1));
+  const [anchor, head] = ids.map((id, i) => {
+    const hider = hiders[i];
+    return hider === null || hider >= from && hider <= to ? id : doc.blocks[hider].id;
+  });
+  if (anchor === selection.anchor && head === selection.head) return selection;
+  const [anchorHider, headHider] = hiders;
+  if (anchorHider !== null && anchorHider === headHider) return textSelection(toggleEnd(doc, schema, anchorHider));
+  return blockRangeSelection(anchor, head);
+}
+function visibleSelection(doc, schema, selection) {
+  if (selection === null) return null;
+  switch (selection.kind) {
+    case "text":
+      return visibleText(doc, schema, selection);
+    case "node": {
+      const hider = hiderOf(doc, selection.block);
+      return hider === null ? selection : textSelection(toggleEnd(doc, schema, hider));
+    }
+    case "blocks":
+      return visibleBlocks(doc, schema, selection);
+  }
+}
+
+// src/engine/state/editor-state.ts
+function createState(config) {
+  const { doc, schema, plugins = [], clock = Date.now } = config;
+  const requested = config.selection === void 0 ? defaultSelection(doc, schema) : config.selection;
+  const pluginState = /* @__PURE__ */ new Map();
+  const state = {
+    doc,
+    schema,
+    selection: validateSelection(doc, schema, requested),
+    storedMarks: null,
+    plugins,
+    pluginState,
+    clock
+  };
+  for (const plugin of plugins) {
+    if (pluginState.has(plugin.key.name)) throw new Error(`duplicate plugin key "${plugin.key.name}"`);
+    pluginState.set(plugin.key.name, plugin.init(state));
+  }
+  return state;
+}
+var mismatchedTransaction = () => new RangeError("Applying a mismatched transaction: it was built on another state");
+function applyTransaction(state, tr) {
+  if (tr.before !== state) throw mismatchedTransaction();
+  const selection = visibleSelection(tr.doc, state.schema, validateSelection(tr.doc, state.schema, tr.selection));
+  const unchanged = !tr.docChanged && sameSelection(state.selection, selection);
+  const storedMarks = tr.storedMarksSet ? tr.storedMarks : unchanged ? state.storedMarks : null;
+  const next = { ...state, doc: tr.doc, selection, storedMarks };
+  if (state.plugins.length === 0) return next;
+  const pluginState = new Map(state.pluginState);
+  const updated = { ...next, pluginState };
+  for (const plugin of state.plugins) {
+    const { name } = plugin.key;
+    pluginState.set(name, plugin.apply(tr, state.pluginState.get(name), state, updated));
+  }
+  return updated;
+}
+function getPluginState(state, key) {
+  if (!state.pluginState.has(key.name)) throw new Error(`no plugin registered for "${key.name}"`);
+  return state.pluginState.get(key.name);
+}
+
+// src/engine/state/plugin.ts
+function createPluginKey(name) {
+  return { name };
+}
+
+// src/engine/state/transaction.ts
+var foreignOrigins = ["remote", "reconcile", "history"];
+var UNFILTERED = "unfiltered";
+var Transaction = class {
+  before;
+  time;
+  currentDoc;
+  currentSelection;
+  currentStoredMarks;
+  selectionWasSet = false;
+  storedMarksWereSet = false;
+  stepList = [];
+  docList = [];
+  mapList = [];
+  metaValues = /* @__PURE__ */ new Map();
+  constructor(state, time = state.clock()) {
+    this.before = state;
+    this.time = time;
+    this.currentDoc = state.doc;
+    this.currentSelection = state.selection;
+    this.currentStoredMarks = state.storedMarks;
+  }
+  get doc() {
+    return this.currentDoc;
+  }
+  get docs() {
+    return this.docList;
+  }
+  get steps() {
+    return this.stepList;
+  }
+  get maps() {
+    return this.mapList;
+  }
+  get docChanged() {
+    return this.stepList.length > 0;
+  }
+  get selection() {
+    return this.currentSelection;
+  }
+  get selectionSet() {
+    return this.selectionWasSet;
+  }
+  get storedMarks() {
+    return this.currentStoredMarks;
+  }
+  get storedMarksSet() {
+    return this.storedMarksWereSet;
+  }
+  get meta() {
+    return this.metaValues;
+  }
+  get origin() {
+    return this.getMeta("origin") ?? "command";
+  }
+  get addToHistory() {
+    return this.getMeta("addToHistory") !== false;
+  }
+  step(step) {
+    const { doc, map } = step.apply(this.currentDoc);
+    if (this.currentSelection !== null) {
+      this.currentSelection = mapSelection(this.currentSelection, map, this.currentDoc);
+    }
+    this.docList.push(this.currentDoc);
+    this.stepList.push(step);
+    this.mapList.push(map);
+    this.currentDoc = doc;
+    return this;
+  }
+  maybeStep(step) {
+    try {
+      this.step(step);
+      return true;
+    } catch (error) {
+      if (error instanceof StepError) return false;
+      throw error;
+    }
+  }
+  setSelection(selection) {
+    this.currentSelection = selection;
+    this.selectionWasSet = true;
+    return this;
+  }
+  setStoredMarks(marks) {
+    this.currentStoredMarks = marks;
+    this.storedMarksWereSet = true;
+    return this;
+  }
+  setOrigin(origin) {
+    return this.setMeta("origin", origin);
+  }
+  setMeta(key, value) {
+    this.metaValues.set(key, value);
+    return this;
+  }
+  getMeta(key) {
+    return this.metaValues.get(key);
+  }
+  mapPos(pos, assoc = 1, fromStep = 0) {
+    let mapped = pos;
+    for (let i = fromStep; i < this.mapList.length; i++) mapped = this.mapList[i](mapped, assoc);
+    return mapped;
+  }
+};
+
+// src/engine/commands/caret-marks.ts
+function caretMarks(doc, schema, storedMarks, pos) {
+  if (storedMarks !== null) return storedMarks;
+  const inline = blockById(doc, pos.block)?.regions[pos.region] ?? [];
+  return marksAt(inline, pos.offset, (mark) => schema.marks.get(mark.type)?.inclusive ?? true);
+}
+
+// src/engine/commands/run-commands.ts
+var chainDispatches = /* @__PURE__ */ new WeakSet();
+var movesHistory = (tr) => tr.getMeta("history") !== void 0;
+function mergeable(parts) {
+  const moving = parts.filter(movesHistory).length;
+  return moving === 0 || moving === 1 && parts.every((part) => movesHistory(part) || !part.docChanged);
+}
+function combine(initial, parts, final) {
+  if (parts.length === 1) return parts[0];
+  const tr = new Transaction(initial, parts[0].time);
+  for (const part of parts) {
+    part.steps.forEach((step) => tr.step(step));
+    part.meta.forEach((value, key) => key !== UNFILTERED && tr.setMeta(key, value));
+  }
+  const moving = parts.find(movesHistory);
+  const origins = new Set(parts.map((part) => part.origin));
+  if (moving !== void 0) tr.setOrigin(moving.origin);
+  else if (origins.size === 1) tr.setOrigin(parts[0].origin);
+  else tr.setOrigin("command");
+  if (parts.every((part) => part.getMeta(UNFILTERED) === true)) tr.setMeta(UNFILTERED, true);
+  if (parts.some((part) => !part.addToHistory)) tr.setMeta("addToHistory", false);
+  if (parts.some((part) => part.getMeta("closeHistory") === true)) tr.setMeta("closeHistory", true);
+  if (!sameSelection(tr.selection, final.selection)) tr.setSelection(final.selection);
+  if (final.storedMarks !== initial.storedMarks) tr.setStoredMarks(final.storedMarks);
+  return tr;
+}
+function runCommands(state, commands) {
+  let current = state;
+  const parts = [];
+  const collect = (tr) => {
+    parts.push(tr);
+    current = applyTransaction(current, tr);
+  };
+  chainDispatches.add(collect);
+  for (const command of commands) {
+    if (!command(current, collect)) return { ok: false, tr: null };
+  }
+  if (!mergeable(parts)) return { ok: false, tr: null };
+  return { ok: true, tr: parts.length === 0 ? null : combine(state, parts, current) };
+}
+
+// src/engine/transform/position-neutral.ts
+function sameLayout(before, after) {
+  return before.blocks.length === after.blocks.length && before.blocks.every(({ id, indent: indent2 }, index) => id === after.blocks[index].id && indent2 === after.blocks[index].indent);
+}
+function isPositionNeutral(before, { doc, map }) {
+  return map === identityMap && sameLayout(before, doc);
+}
+
+// src/engine/state/history.ts
+var historyKey = createPluginKey("history");
+var HISTORY_PROVIDER = "historyProvider";
+var HISTORY_GROUP = "historyGroup";
+var emptyHistory = { done: [], undone: [], lastTime: 0, lastGroup: null, lastInputRule: null };
+var historyOf = (state) => state.pluginState.get(historyKey.name);
+function invertTransaction(tr) {
+  return tr.steps.map((step, i) => step.invert(tr.docs[i])).reverse();
+}
+var newest = (items, depth) => items.slice(Math.max(0, items.length - depth));
+function groupKey(selection) {
+  return selection?.kind === "text" ? JSON.stringify([selection.head.block, selection.head.region]) : null;
+}
+function groupOf(tr) {
+  if (tr.getMeta("closeHistory") === true) return null;
+  return tr.getMeta(HISTORY_GROUP) ?? (tr.origin === "input" ? groupKey(tr.before.selection) : null);
+}
+function inputRuleRecord(tr, steps) {
+  const rule = tr.getMeta("inputRule");
+  const before = tr.before.selection;
+  if (rule === void 0 || before?.kind !== "text" || !isCollapsed(before)) return null;
+  const { doc, schema, storedMarks } = tr.before;
+  return { steps, undoText: rule.undoText, at: before.head, marks: caretMarks(doc, schema, storedMarks, before.head) };
+}
+function recorded(tr, value, { depth, groupDelay }) {
+  const steps = invertTransaction(tr);
+  const group = groupOf(tr);
+  const last = value.done.at(-1);
+  const merges = last !== void 0 && group !== null && group === value.lastGroup && tr.time - value.lastTime < groupDelay;
+  const done = merges ? [...value.done.slice(0, -1), { ...last, steps: [...steps, ...last.steps] }] : newest([...value.done, { steps, selection: tr.before.selection, origin: tr.origin }], depth);
+  return { done, undone: [], lastTime: tr.time, lastGroup: group, lastInputRule: inputRuleRecord(tr, steps) };
+}
+function moved(tr, value, direction, depth) {
+  const undoing = direction === "undo";
+  const source = undoing ? value.done : value.undone;
+  const applied = source.length - 1 - (tr.getMeta("historySkipped") ?? 0);
+  const inverse = {
+    steps: invertTransaction(tr),
+    selection: tr.before.selection,
+    origin: source[applied]?.origin ?? tr.origin
+  };
+  const rest = source.slice(0, applied);
+  const target = newest([...undoing ? value.undone : value.done, inverse], depth);
+  const stacks = undoing ? { done: rest, undone: target } : { done: target, undone: rest };
+  return { ...value, ...stacks, lastGroup: null, lastInputRule: null };
+}
+var movesNoPosition = (tr) => tr.steps.every((_, i) => isPositionNeutral(tr.docs[i], { doc: tr.docs[i + 1] ?? tr.doc, map: tr.maps[i] }));
+function advance(tr, value, config) {
+  if (tr.docChanged) {
+    const direction = tr.getMeta("history");
+    if (direction !== void 0) return moved(tr, value, direction, config.depth);
+    if (tr.addToHistory && !foreignOrigins.includes(tr.origin)) return recorded(tr, value, config);
+    if (!movesNoPosition(tr)) return emptyHistory;
+  }
+  const closed = tr.getMeta("closeHistory") === true;
+  const relocated = tr.selectionSet && !sameSelection(tr.before.selection, tr.selection);
+  return {
+    ...value,
+    lastGroup: closed ? null : value.lastGroup,
+    lastInputRule: relocated || tr.storedMarksSet ? null : value.lastInputRule
+  };
+}
+function historyPlugin(options = {}) {
+  const config = { depth: options.depth ?? 200, groupDelay: options.groupDelay ?? 500 };
+  return { key: historyKey, init: () => emptyHistory, apply: (tr, value) => advance(tr, value, config) };
+}
+function travel(direction) {
+  return (state, dispatch) => {
+    const provider = state.pluginState.get(HISTORY_PROVIDER);
+    if (provider) return !(dispatch && chainDispatches.has(dispatch)) && provider[direction](!dispatch);
+    const history = historyOf(state);
+    const items = (direction === "undo" ? history?.done : history?.undone) ?? [];
+    for (let i = items.length - 1; i >= 0; i--) {
+      const tr = new Transaction(state).setOrigin("history").setMeta("history", direction);
+      if (!items[i].steps.every((step) => tr.maybeStep(step))) continue;
+      const { selection } = items[i];
+      if (selection !== null) tr.setSelection(selection);
+      dispatch?.(tr.setMeta("historySkipped", items.length - 1 - i));
+      return true;
+    }
+    return false;
+  };
+}
+var undo = travel("undo");
+var redo = travel("redo");
+var undoInputRule = (state, dispatch) => {
+  const record = historyOf(state)?.lastInputRule;
+  if (record === null || record === void 0) return false;
+  if (dispatch !== void 0) {
+    const { steps, undoText, at, marks } = record;
+    const tr = new Transaction(state).setMeta(UNFILTERED, true);
+    steps.forEach((step) => tr.step(step));
+    tr.step(replaceInlineStep(at.block, at.region, at.offset, at.offset, [text(undoText, marks)]));
+    dispatch(tr.setSelection(textSelection({ ...at, offset: at.offset + undoText.length })));
+  }
+  return true;
+};
+
+// src/engine/commands/block-helpers.ts
+var ITEM_KINDS = /* @__PURE__ */ new Set(["bullet", "ordered", "task", "quote"]);
+function specOf(schema, block) {
+  return specFor(schema, block.type);
+}
+function isTextFlow(schema, block) {
+  return specOf(schema, block).flow === "text";
+}
+function isParagraph(block) {
+  return block.type === "MARKDOWN" && block.attrs.kind === "paragraph";
+}
+function isItem(block) {
+  return block.type === "MARKDOWN" && typeof block.attrs.kind === "string" && ITEM_KINDS.has(block.attrs.kind);
+}
+function regionLength(block, region) {
+  return Object.hasOwn(block.regions, region) ? inlineLength(block.regions[region]) : 0;
+}
+function descendantsEnd(doc, index) {
+  const { indent: indent2 } = doc.blocks[index];
+  let end = index + 1;
+  while (end < doc.blocks.length && doc.blocks[end].indent > indent2) end++;
+  return end;
+}
+function createBlock(schema, type, attrs = {}, indent2 = 0, id = newId()) {
+  const initial = specFor(schema, type).initial();
+  return { id, type, indent: indent2, attrs: { ...initial.attrs, ...attrs }, regions: initial.regions };
+}
+function withContent(schema, block, content) {
+  const region = primaryRegion(schema, block) ?? "";
+  return { ...block, regions: { ...block.regions, [region]: content } };
+}
+function startPos(schema, block) {
+  return { block: block.id, region: primaryRegion(schema, block) ?? "", offset: 0 };
+}
+function headBlockId(selection) {
+  if (selection === null) return null;
+  if (selection.kind === "text") return selection.head.block;
+  return selection.kind === "node" ? selection.block : selection.head;
+}
+function selectedBlockRange(doc, selection) {
+  const ids = selectedBlockIds(doc, selection);
+  if (ids.length === 0) return null;
+  const start = indexOfBlock(doc, ids[0]);
+  let end = start + ids.length;
+  for (let index = start; index < start + ids.length; index++) end = Math.max(end, descendantsEnd(doc, index));
+  return { start, end };
+}
+
+// src/engine/commands/cap-indents.ts
+function capIndents(tr, start, end = start) {
+  const { blocks } = tr.doc;
+  const base = start > 0 ? blocks[start - 1].indent : -1;
+  const levels = [];
+  for (let at = start; at < blocks.length; at++) {
+    const { id, indent: indent2 } = blocks[at];
+    let sibling;
+    while (levels.length > 0 && levels[levels.length - 1].from >= indent2) sibling = levels.pop();
+    const parent = levels.length > 0 ? levels[levels.length - 1].to : base;
+    const next = sibling?.from === indent2 ? sibling.to : Math.min(indent2, parent + 1);
+    if (next === indent2 && at >= end) return;
+    if (next !== indent2) tr.step(setIndentStep(id, next));
+    levels.push({ from: indent2, to: next });
+  }
+}
+
+// src/engine/commands/remove-blocks.ts
+function removeBlocks(tr, schema, index, count2) {
+  const before = tr.doc.blocks[index - 1];
+  const after = tr.doc.blocks[index + count2];
+  tr.step(removeBlocksStep(index, count2));
+  capIndents(tr, index);
+  if (before !== void 0) tr.setSelection(endOf(tr.doc, schema, before.id));
+  else tr.setSelection(after === void 0 ? null : startOf(tr.doc, schema, after.id));
+}
+
+// src/engine/commands/shift-subtree.ts
+function shiftSubtree(tr, index, delta) {
+  const { doc } = tr;
+  for (const block of doc.blocks.slice(index, descendantsEnd(doc, index))) {
+    tr.step(setIndentStep(block.id, block.indent + delta));
+  }
+}
+
+// src/engine/commands/block-structure.ts
+var toggleTask = (state, dispatch) => {
+  const { doc, selection } = state;
+  const tasks = selectedBlockIds(doc, selection).map((id) => doc.blocks[requireBlockIndex(doc, id)]).filter((block) => block.type === "MARKDOWN" && block.attrs.kind === "task");
+  if (tasks.length === 0) return false;
+  const checked = !tasks.every((block) => block.attrs.checked === true);
+  const tr = new Transaction(state);
+  for (const block of tasks) tr.step(setAttrsStep(block.id, { checked }));
+  dispatch?.(tr);
+  return true;
+};
+function reindentCommand(delta) {
+  return (state, dispatch) => {
+    const { doc } = state;
+    const range = selectedBlockRange(doc, state.selection);
+    if (range === null) return false;
+    const before = range.start > 0 ? doc.blocks[range.start - 1].indent : -1;
+    const tr = new Transaction(state);
+    for (let root = range.start; root < range.end; root = descendantsEnd(doc, root)) {
+      const shift = delta(doc.blocks[root].indent, before);
+      if (shift !== 0) shiftSubtree(tr, root, shift);
+    }
+    if (!tr.docChanged) return false;
+    dispatch?.(tr);
+    return true;
+  };
+}
+var indent = reindentCommand((root, before) => root <= before ? 1 : 0);
+var outdent = reindentCommand((root) => root > 0 ? -1 : 0);
+function moveTarget(doc, range, direction) {
+  if (direction === "up") {
+    if (range.start === 0) return null;
+    let root = range.start - 1;
+    while (root > 0 && doc.blocks[root].indent > doc.blocks[range.start].indent) root--;
+    return root;
+  }
+  if (range.end >= doc.blocks.length) return null;
+  return descendantsEnd(doc, range.end) - (range.end - range.start);
+}
+function moveCommand(direction) {
+  return (state, dispatch) => {
+    const { doc } = state;
+    const range = selectedBlockRange(doc, state.selection);
+    const to = range === null ? null : moveTarget(doc, range, direction);
+    if (range === null || to === null) return false;
+    const count2 = range.end - range.start;
+    const tr = new Transaction(state).step(moveBlocksStep(range.start, count2, to));
+    capIndents(tr, to);
+    capIndents(tr, to + count2);
+    dispatch?.(tr);
+    return true;
+  };
+}
+var moveBlocksUp = moveCommand("up");
+var moveBlocksDown = moveCommand("down");
+function copiedSelection(selection, copies) {
+  const copy = (id) => copies.get(id) ?? id;
+  const copyPos = (pos) => ({ ...pos, block: copy(pos.block) });
+  switch (selection.kind) {
+    case "text":
+      return textSelection(copyPos(selection.anchor), copyPos(selection.head));
+    case "node":
+      return nodeSelection(copy(selection.block));
+    case "blocks":
+      return blockRangeSelection(copy(selection.anchor), copy(selection.head));
+  }
+}
+function duplicateBlocks(options = {}) {
+  const makeId = options.newId ?? newId;
+  return (state, dispatch) => {
+    const { doc, selection } = state;
+    const range = selectedBlockRange(doc, selection);
+    if (range === null || selection === null) return false;
+    const blocks = doc.blocks.slice(range.start, range.end).map((block) => ({ ...block, id: makeId() }));
+    const copies = new Map(blocks.map((copy, i) => [doc.blocks[range.start + i].id, copy.id]));
+    const tr = new Transaction(state).step(insertBlocksStep(range.end, blocks));
+    capIndents(tr, range.end);
+    dispatch?.(tr.setSelection(copiedSelection(selection, copies)));
+    return true;
+  };
+}
+var deleteBlocks = (state, dispatch) => {
+  const range = selectedBlockRange(state.doc, state.selection);
+  if (range === null) return false;
+  const tr = new Transaction(state);
+  removeBlocks(tr, state.schema, range.start, range.end - range.start);
+  dispatch?.(tr);
+  return true;
+};
+function insertBlockAfter(type, attrs, options = {}) {
+  const makeId = options.newId ?? newId;
+  return (state, dispatch) => {
+    const { doc, schema } = state;
+    const id = headBlockId(state.selection);
+    if (id === null) return false;
+    const index = requireBlockIndex(doc, id);
+    const current = doc.blocks[index];
+    const fillsCurrent = isParagraph(current) && regionLength(current, primaryRegion(schema, current) ?? "") === 0;
+    const block = createBlock(schema, type, attrs, current.indent, fillsCurrent ? current.id : makeId());
+    const step = fillsCurrent ? replaceBlockStep(block) : insertBlocksStep(descendantsEnd(doc, index), [block]);
+    const tr = new Transaction(state).step(step);
+    dispatch?.(tr.setSelection(startOf(tr.doc, schema, block.id)));
+    return true;
+  };
+}
+
+// src/engine/commands/delete-range.ts
+function clear(tr, pos, start, end) {
+  if (start < end) tr.step(replaceInlineStep(pos.block, pos.region, start, end, []));
+}
+function deleteWithinBlock(tr, from, to) {
+  if (from.region === to.region) {
+    clear(tr, from, from.offset, to.offset);
+    return from;
+  }
+  const block = tr.doc.blocks[requireBlockIndex(tr.doc, from.block)];
+  clear(tr, from, from.offset, regionLength(block, from.region));
+  for (const region of Object.keys(block.regions)) {
+    const between = compareRegionNames(from.region, region) < 0 && compareRegionNames(region, to.region) < 0;
+    if (between) clear(tr, { ...from, region }, 0, regionLength(block, region));
+  }
+  clear(tr, to, 0, to.offset);
+  return from;
+}
+function deleteRange(tr, schema, from, to, newId2) {
+  if (from.block === to.block) return deleteWithinBlock(tr, from, to);
+  const { doc } = tr;
+  const start = requireBlockIndex(doc, from.block);
+  const end = requireBlockIndex(doc, to.block);
+  const first = doc.blocks[start];
+  const last = doc.blocks[end];
+  const keepFirst = isTextFlow(schema, first);
+  const keepLast = isTextFlow(schema, last);
+  if (keepFirst) clear(tr, from, from.offset, regionLength(first, from.region));
+  if (keepLast) clear(tr, to, 0, to.offset);
+  const removeFrom = keepFirst ? start + 1 : start;
+  const removeTo = keepLast ? end : end + 1;
+  if (removeTo > removeFrom) tr.step(removeBlocksStep(removeFrom, removeTo - removeFrom));
+  if (keepFirst) {
+    if (keepLast) tr.step(joinBlocksStep(first.id, from.region, last.id, to.region));
+    capIndents(tr, start + 1);
+    return from;
+  }
+  if (keepLast) {
+    capIndents(tr, start);
+    return { block: last.id, region: to.region, offset: 0 };
+  }
+  const filler = createBlock(schema, schema.defaultTextBlock, {}, first.indent, newId2?.());
+  tr.step(insertBlocksStep(removeFrom, [filler]));
+  capIndents(tr, start + 1);
+  return startPos(schema, filler);
+}
+
+// src/engine/commands/insert-text-at.ts
+function insertTextAt(tr, schema, pos, value) {
+  const slice = [text(value, caretMarks(tr.doc, schema, tr.storedMarks, pos))];
+  tr.step(replaceInlineStep(pos.block, pos.region, pos.offset, pos.offset, slice));
+  return { ...pos, offset: pos.offset + value.length };
+}
+
+// src/engine/commands/insert-text.ts
+function replaceBlocksWithText(tr, schema, range, value, makeId) {
+  const { doc } = tr;
+  const index = range === null ? doc.blocks.length : range.start;
+  const indent2 = range === null ? 0 : doc.blocks[index].indent;
+  if (range !== null) tr.step(removeBlocksStep(index, range.end - range.start));
+  const empty = createBlock(schema, schema.defaultTextBlock, {}, indent2, makeId());
+  const paragraph = withContent(schema, empty, [text(value)]);
+  tr.step(insertBlocksStep(index, [paragraph]));
+  tr.setSelection(endOf(tr.doc, schema, paragraph.id));
+}
+function insertText(value, options = {}) {
+  const makeId = options.newId ?? newId;
+  return (state, dispatch) => {
+    if (value === "") return false;
+    const { doc, schema, selection } = state;
+    const tr = new Transaction(state).setOrigin(options.origin ?? "command");
+    if (selection?.kind === "text") {
+      const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+      const caret = deleteRange(tr, schema, from, to, makeId);
+      tr.setSelection(textSelection(insertTextAt(tr, schema, caret, value)));
+    } else {
+      replaceBlocksWithText(tr, schema, selectedBlockRange(doc, selection), value, makeId);
+    }
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/commands/mark-extent.ts
+function markExtent(inline, offset, type) {
+  const starts = [];
+  let position = 0;
+  for (const node of inline) {
+    starts.push(position);
+    position += nodeLength(node);
+  }
+  const containing = (at) => inline.findIndex((node, i) => starts[i] <= at && at < starts[i] + nodeLength(node));
+  const markOf = (index) => inline[index]?.marks.find((mark2) => mark2.type === type);
+  let seed = containing(offset);
+  let mark = markOf(seed);
+  if (mark === void 0) {
+    seed = containing(offset - 1);
+    mark = markOf(seed);
+  }
+  if (mark === void 0) return null;
+  const shares = (index) => inline[index].marks.some((other) => sameMark(other, mark));
+  let first = seed;
+  while (first > 0 && shares(first - 1)) first--;
+  let last = seed;
+  while (last < inline.length - 1 && shares(last + 1)) last++;
+  return { from: starts[first], to: starts[last] + nodeLength(inline[last]) };
+}
+
+// src/engine/commands/storable-mark.ts
+function readsBack(inline) {
+  return equalInline(parseInline(serializeInline(inline)), normalizeInline(inline));
+}
+function safeLink(mark) {
+  const href = mark.attrs?.href;
+  const safe = typeof href === "string" ? sanitizeHref(href) : null;
+  return safe ? { type: "link", attrs: { ...mark.attrs, href: safe } } : null;
+}
+function storableMark(mark) {
+  const candidate = mark.type === "link" ? safeLink(mark) : mark;
+  return candidate !== null && readsBack([text("a", [candidate])]) ? candidate : null;
+}
+function storableAtom(type, attrs) {
+  return readsBack([atom(type, attrs)]);
+}
+
+// src/engine/commands/selection-marks.ts
+function matchesMark(mark, type, attrs) {
+  return mark.type === type && Object.entries(attrs ?? {}).every(([key, value]) => mark.attrs?.[key] === value);
+}
+function wholeRegion(schema, block) {
+  const region = primaryRegion(schema, block);
+  if (!isTextFlow(schema, block) || region === null) return null;
+  return { block: block.id, region, from: 0, to: regionLength(block, region) };
+}
+function textRanges(state, selection) {
+  const { doc, schema } = state;
+  const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+  if (from.block === to.block) {
+    if (from.region !== to.region) return [];
+    return [{ block: from.block, region: from.region, from: from.offset, to: to.offset }];
+  }
+  const first = requireBlockIndex(doc, from.block);
+  const last = requireBlockIndex(doc, to.block);
+  return doc.blocks.slice(first, last + 1).flatMap((block, i) => {
+    const whole = wholeRegion(schema, block);
+    if (whole === null) return [];
+    const startsHere = i === 0 && from.region === whole.region;
+    const endsHere = first + i === last && to.region === whole.region;
+    return [{ ...whole, from: startsHere ? from.offset : 0, to: endsHere ? to.offset : whole.to }];
+  });
+}
+function selectionRanges(state, selection) {
+  if (selection.kind === "text") return textRanges(state, selection);
+  return selectedBlockIds(state.doc, selection).flatMap((id) => {
+    const whole = wholeRegion(state.schema, state.doc.blocks[requireBlockIndex(state.doc, id)]);
+    return whole === null ? [] : [whole];
+  });
+}
+function markRanges(state) {
+  const { selection } = state;
+  return selection === null ? [] : selectionRanges(state, selection).filter((range) => range.from < range.to);
+}
+function rangeContent(state, range) {
+  const inline = blockById(state.doc, range.block)?.regions[range.region] ?? [];
+  return sliceInline(inline, range.from, range.to);
+}
+function markCoverage(content, type, attrs) {
+  const carries = (node) => node.marks.some((mark) => matchesMark(mark, type, attrs));
+  return { some: content.some(carries), every: content.every(carries) };
+}
+function selectionHasMark(state, type, attrs) {
+  const { selection } = state;
+  if (selection?.kind === "text" && isCollapsed(selection)) {
+    const marks = caretMarks(state.doc, state.schema, state.storedMarks, selection.head);
+    return marks.some((mark) => matchesMark(mark, type, attrs));
+  }
+  const ranges = markRanges(state);
+  return ranges.length > 0 && ranges.every((range) => markCoverage(rangeContent(state, range), type, attrs).every);
+}
+
+// src/engine/commands/marks.ts
+var KEPT_ON_CLEAR = /* @__PURE__ */ new Set(["link", "comment"]);
+function makeMark(type, attrs) {
+  return attrs !== void 0 && Object.keys(attrs).length > 0 ? { type, attrs } : { type };
+}
+function collapsedCaret(state) {
+  const { selection } = state;
+  return selection?.kind === "text" && isCollapsed(selection) ? selection.head : null;
+}
+function editRanges(state, dispatch, ranges, edit) {
+  const tr = new Transaction(state);
+  for (const range of ranges) edit(tr, range, rangeContent(state, range));
+  if (!tr.docChanged) return false;
+  dispatch?.(tr);
+  return true;
+}
+function applyMark(type, attrs, mode) {
+  return (state, dispatch) => {
+    const requested = makeMark(type, attrs);
+    const mark = mode === "remove" ? requested : storableMark(requested);
+    if (mark === null) return false;
+    const target = mark.attrs === void 0 ? type : mark;
+    const caret = collapsedCaret(state);
+    if (caret !== null) {
+      const current = caretMarks(state.doc, state.schema, state.storedMarks, caret);
+      const active = current.some((existing) => matchesMark(existing, type, mark.attrs));
+      const remove2 = mode === "remove" || mode === "toggle" && active;
+      const next = remove2 ? removeMark(current, target) : addMark(current, mark);
+      if (sameMarkSet(next, current)) return false;
+      dispatch?.(new Transaction(state).setStoredMarks(next));
+      return true;
+    }
+    const remove = mode === "remove" || mode === "toggle" && selectionHasMark(state, type, mark.attrs);
+    return editRanges(state, dispatch, markRanges(state), (tr, { block, region, from, to }, content) => {
+      const coverage = markCoverage(content, type, mark.attrs);
+      if (remove && coverage.some) tr.step(removeMarkStep(block, region, from, to, target));
+      if (!remove && !coverage.every) tr.step(addMarkStep(block, region, from, to, mark));
+    });
+  };
+}
+function toggleMark(type, attrs) {
+  return applyMark(type, attrs, "toggle");
+}
+function setMark(type, attrs) {
+  return applyMark(type, attrs, "add");
+}
+function unsetMark(type) {
+  return applyMark(type, void 0, "remove");
+}
+function linkRanges(state) {
+  const caret = collapsedCaret(state);
+  if (caret === null) return markRanges(state);
+  const inline = blockById(state.doc, caret.block)?.regions[caret.region] ?? [];
+  const extent = markExtent(inline, caret.offset, "link");
+  return extent === null ? [] : [{ block: caret.block, region: caret.region, ...extent }];
+}
+function setLink(href, title) {
+  const safe = sanitizeHref(href);
+  return (state, dispatch) => {
+    if (safe === null || safe === "") return false;
+    const link = { type: "link", attrs: title ? { href: safe, title } : { href: safe } };
+    return editRanges(state, dispatch, linkRanges(state), (tr, { block, region, from, to }, content) => {
+      const linked2 = content.every((node) => node.marks.some((mark) => sameMark(mark, link)));
+      if (!linked2) tr.step(addMarkStep(block, region, from, to, link));
+    });
+  };
+}
+var unsetLink = (state, dispatch) => editRanges(state, dispatch, linkRanges(state), (tr, { block, region, from, to }, content) => {
+  if (markCoverage(content, "link").some) tr.step(removeMarkStep(block, region, from, to, "link"));
+});
+var clearFormatting = (state, dispatch) => {
+  const clearable = (mark) => !KEPT_ON_CLEAR.has(mark.type);
+  const caret = collapsedCaret(state);
+  if (caret !== null) {
+    const current = caretMarks(state.doc, state.schema, state.storedMarks, caret);
+    const kept = current.filter((mark) => !clearable(mark));
+    if (kept.length === current.length) return false;
+    dispatch?.(new Transaction(state).setStoredMarks(kept));
+    return true;
+  }
+  return editRanges(state, dispatch, markRanges(state), (tr, { block, region, from, to }, content) => {
+    const types = new Set(content.flatMap((node) => node.marks.filter(clearable).map((mark) => mark.type)));
+    for (const type of types) tr.step(removeMarkStep(block, region, from, to, type));
+  });
+};
+function insertAtom(type, attrs) {
+  return (state, dispatch) => {
+    const { doc, schema, selection } = state;
+    if (selection?.kind !== "text" || !storableAtom(type, attrs)) return false;
+    const tr = new Transaction(state);
+    const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+    const caret = deleteRange(tr, schema, from, to);
+    const node = atom(type, attrs, caretMarks(tr.doc, schema, tr.storedMarks, caret));
+    tr.step(replaceInlineStep(caret.block, caret.region, caret.offset, caret.offset, [node]));
+    tr.setSelection(textSelection({ ...caret, offset: caret.offset + 1 }));
+    dispatch?.(tr);
+    return true;
+  };
+}
+function insertMention(mention) {
+  const { id, label, kind } = mention;
+  return insertAtom("mention", kind === void 0 ? { id, label } : { id, label, kind });
+}
+
+// src/engine/commands/turn-into.ts
+var TEXT_ATTRIBUTE = /* @__PURE__ */ new Map([
+  ["CODE", "code"],
+  ["MATH", "latex"]
+]);
+function holdsText(schema, type) {
+  return TEXT_ATTRIBUTE.has(type) || specFor(schema, type).flow === "text";
+}
+function sourceContent(schema, block) {
+  const field = TEXT_ATTRIBUTE.get(block.type);
+  if (field !== void 0) {
+    const value = block.attrs[field];
+    return typeof value === "string" && value !== "" ? [text(value)] : [];
+  }
+  const region = primaryRegion(schema, block);
+  return region === null ? [] : block.regions[region];
+}
+function plainText(schema, content) {
+  return inlineText(content, (node) => schema.atoms.get(node.type)?.plainText(node.attrs) ?? "");
+}
+function convert(schema, block, type, attrs) {
+  const content = sourceContent(schema, block);
+  const field = TEXT_ATTRIBUTE.get(type);
+  const withText = field === void 0 ? attrs : { ...attrs, [field]: plainText(schema, content) };
+  const created = createBlock(schema, type, withText, block.indent, block.id);
+  return field === void 0 ? withContent(schema, created, content) : created;
+}
+function sameTypePatch(type, attrs) {
+  if (type !== "MARKDOWN") return attrs;
+  return { kind: "paragraph", level: void 0, checked: void 0, start: void 0, ...attrs };
+}
+function setBlockType(type, attrs = {}) {
+  return (state, dispatch) => {
+    const { doc, schema, selection } = state;
+    if (!holdsText(schema, type)) return false;
+    const ids = selectedBlockIds(doc, selection);
+    const convertible = (block) => isTextFlow(schema, block) || selection?.kind === "node" && TEXT_ATTRIBUTE.has(block.type);
+    const blocks = ids.flatMap((id) => blockById(doc, id) ?? []).filter(convertible);
+    if (blocks.length === 0) return false;
+    const tr = new Transaction(state);
+    const moved2 = /* @__PURE__ */ new Map();
+    for (const block of blocks) {
+      if (block.type === type) {
+        const patch = sameTypePatch(type, attrs);
+        if (patchChangesAttrs(block.attrs, patch)) tr.step(setAttrsStep(block.id, patch));
+        continue;
+      }
+      const next = convert(schema, block, type, attrs);
+      tr.step(replaceBlockStep(next));
+      const from = primaryRegion(schema, block);
+      const to = primaryRegion(schema, next);
+      if (from !== null && to !== null) moved2.set(block.id, { from, to, length: inlineLength(next.regions[to]) });
+    }
+    if (!tr.docChanged) return false;
+    if (selection?.kind === "text" && moved2.size > 0) {
+      const carry = (pos) => {
+        const entry = moved2.get(pos.block);
+        if (entry === void 0 || pos.region !== entry.from) return pos;
+        return { block: pos.block, region: entry.to, offset: Math.min(pos.offset, entry.length) };
+      };
+      tr.setSelection(textSelection(carry(selection.anchor), carry(selection.head)));
+    }
+    const converted = selection?.kind === "node" ? blockById(tr.doc, selection.block) : void 0;
+    if (converted !== void 0 && isTextFlow(schema, converted)) tr.setSelection(endOf(tr.doc, schema, converted.id));
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/rules/input-rule.ts
+function appliesTo(rule, block) {
+  const { blockTypes, kinds } = rule;
+  const { kind } = block.attrs;
+  if (blockTypes !== void 0 && !blockTypes.includes(block.type)) return false;
+  return kinds === void 0 || typeof kind === "string" && kinds.includes(kind);
+}
+function ruleTransaction(state, rules, context) {
+  const { selection, doc } = state;
+  if (selection?.kind !== "text") return null;
+  const { block: id, region, offset } = selection.head;
+  const block = doc.blocks[requireBlockIndex(doc, id)];
+  const inline = block.regions[region];
+  if (hasMark(marksAt(inline, offset, () => true), "code")) return null;
+  const before = inlineText(sliceInline(inline, 0, offset));
+  for (const rule of rules) {
+    const match = appliesTo(rule, block) ? rule.match.exec(before) : null;
+    if (match === null) continue;
+    const tr = rule.handler(state, match, { block: id, region, from: match.index, to: offset }, context);
+    if (tr !== null) return tr;
+  }
+  return null;
+}
+function insertTextWithRules(value, rules, options = {}) {
+  const context = { newId: options.newId ?? newId };
+  const insert = insertText(value, { origin: "input", newId: context.newId });
+  return (state, dispatch) => {
+    let fired = false;
+    const applyRules = (current, emit2) => {
+      const tr2 = ruleTransaction(current, rules, context);
+      if (tr2 !== null) {
+        fired = true;
+        emit2?.(tr2.setOrigin("input"));
+      }
+      return true;
+    };
+    const { ok, tr } = runCommands(state, [insert, applyRules]);
+    if (!ok || tr === null) return false;
+    if (fired) tr.setMeta("inputRule", { undoText: value });
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/rules/convert-prefix.ts
+function convertPrefix(state, range, convert2) {
+  const { block, region, from, to } = range;
+  const removePrefix = (current, dispatch) => {
+    dispatch?.(new Transaction(current).step(replaceInlineStep(block, region, from, to, [])));
+    return true;
+  };
+  return runCommands(state, [removePrefix, convert2]).tr;
+}
+
+// src/engine/rules/block-rules.ts
+var PARAGRAPH = ["paragraph"];
+function lineRule(name, match, attrs, kinds = PARAGRAPH) {
+  return {
+    name,
+    match,
+    blockTypes: ["MARKDOWN"],
+    kinds,
+    handler: (state, found, range) => convertPrefix(state, range, setBlockType("MARKDOWN", attrs(found)))
+  };
+}
+var divider = {
+  name: "divider",
+  match: /^(?:---|[\u2013\u2014]-|\*\*\*|___)$/,
+  blockTypes: ["MARKDOWN"],
+  kinds: PARAGRAPH,
+  handler(state, _match, range, context) {
+    const { doc, schema } = state;
+    const index = requireBlockIndex(doc, range.block);
+    const block = doc.blocks[index];
+    const content = block.regions[range.region];
+    const tail = sliceInline(content, range.to, inlineLength(content));
+    const empty = createBlock(schema, schema.defaultTextBlock, {}, block.indent, (context?.newId ?? newId)());
+    const next = withContent(schema, empty, tail);
+    const tr = new Transaction(state);
+    tr.step(replaceBlockStep(createBlock(schema, "DIVIDER", {}, block.indent, block.id)));
+    tr.step(insertBlocksStep(index + 1, [next]));
+    return tr.setSelection(startOf(tr.doc, schema, next.id));
+  }
+};
+var blockInputRules = [
+  lineRule("heading", /^(#{1,6}) $/, (m) => ({ kind: "heading", level: m[1].length })),
+  lineRule("bullet", /^[-*+] $/, () => ({ kind: "bullet" })),
+  lineRule("ordered", /^(\d{1,9})[.)] $/, (m) => ({ kind: "ordered", start: Number(m[1]) })),
+  lineRule("task", /^\[( |x|X)?\] $/, (m) => ({ kind: "task", checked: m[1] === "x" || m[1] === "X" }), [
+    "paragraph",
+    "bullet"
+  ]),
+  lineRule("quote", /^> $/, () => ({ kind: "quote" })),
+  divider,
+  {
+    name: "math",
+    match: /^\$\$ $/,
+    blockTypes: ["MARKDOWN"],
+    kinds: PARAGRAPH,
+    handler: (state, _match, range) => convertPrefix(state, range, setBlockType("MATH"))
+  },
+  {
+    name: "code",
+    match: /^```([\w+#.-]*) $/,
+    blockTypes: ["MARKDOWN"],
+    kinds: PARAGRAPH,
+    handler: (state, found, range) => convertPrefix(state, range, setBlockType("CODE", { language: found[1] }))
+  }
+];
+
+// src/engine/markdown/autolink-href.ts
+function autolinkHref(url) {
+  return sanitizeHref(/^www\./i.test(url) ? `https://${url}` : url);
+}
+
+// src/engine/markdown/trim-url-end.ts
+var TRAILING_PUNCTUATION = `?!.,:;*_~'"`;
+function count(value, char) {
+  return value.split(char).length - 1;
+}
+function trimUrlEnd(url) {
+  let end = url.length;
+  while (end > 0) {
+    const last = url[end - 1];
+    const kept = url.slice(0, end);
+    const unbalanced = last === ")" && count(kept, ")") > count(kept, "(");
+    if (!TRAILING_PUNCTUATION.includes(last) && !unbalanced) break;
+    end -= 1;
+  }
+  return url.slice(0, end);
+}
+
+// src/engine/rules/region-inline.ts
+function regionInline(state, range) {
+  return state.doc.blocks[requireBlockIndex(state.doc, range.block)].regions[range.region];
+}
+
+// src/engine/rules/touches-mark.ts
+function touchesMark(inline, from, to, type) {
+  return sliceInline(inline, from, to).some((node) => hasMark(node.marks, type));
+}
+
+// src/engine/rules/autolink.ts
+var autolinkRule = {
+  name: "autolink",
+  match: /(?:^|[\s(])((https?:\/\/|www\.)[^\s\uFFFC]+) $/i,
+  handler(state, match, range) {
+    const url = trimUrlEnd(match[1]);
+    const href = url.length > match[2].length ? autolinkHref(url) : null;
+    const inline = regionInline(state, range);
+    const from = range.to - 1 - match[1].length;
+    const to = from + url.length;
+    if (href === null) return null;
+    if (touchesMark(inline, from, to, "link") || touchesMark(inline, from, to, "code")) return null;
+    const link = { type: "link", attrs: { href } };
+    return new Transaction(state).step(addMarkStep(range.block, range.region, from, to, link));
+  }
+};
+
+// src/engine/rules/mark-rule.ts
+var WORD_CHARACTER = /[\p{L}\p{N}]/u;
+function markRule({ name, match, open, close, wordBounded = false, mark }) {
+  return {
+    name,
+    match,
+    handler(state, found, range) {
+      const added = mark(found);
+      if (added === null) return null;
+      const { block, region, to } = range;
+      const inline = regionInline(state, range);
+      const contentTo = to - (close?.(found) ?? open);
+      const contentFrom = contentTo - found[1].length;
+      const from = contentFrom - open;
+      if (wordBounded && WORD_CHARACTER.test(inlineText(sliceInline(inline, to, to + 1)))) return null;
+      if (touchesMark(inline, from, contentFrom, "code") || touchesMark(inline, contentTo, to, "code")) return null;
+      const tr = new Transaction(state);
+      tr.step(addMarkStep(block, region, contentFrom, contentTo, added));
+      tr.step(replaceInlineStep(block, region, contentTo, to, []));
+      tr.step(replaceInlineStep(block, region, from, contentFrom, []));
+      const caret = { block, region, offset: from + found[1].length };
+      const carried = caretMarks(tr.doc, state.schema, null, caret);
+      return tr.setSelection(textSelection(caret)).setStoredMarks(removeMark(carried, added.type));
+    }
+  };
+}
+
+// src/engine/rules/mark-rules.ts
+function typed(name, match, open, type, wordBounded = false) {
+  return markRule({ name, match, open, wordBounded, mark: () => ({ type }) });
+}
+var markInputRules = [
+  typed("bold-asterisks", /\*\*([^\s*](?:[^*]*[^\s*])?)\*\*$/, 2, "bold"),
+  typed("bold-underscores", /(?:^|[^\p{L}\p{N}_])__([^\s_](?:[^_]*[^\s_])?)__$/u, 2, "bold", true),
+  typed("strike", /~~([^\s~](?:[^~]*[^\s~])?)~~$/, 2, "strike"),
+  typed("code", /`([^\s`](?:[^`]*[^\s`])?)`$/, 1, "code"),
+  typed("highlight", /==([^\s=](?:[^=]*[^\s=])?)==$/, 2, "highlight"),
+  markRule({
+    name: "link",
+    match: /\[([^\s[\]](?:[^[\]]*[^\s[\]])?)\]\(((?:[^\s()]|\((?:[^\s()]|\([^\s()]*\))*\))+)\)$/,
+    open: 1,
+    close: (match) => match[2].length + 3,
+    mark(match) {
+      const href = sanitizeHref(match[2]);
+      return href === null ? null : { type: "link", attrs: { href } };
+    }
+  }),
+  typed("italic-asterisk", /(?:^|[^*])\*([^\s*](?:[^*]*[^\s*])?)\*$/, 1, "italic"),
+  typed("italic-underscore", /(?:^|[^\p{L}\p{N}_])_([^\s_](?:[^_]*[^\s_])?)_$/u, 1, "italic", true),
+  autolinkRule
+];
+
+// src/engine/rules/typography.ts
+var OPENING_CONTEXT = /[\s([{\u2018\u201C\u2014\u2013]/;
+function replacing(name, match, replacement) {
+  return {
+    name,
+    match,
+    handler(state, found, range) {
+      const value = typeof replacement === "string" ? replacement : replacement(found);
+      const from = range.to - (found[1] ?? found[0]).length;
+      const node = text(value, marksAt(regionInline(state, range), range.to, () => true));
+      return new Transaction(state).step(replaceInlineStep(range.block, range.region, from, range.to, [node]));
+    }
+  };
+}
+function quote(opening, closing2) {
+  return (match) => {
+    const before = match.input[match.index - 1];
+    return before === void 0 || OPENING_CONTEXT.test(before) ? opening : closing2;
+  };
+}
+function typographyRules(options = {}) {
+  const { dashes = "none" } = options;
+  const dash = dashes === "em" ? "\u2014" : "\u2013";
+  return [
+    replacing("double-quote", /"$/, quote("\u201C", "\u201D")),
+    replacing("single-quote", /'$/, quote("\u2018", "\u2019")),
+    replacing("ellipsis", /\.\.\.$/, "\u2026"),
+    replacing("arrow-right", /->$/, "\u2192"),
+    replacing("arrow-left", /<-$/, "\u2190"),
+    replacing("double-arrow", /=>$/, "\u21D2"),
+    replacing("copyright", /\(c\)$/, "\xA9"),
+    replacing("registered", /\(r\)$/, "\xAE"),
+    replacing("trademark", /\(tm\)$/, "\u2122"),
+    replacing("one-half", /(?:^|[^\d/])(1\/2)$/, "\xBD"),
+    replacing("one-quarter", /(?:^|[^\d/])(1\/4)$/, "\xBC"),
+    replacing("three-quarters", /(?:^|[^\d/])(3\/4)$/, "\xBE"),
+    ...dashes === "none" ? [] : [replacing("dash", /--$/, dash)]
+  ];
+}
+
+// src/engine/clipboard/html-context.ts
+var PARAGRAPH2 = { kind: "paragraph" };
+var child = (ctx, patch = {}) => ({
+  ...ctx,
+  ...patch,
+  depth: ctx.depth + 1
+});
+function emit(sink, type, indent2, attrs, regions) {
+  sink.out.push({ id: sink.newId(), type, indent: indent2, attrs, regions });
+}
+var emitText = (sink, indent2, attrs, content) => emit(sink, "MARKDOWN", indent2, attrs, { text: content });
+
+// src/engine/clipboard/html-dom.ts
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var MAX_DEPTH = 100;
+var DROPPED = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "head",
+  "meta",
+  "link",
+  "title",
+  "template",
+  "noscript",
+  "svg",
+  "iframe",
+  "object",
+  "embed",
+  "canvas",
+  "audio",
+  "video",
+  "select",
+  "textarea",
+  "button",
+  "o:p"
+]);
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "body",
+  "caption",
+  "center",
+  "dd",
+  "details",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+]);
+var isElement = (node) => node.nodeType === ELEMENT_NODE;
+var tagName = (element) => element.localName.toLowerCase();
+var isFragmentRoot = ({ parentElement }) => parentElement !== null && tagName(parentElement) === "body";
+var isDropped = (element) => DROPPED.has(tagName(element));
+var isBlockTag = (element) => BLOCK_TAGS.has(tagName(element));
+var isBlockLevel = (element) => isBlockTag(element) || tagName(element) === "img";
+function hasClass(element, name) {
+  return (element.getAttribute("class") ?? "").split(/\s+/).includes(name);
+}
+function hasBlockDescendant(node, depth = 0) {
+  if (depth > MAX_DEPTH) return false;
+  for (const child2 of Array.from(node.childNodes)) {
+    if (!isElement(child2) || isDropped(child2)) continue;
+    if (isBlockLevel(child2) || hasBlockDescendant(child2, depth + 1)) return true;
+  }
+  return false;
+}
+var breaksRun = (node) => isElement(node) && !isDropped(node) && (isBlockLevel(node) || hasBlockDescendant(node));
+function flatText(root) {
+  const parts = [];
+  const pending = [root];
+  for (let node = pending.pop(); node !== void 0; node = pending.pop()) {
+    if (node.nodeType === TEXT_NODE) parts.push(node.nodeValue ?? "");
+    else if (!isElement(node) || !isDropped(node)) {
+      for (let part = node.lastChild; part !== null; part = part.previousSibling) pending.push(part);
+    }
+  }
+  return parts.join("");
+}
+
+// src/engine/clipboard/html-code.ts
+var LANGUAGE = /(?:^|\s)(?:language|lang)-(\S+)/;
+function preText(node, depth = 0) {
+  if (node.nodeType === TEXT_NODE) return node.nodeValue ?? "";
+  if (!isElement(node)) return "";
+  if (tagName(node) === "br") return "\n";
+  if (depth > MAX_DEPTH) return flatText(node);
+  const text2 = Array.from(node.childNodes).map((part) => preText(part, depth + 1)).join("");
+  return depth > 0 && isBlockTag(node) && !text2.endsWith("\n") ? `${text2}
+` : text2;
+}
+var languageOf = (element) => element === null ? void 0 : LANGUAGE.exec(element.getAttribute("class") ?? "")?.[1];
+function codeBlock(pre, ctx, sink) {
+  const code = preText(pre).replace(/\r\n?/g, "\n").replace(/\n$/, "");
+  const language = languageOf(pre) ?? languageOf(pre.querySelector("code")) ?? "";
+  emit(sink, "CODE", ctx.indent, { language, code }, {});
+}
+
+// src/engine/markdown/palette-rgb.ts
+var PALETTE_RGB = {
+  text: {
+    default: [[55, 53, 47]],
+    gray: [[120, 119, 116], [155, 154, 151], [190, 190, 188]],
+    brown: [[159, 107, 83], [100, 71, 58]],
+    orange: [[217, 115, 13]],
+    yellow: [[203, 145, 47], [223, 171, 1]],
+    green: [[68, 131, 97], [15, 123, 108]],
+    blue: [[51, 126, 169], [11, 110, 153]],
+    purple: [[144, 101, 176], [105, 64, 165]],
+    pink: [[193, 76, 138], [173, 26, 114]],
+    red: [[212, 76, 71], [224, 62, 62]]
+  },
+  background: {
+    default: [[255, 255, 255]],
+    gray: [[241, 241, 239], [235, 236, 237]],
+    brown: [[244, 238, 238], [233, 229, 227]],
+    orange: [[251, 236, 221]],
+    yellow: [[251, 243, 219]],
+    green: [[237, 243, 236], [221, 237, 234]],
+    blue: [[231, 243, 248], [221, 235, 241]],
+    purple: [[244, 240, 247], [234, 228, 242]],
+    pink: [[249, 238, 243], [244, 223, 235]],
+    red: [[253, 235, 236], [251, 228, 228]]
+  }
+};
+
+// src/engine/clipboard/html-styles.ts
+var HEX = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var FUNCTION = /^rgba?\(([^)]*)\)$/i;
+var SEPARATORS = /[\s,/]+/;
+function parseStyle(style) {
+  const declarations = /* @__PURE__ */ new Map();
+  for (const declaration of (style ?? "").split(";")) {
+    const colon = declaration.indexOf(":");
+    if (colon < 0) continue;
+    const value = declaration.slice(colon + 1).replace(/!important\s*$/i, "").trim().toLowerCase();
+    declarations.set(declaration.slice(0, colon).trim().toLowerCase(), value);
+  }
+  return declarations;
+}
+function fontWeight(styles) {
+  const value = styles.get("font-weight");
+  if (value === void 0) return null;
+  if (value === "bold" || value === "bolder") return 700;
+  if (value === "normal") return 400;
+  if (value === "lighter") return 300;
+  const weight = Number(value);
+  return Number.isFinite(weight) ? weight : null;
+}
+function isItalicStyle(styles) {
+  const value = styles.get("font-style");
+  if (value === void 0) return null;
+  if (value === "normal") return false;
+  return value === "italic" || value.startsWith("oblique") ? true : null;
+}
+var PRESERVING = /* @__PURE__ */ new Set(["pre", "pre-wrap", "break-spaces"]);
+var COLLAPSING = /* @__PURE__ */ new Set(["normal", "nowrap", "pre-line"]);
+var MONOSPACE = /\b(?:monospace|menlo|monaco|consolas|courier)\b/;
+function keepsWhitespace(styles) {
+  const value = styles.get("white-space");
+  if (value === void 0) return null;
+  if (PRESERVING.has(value)) return true;
+  return COLLAPSING.has(value) ? false : null;
+}
+var isMonospace = (styles) => MONOSPACE.test(styles.get("font-family") ?? "");
+function hasDecoration(styles, line2) {
+  return (styles.get("text-decoration") ?? "").includes(line2) || (styles.get("text-decoration-line") ?? "").includes(line2);
+}
+function verticalAlign(styles) {
+  const value = styles.get("vertical-align");
+  return value === "sub" || value === "super" ? value : null;
+}
+function channel(value) {
+  return value.endsWith("%") ? parseFloat(value) * 2.55 : parseFloat(value);
+}
+function fromHex(digits) {
+  const full = digits.length <= 4 ? [...digits].map((digit) => digit + digit).join("") : digits;
+  const byte = (at) => parseInt(full.slice(at, at + 2), 16);
+  return { rgb: [byte(0), byte(2), byte(4)], alpha: full.length === 8 ? byte(6) / 255 : 1 };
+}
+function fromFunction(args) {
+  const parts = args.trim().split(SEPARATORS).filter(Boolean);
+  if (parts.length < 3) return null;
+  const [r, g, b] = parts.slice(0, 3).map(channel);
+  const alpha = parts[3] === void 0 ? 1 : parts[3].endsWith("%") ? parseFloat(parts[3]) / 100 : parseFloat(parts[3]);
+  if ([r, g, b, alpha].some(Number.isNaN)) return null;
+  return { rgb: [r, g, b], alpha };
+}
+function parseColor(css) {
+  const value = css.trim();
+  const hex = HEX.exec(value);
+  const functional = FUNCTION.exec(value);
+  const parsed = hex ? fromHex(hex[1]) : functional ? fromFunction(functional[1]) : null;
+  return parsed === null || parsed.alpha === 0 ? null : parsed.rgb;
+}
+function distance(a, b) {
+  return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2;
+}
+var MAX_PALETTE_DISTANCE = 330;
+var NEUTRAL_CHROMA = 24;
+var LIGHT_TEXT = 200;
+var WHITE_SURFACE = 244;
+var DARK_SURFACE = 128;
+var PASTEL_FLOOR = 233;
+function isSurface([r, g, b], kind) {
+  const high = Math.max(r, g, b);
+  const low = Math.min(r, g, b);
+  const neutral = high - low <= NEUTRAL_CHROMA;
+  if (kind === "text") return neutral && (high + low) / 2 > LIGHT_TEXT;
+  return low >= WHITE_SURFACE || neutral && (high + low) / 2 < DARK_SURFACE;
+}
+function isGreyBackground([r, g, b]) {
+  const high = Math.max(r, g, b);
+  return high - Math.min(r, g, b) <= NEUTRAL_CHROMA && high < PASTEL_FLOOR;
+}
+function nearestPaletteColor(css, kind) {
+  const rgb = parseColor(css);
+  if (rgb === null || isSurface(rgb, kind)) return null;
+  if (kind === "background" && isGreyBackground(rgb)) return "gray";
+  const table = PALETTE_RGB[kind];
+  let best = "default";
+  let least = Infinity;
+  for (const name of PALETTE) {
+    for (const reference of table[name]) {
+      const gap = distance(rgb, reference);
+      if (gap < least) {
+        least = gap;
+        best = name;
+      }
+    }
+  }
+  return best === "default" || least > MAX_PALETTE_DISTANCE ** 2 ? null : best;
+}
+
+// src/engine/clipboard/html-marks.ts
+function linkMark(element) {
+  const href = sanitizeHref(element.getAttribute("href") ?? "");
+  if (href === null || href === "") return null;
+  const title = element.getAttribute("title");
+  return { type: "link", attrs: title ? { href, title } : { href } };
+}
+function highlightMark(element) {
+  const color = element.getAttribute("data-color") ?? "";
+  return isPaletteColor(color) ? { type: "highlight", attrs: { color } } : { type: "highlight" };
+}
+function elementMarks(element, inherited) {
+  const tag = tagName(element);
+  const styles = parseStyle(element.getAttribute("style"));
+  let marks = inherited;
+  const add = (mark) => {
+    marks = addMark(marks, mark);
+  };
+  const link = tag === "a" ? linkMark(element) : null;
+  if (link !== null) add(link);
+  const linked2 = hasMark(marks, "link");
+  const weight = fontWeight(styles);
+  if (weight !== null ? weight >= 600 : tag === "b" || tag === "strong") add({ type: "bold" });
+  else if (weight !== null) marks = removeMark(marks, "bold");
+  const slanted = isItalicStyle(styles);
+  if (slanted ?? (tag === "i" || tag === "em")) add({ type: "italic" });
+  else if (slanted === false) marks = removeMark(marks, "italic");
+  if (tag === "u" || !linked2 && hasDecoration(styles, "underline")) add({ type: "underline" });
+  if (tag === "s" || tag === "del" || tag === "strike" || hasDecoration(styles, "line-through")) {
+    add({ type: "strike" });
+  }
+  if (tag === "code" || tag === "kbd") add({ type: "code" });
+  const align = verticalAlign(styles);
+  if (tag === "sub" || align === "sub") add({ type: "sub" });
+  if (tag === "sup" || align === "super") add({ type: "sup" });
+  if (tag === "mark") add(highlightMark(element));
+  const pageColors = isFragmentRoot(element);
+  const color = linked2 || pageColors ? null : nearestPaletteColor(styles.get("color") ?? "", "text");
+  if (color !== null) add({ type: "color", attrs: { color } });
+  const background = pageColors ? null : nearestPaletteColor(styles.get("background-color") ?? "", "background");
+  if (background !== null) add({ type: "background", attrs: { color: background } });
+  return marks;
+}
+
+// src/engine/clipboard/hoist-spaces.ts
+var shared = (a, b) => a.filter((mark) => b.some((other) => sameMark(mark, other)));
+function hoistEdgeSpaces(pieces) {
+  const result = [];
+  pieces.forEach((piece, at) => {
+    const before = pieces[at - 1];
+    const after = pieces[at + 1];
+    if (piece.text === " " && before !== void 0 && after !== void 0) {
+      result.push({ text: " ", marks: shared(before.marks, after.marks) });
+      return;
+    }
+    const leading = before !== void 0 && piece.text.length > 1 && piece.text.startsWith(" ");
+    const trailing = after !== void 0 && piece.text.length > 1 && piece.text.endsWith(" ");
+    if (leading) result.push({ text: " ", marks: shared(before.marks, piece.marks) });
+    result.push({ ...piece, text: piece.text.slice(leading ? 1 : 0, trailing ? -1 : void 0) });
+    if (trailing) result.push({ text: " ", marks: shared(piece.marks, after.marks) });
+  });
+  return result;
+}
+
+// src/engine/clipboard/html-inline.ts
+var COLLAPSIBLE = /[ \t\n\r\f]+/g;
+var MSO_IGNORED = "mso-list:ignore";
+function isMsoIgnored(element) {
+  return (element.getAttribute("style") ?? "").toLowerCase().replace(/\s+/g, "").includes(MSO_IGNORED);
+}
+function lastChar({ pieces }) {
+  const last = pieces[pieces.length - 1];
+  return last === void 0 ? "" : last.text[last.text.length - 1];
+}
+function trimEndSpace({ pieces }) {
+  const last = pieces[pieces.length - 1];
+  if (last === void 0 || !last.text.endsWith(" ")) return;
+  const trimmed2 = last.text.slice(0, -1);
+  if (trimmed2 === "") pieces.pop();
+  else pieces[pieces.length - 1] = { ...last, text: trimmed2 };
+}
+function addBreak(acc, marks, preformatted) {
+  acc.pendingBreak = false;
+  if (acc.pieces.length === 0) return;
+  if (!preformatted) trimEndSpace(acc);
+  acc.pieces.push({ text: "\n", marks });
+}
+function append(acc, raw, marks, preformatted) {
+  let value = preformatted ? raw.replace(/\r\n?/g, "\n") : raw.replace(COLLAPSIBLE, " ");
+  if (value === "") return;
+  if (acc.pendingBreak) {
+    if (lastChar(acc) !== "\n") addBreak(acc, marks, preformatted);
+    acc.pendingBreak = false;
+  }
+  const before = lastChar(acc);
+  if (!preformatted && (before === "" || before === "\n" || before === " ")) value = value.replace(/^ /, "");
+  if (value !== "") acc.pieces.push({ text: value, marks });
+}
+function finish({ pieces }) {
+  while (pieces.length > 0) {
+    const last = pieces[pieces.length - 1];
+    const trimmed2 = last.text.replace(/[ \n]+$/, "");
+    if (trimmed2 === "") pieces.pop();
+    else {
+      pieces[pieces.length - 1] = { ...last, text: trimmed2 };
+      break;
+    }
+  }
+  const inline = normalizeInline(hoistEdgeSpaces(pieces).map((piece) => text(piece.text, piece.marks)));
+  return inline.every((node) => node.kind === "text" && node.text.trim() === "") ? [] : inline;
+}
+function visit(acc, node, style, depth) {
+  const { marks, preformatted } = style;
+  if (node.nodeType === TEXT_NODE) return append(acc, node.nodeValue ?? "", marks, preformatted);
+  if (node.nodeType !== ELEMENT_NODE || !isElement(node) || isDropped(node) || isMsoIgnored(node)) return;
+  const tag = tagName(node);
+  if (tag === "br") return addBreak(acc, marks, preformatted);
+  if (tag === "img") return;
+  const next = {
+    marks: elementMarks(node, marks),
+    preformatted: keepsWhitespace(parseStyle(node.getAttribute("style"))) ?? preformatted
+  };
+  if (depth > MAX_DEPTH) return append(acc, flatText(node), next.marks, next.preformatted);
+  const block = isBlockTag(node);
+  if (block) acc.pendingBreak = true;
+  for (const child2 of Array.from(node.childNodes)) visit(acc, child2, next, depth + 1);
+  if (block) acc.pendingBreak = true;
+}
+function inlineFromNodes(nodes, style) {
+  const acc = { pieces: [], pendingBreak: false };
+  for (const node of nodes) visit(acc, node, style, 0);
+  return finish(acc);
+}
+
+// src/engine/clipboard/html-lists.ts
+var LIST_TAGS = /* @__PURE__ */ new Set(["ul", "ol"]);
+var MARKER_NUMBER = /^(\d+)[.)]$/;
+var MARKER_LETTERS = /^[a-z]{1,4}[.)]$/i;
+function checkboxState(node) {
+  if (!isElement(node)) return null;
+  if (tagName(node) === "input" && node.getAttribute("type")?.toLowerCase() === "checkbox") {
+    return node.hasAttribute("checked");
+  }
+  if (hasClass(node, "checkbox-on")) return true;
+  return hasClass(node, "checkbox-off") ? false : null;
+}
+function takeCheckbox(nodes) {
+  const at = nodes.findIndex((node) => checkboxState(node) !== null);
+  if (at < 0) return { checked: null, rest: [...nodes] };
+  return { checked: checkboxState(nodes[at]), rest: nodes.filter((_, index) => index !== at) };
+}
+var isPlainWrapper = (node) => isElement(node) && ["p", "div"].includes(tagName(node)) && !hasBlockDescendant(node);
+function listItem(item, base, ctx, sink) {
+  const own = takeCheckbox(Array.from(item.childNodes));
+  const split = own.rest.findIndex(breaksRun);
+  let content = inlineFromNodes(split < 0 ? own.rest : own.rest.slice(0, split), ctx);
+  let rest = split < 0 ? [] : own.rest.slice(split);
+  let checked = own.checked;
+  if (content.length === 0 && rest.length > 0 && isPlainWrapper(rest[0])) {
+    const inner = takeCheckbox(Array.from(rest[0].childNodes));
+    checked = checked ?? inner.checked;
+    content = inlineFromNodes(inner.rest, ctx);
+    rest = rest.slice(1);
+  }
+  emitText(sink, ctx.indent, checked === null ? base : { kind: "task", checked }, content);
+  sink.walk(rest, child(ctx, { indent: ctx.indent + 1, run: PARAGRAPH2 }));
+}
+function firstNumber(list2) {
+  const start = Number.parseInt(list2.getAttribute("start") ?? "", 10);
+  return Number.isInteger(start) && start >= 0 ? start : 1;
+}
+function list(element, ctx, sink) {
+  const ordered = tagName(element) === "ol";
+  const first = firstNumber(element);
+  let position = 0;
+  for (const node of Array.from(element.childNodes)) {
+    if (isElement(node) && tagName(node) === "li") {
+      listItem(node, ordered ? { kind: "ordered", start: first + position } : { kind: "bullet" }, ctx, sink);
+      position++;
+    } else if (isElement(node) && LIST_TAGS.has(tagName(node)) && ctx.depth <= MAX_DEPTH) {
+      list(node, child(ctx, { indent: ctx.indent + 1 }), sink);
+    } else {
+      sink.walk([node], child(ctx));
+    }
+  }
+}
+function wordMarker(paragraph) {
+  const ignored = Array.from(paragraph.querySelectorAll("[style]")).find(isMsoIgnored);
+  const marker = (ignored?.textContent ?? "").replace(/\s+/g, "");
+  const number = MARKER_NUMBER.exec(marker);
+  if (number) return { kind: "ordered", start: Number(number[1]) };
+  return MARKER_LETTERS.test(marker) ? { kind: "ordered", start: 1 } : { kind: "bullet" };
+}
+function wordListItem(paragraph, ctx, sink) {
+  const style = (paragraph.getAttribute("style") ?? "").toLowerCase();
+  const level = /mso-list:[^;]*\blevel(\d+)/.exec(style);
+  const listClass = (paragraph.getAttribute("class") ?? "").toLowerCase().includes("msolistparagraph");
+  if (level === null && !listClass) return false;
+  const depth = level === null ? 0 : Math.max(0, Number(level[1]) - 1);
+  emitText(sink, ctx.indent + depth, wordMarker(paragraph), inlineFromNodes(paragraph.childNodes, ctx));
+  return true;
+}
+
+// src/engine/clipboard/html-media.ts
+function imageBlock(img, caption, ctx, sink) {
+  const url = sanitizeHref(img.getAttribute("src") ?? "");
+  if (url === null || url === "") return;
+  emit(sink, "IMAGE", ctx.indent, { storageKey: "", alt: img.getAttribute("alt") ?? "", url }, { caption });
+}
+function figure(element, ctx, sink) {
+  const img = element.querySelector("img");
+  if (img === null) {
+    sink.walk(element.childNodes, child(ctx));
+    return;
+  }
+  const caption = element.querySelector("figcaption");
+  imageBlock(img, caption === null ? [] : inlineFromNodes(caption.childNodes, ctx), ctx, sink);
+}
+
+// src/engine/clipboard/html-table.ts
+var SECTIONS = /* @__PURE__ */ new Set(["thead", "tbody", "tfoot"]);
+function rowOf(tr, head) {
+  return { cells: Array.from(tr.children).filter((cell) => ["td", "th"].includes(tagName(cell))), head };
+}
+function tableRows(table) {
+  const rows = [];
+  for (const part of Array.from(table.children)) {
+    const tag = tagName(part);
+    if (tag === "tr") rows.push(rowOf(part, false));
+    else if (SECTIONS.has(tag)) {
+      for (const tr of Array.from(part.children)) if (tagName(tr) === "tr") rows.push(rowOf(tr, tag === "thead"));
+    }
+  }
+  return rows;
+}
+function tableBlock(table, ctx, sink) {
+  const rows = tableRows(table);
+  const cols = rows.reduce((widest, row) => Math.max(widest, row.cells.length), 0);
+  if (rows.length === 0 || cols === 0) return;
+  const regions = {};
+  rows.forEach((row, r) => {
+    for (let c = 0; c < cols; c++) {
+      const cell = row.cells[c];
+      regions[cellKey(r, c)] = cell === void 0 ? [] : inlineFromNodes(cell.childNodes, ctx);
+    }
+  });
+  const header = rows[0].head || rows[0].cells.some((cell) => tagName(cell) === "th");
+  emit(sink, "TABLE", ctx.indent, { header, align: Array(cols).fill(null), rows: rows.length, cols }, regions);
+}
+
+// src/engine/clipboard/html-blocks.ts
+var QUOTE = { kind: "quote" };
+var HEADING = /^h([1-6])$/;
+function emitRun(run, ctx, sink) {
+  const inline = inlineFromNodes(run, ctx);
+  if (inline.length === 0) return;
+  const plain = ctx.run.kind === "heading" ? removeMarkRange(inline, 0, inlineLength(inline), "bold") : inline;
+  emitText(sink, ctx.indent, ctx.run, plain);
+}
+function details(element, ctx, sink) {
+  const summary = Array.from(element.children).find((part) => tagName(part) === "summary");
+  const title = summary === void 0 ? [] : inlineFromNodes(summary.childNodes, ctx);
+  emit(sink, "TOGGLE", ctx.indent, { open: element.hasAttribute("open") }, { text: title });
+  const body = Array.from(element.childNodes).filter((part) => part !== summary);
+  sink.walk(body, child(ctx, { indent: ctx.indent + 1, run: PARAGRAPH2 }));
+}
+function styledContext(element, outer) {
+  const styles = parseStyle(element.getAttribute("style"));
+  const keeps = keepsWhitespace(styles);
+  const marks = elementMarks(element, outer.marks);
+  const ctx = { ...outer, marks, preformatted: keeps ?? outer.preformatted };
+  return { ctx, code: keeps === true && isMonospace(styles) };
+}
+function handleBlock(element, outer, sink) {
+  const { ctx, code } = styledContext(element, outer);
+  const tag = tagName(element);
+  if (code && tag === "div") return codeBlock(element, ctx, sink);
+  const heading = HEADING.exec(tag);
+  if (heading) return sink.walk(element.childNodes, child(ctx, { run: { kind: "heading", level: Number(heading[1]) } }));
+  switch (tag) {
+    case "ul":
+    case "ol":
+      return list(element, ctx, sink);
+    case "li":
+      return listItem(element, { kind: "bullet" }, ctx, sink);
+    case "blockquote": {
+      const nested = ctx.run.kind === "quote";
+      return sink.walk(element.childNodes, child(ctx, { indent: ctx.indent + (nested ? 1 : 0), run: QUOTE }));
+    }
+    case "pre":
+      return codeBlock(element, ctx, sink);
+    case "hr":
+      return emit(sink, "DIVIDER", ctx.indent, {}, {});
+    case "table":
+      return tableBlock(element, ctx, sink);
+    case "img":
+      return imageBlock(element, [], ctx, sink);
+    case "figure":
+      return figure(element, ctx, sink);
+    case "details":
+      return details(element, ctx, sink);
+    case "p":
+      if (wordListItem(element, ctx, sink)) return;
+  }
+  sink.walk(element.childNodes, child(ctx));
+}
+function walkNodes(nodes, ctx, sink) {
+  const all = Array.from(nodes);
+  if (ctx.depth > MAX_DEPTH) return emitRun(all, ctx, sink);
+  let run = [];
+  const flush = () => {
+    emitRun(run, ctx, sink);
+    run = [];
+  };
+  for (const node of all) {
+    if (node.nodeType === TEXT_NODE) run.push(node);
+    else if (!isElement(node) || isDropped(node)) continue;
+    else if (isBlockLevel(node)) {
+      flush();
+      handleBlock(node, ctx, sink);
+    } else if (hasBlockDescendant(node)) {
+      flush();
+      sink.walk(node.childNodes, child(styledContext(node, ctx).ctx));
+    } else run.push(node);
+  }
+  flush();
+}
+function blocksFromBody(body, newId2) {
+  const sink = { out: [], newId: newId2, walk: (nodes, ctx) => walkNodes(nodes, ctx, sink) };
+  sink.walk(body.childNodes, { indent: 0, marks: [], run: PARAGRAPH2, preformatted: false, depth: 0 });
+  return sink.out;
+}
+
+// src/engine/clipboard/from-html.ts
+function availableParser(parser) {
+  if (parser !== void 0) return parser;
+  return typeof globalThis.DOMParser === "function" ? new globalThis.DOMParser() : null;
+}
+function fromHTML(html, options = {}) {
+  const parser = availableParser(options.parser);
+  if (parser === null) throw new Error("fromHTML needs a DOMParser");
+  const makeId = options.newId ?? newId;
+  const codec = createBlockCodec(createSchema(), { newId: makeId });
+  const { body } = parser.parseFromString(html, "text/html");
+  return blocksFromBody(body, makeId).map((block) => codec.toQuoin(block));
+}
+
+// src/engine/markdown/document/line-format.ts
+function indentLines(text2, prefix) {
+  if (prefix === "") return text2;
+  return text2.split("\n").map((line2) => line2 === "" ? line2 : prefix + line2).join("\n");
+}
+function hangLines(text2, width) {
+  if (width === 0) return text2;
+  const [first, ...rest] = text2.split("\n");
+  return [first, ...rest.map((line2) => line2 === "" ? line2 : " ".repeat(width) + line2)].join("\n");
+}
+function quoteLines(text2) {
+  return text2.split("\n").map((line2) => line2 === "" ? ">" : `> ${line2}`).join("\n");
+}
+
+// src/engine/markdown/document/block-forms.ts
+var ALERT_NAMES = new Map(
+  Object.entries(ALERT_TONES).map(([name, tone]) => [tone, name])
+);
+var DELIMITERS = /* @__PURE__ */ new Map([
+  ["left", ":--"],
+  ["center", ":-:"],
+  ["right", "--:"]
+]);
+var MIN_FENCE = 3;
+var FENCE_LIKE_MATH_LINE = /^ {0,3}\${2,}[ \t]*$/m;
+function calloutMarkdown(data) {
+  const name = ALERT_NAMES.get(str(data.tone)) ?? "NOTE";
+  const body = str(data.body);
+  return quoteLines(body === "" ? `[!${name}]` : `[!${name}]
+${body}`);
+}
+function longestRun(value, char) {
+  let longest = 0;
+  let run = 0;
+  for (const current of value) {
+    run = current === char ? run + 1 : 0;
+    longest = Math.max(longest, run);
+  }
+  return longest;
+}
+function codeMarkdown(data) {
+  const code = str(data.code);
+  const info = str(data.language);
+  const char = info.includes("`") ? "~" : "`";
+  const fence = char.repeat(Math.max(MIN_FENCE, longestRun(code, char) + 1));
+  return [fence + info.replace(/[\\&]/g, "\\$&"), ...code === "" ? [] : code.split("\n"), fence].join("\n");
+}
+function mathMarkdown(data) {
+  const latex = str(data.latex);
+  if (FENCE_LIKE_MATH_LINE.test(latex)) return null;
+  return ["$$", ...latex === "" ? [] : latex.split("\n"), "$$"].join("\n");
+}
+var cellsOf = (row) => Array.isArray(row) ? row.map(str) : [];
+var rowMarkdown = (cells) => `| ${cells.join(" | ")} |`;
+function tableMarkdown(data) {
+  const rows = Array.isArray(data.rows) ? data.rows.map(cellsOf) : [];
+  const cols = rows.reduce((widest, row) => Math.max(widest, row.length), 0);
+  if (cols === 0) return null;
+  const aligns = Array.isArray(data.align) ? data.align : [];
+  const headed = data.header !== false;
+  const header = headed ? rows[0] : [];
+  const body = headed ? rows.slice(1) : rows;
+  const pad = (cells) => Array.from({ length: cols }, (_, col) => cells[col] ?? "");
+  const delimiter = Array.from({ length: cols }, (_, col) => DELIMITERS.get(aligns[col]) ?? "---");
+  return [header, delimiter, ...body].map((row) => rowMarkdown(pad(row))).join("\n");
+}
+
+// src/engine/markdown/document/comment-form.ts
+var NATIVE_KEYS = /* @__PURE__ */ new Map([
+  ["MARKDOWN", ["markdown"]],
+  ["TOGGLE", ["markdown", "open"]],
+  ["DIVIDER", []],
+  ["TOC", []]
+]);
+var hasNativeForm = (type) => NATIVE_KEYS.has(type);
+function needsComment(block, residual, schema, ctx) {
+  const native = NATIVE_KEYS.get(block.type);
+  if (!native) return false;
+  if (residual > 0) return true;
+  return Object.keys(specFor(schema, block.type).toData(block, ctx)).some((key) => !native.includes(key));
+}
+
+// src/engine/markdown/document/comment-markdown.ts
+var DOUBLE_HYPHEN = /--/g;
+var LINE_SEPARATOR = /[\u2028\u2029]/g;
+function quoinComment(type, data, indent2) {
+  const payload = JSON.stringify(indent2 > 0 ? { data, indent: indent2 } : { data }).replace(DOUBLE_HYPHEN, "-\\u002d").replace(LINE_SEPARATOR, (char) => `\\u${char.charCodeAt(0).toString(16)}`);
+  return `<!-- quoin:${type} ${payload} -->`;
+}
+
+// src/engine/markdown/document/link-forms.ts
+var oneLine = (value) => value.replace(/[\r\n]+/g, " ");
+function linked(label, href, ctx) {
+  return ctx.inline.serialize([text(label || href, [{ type: "link", attrs: { href } }])]);
+}
+var assetUrl = (storageKey, ctx) => storageKey === "" ? "" : ctx.resolveAssetUrl(storageKey);
+function imageMarkdown(data, ctx) {
+  const href = str(data.url) || assetUrl(str(data.storageKey), ctx);
+  if (href === "") return null;
+  const caption = str(data.caption);
+  const alt = ctx.inline.serialize([text(oneLine(str(data.alt)))]);
+  return `![${alt}${linkClose({ type: "link", attrs: caption ? { href, title: caption } : { href } }, false)}`;
+}
+function fileMarkdown(data, ctx) {
+  const href = assetUrl(str(data.storageKey), ctx);
+  return href === "" ? null : linked(oneLine(str(data.filename)), href, ctx);
+}
+function embedMarkdown(data, ctx) {
+  const url = str(data.url);
+  return url === "" ? null : linked(url, url, ctx);
+}
+function bookmarkMarkdown(data, ctx) {
+  const url = str(data.url);
+  return url === "" ? null : linked(oneLine(str(data.title)), url, ctx);
+}
+
+// src/engine/markdown/document/block-markdown.ts
+var QUOTE_PREFIX = "> ";
+function markdownLine(block, data) {
+  const kind = block.attrs.kind ?? "paragraph";
+  const markdown = str(data.markdown);
+  const empty = inlineLength(block.regions.text ?? []) === 0;
+  if (empty && (kind === "paragraph" || kind === "quote")) return null;
+  return kind === "quote" ? quoteLines(markdown.slice(QUOTE_PREFIX.length)) : markdown;
+}
+function toggleMarkdown(data) {
+  return `<details${data.open === true ? " open" : ""}>
+<summary>${str(data.markdown)}</summary>`;
+}
+function coreMarkdown(block, data, env, residual) {
+  switch (block.type) {
+    case "MARKDOWN":
+      return markdownLine(block, data);
+    case "CALLOUT":
+      return calloutMarkdown(data);
+    case "CODE":
+      return codeMarkdown(data);
+    case "MATH":
+      return mathMarkdown(data);
+    case "DIVIDER":
+      return "---";
+    case "TABLE":
+      return tableMarkdown(data);
+    case "IMAGE":
+      return imageMarkdown(data, env.ctx);
+    case "FILE":
+      return fileMarkdown(data, env.ctx);
+    case "EMBED":
+      return embedMarkdown(data, env.ctx);
+    case "BOOKMARK":
+      return bookmarkMarkdown(data, env.ctx);
+    case "TOGGLE":
+      return toggleMarkdown(data);
+    case "TOC":
+      return Object.keys(data).length === 0 && residual === 0 ? "<!-- quoin:toc -->" : null;
+    default:
+      return null;
+  }
+}
+function blockMarkdown(block, env, { residual, asComment }) {
+  const spec = specFor(env.schema, block.type);
+  const data = spec.toData(block, env.ctx);
+  const comment = () => isQuoinType(block.type) ? quoinComment(block.type, data, residual) : null;
+  if (asComment || env.lossless && !hasNativeForm(block.type)) return comment();
+  const written = spec.toMarkdown ? spec.toMarkdown(block, env.ctx) : coreMarkdown(block, data, env, residual);
+  if (written !== null) return written;
+  return env.lossless || block.type !== "MARKDOWN" ? comment() : null;
+}
+
+// src/engine/markdown/document/list-context.ts
+var ITEM_KINDS2 = ["bullet", "ordered", "task"];
+var lineKindOf = (block) => block.type === "MARKDOWN" ? block.attrs.kind ?? "paragraph" : void 0;
+function openedBy(block, prefix, hang) {
+  if (hang > 0) return { kind: "item", indent: block.indent, prefix, childPrefix: prefix + " ".repeat(hang) };
+  if (block.type === "TOGGLE") return { kind: "toggle", indent: block.indent, prefix, childPrefix: prefix };
+  return void 0;
+}
+function createListContext() {
+  const stack = [];
+  const runs = /* @__PURE__ */ new Map();
+  function place(block, asComment) {
+    const closed = [];
+    while (stack.length > 0 && stack[stack.length - 1].indent >= block.indent) closed.push(stack.pop());
+    const parent = stack[stack.length - 1];
+    const prefix = parent?.childPrefix ?? "";
+    const line2 = lineKindOf(block);
+    const residual = block.indent - stack.length;
+    const comment = asComment?.(residual) === true;
+    for (const indent2 of [...runs.keys()]) if (indent2 > block.indent) runs.delete(indent2);
+    let placed = block;
+    let number = 1;
+    if (line2 === "ordered") {
+      number = Math.min(runs.get(block.indent) ?? orderedStart(block.attrs.start), MAX_MARKER_NUMBER);
+      runs.set(block.indent, number + 1);
+      if (number !== block.attrs.start) placed = { ...block, attrs: { ...block.attrs, start: number } };
+    } else {
+      runs.delete(block.indent);
+    }
+    const isItem2 = !comment && line2 !== void 0 && ITEM_KINDS2.includes(line2);
+    const hang = isItem2 ? (line2 === "ordered" ? String(number).length : 0) + 2 : 0;
+    const container = comment ? void 0 : openedBy(block, prefix, hang);
+    if (container) stack.push(container);
+    const bare = !comment && (line2 === "bullet" || line2 === "ordered") && inlineLength(block.regions.text ?? []) === 0;
+    const fragile = isItem2 && (bare || line2 === "ordered" && number !== 1);
+    const shown = comment ? void 0 : line2;
+    return { block: placed, line: shown, prefix, hang, residual, parent, container, closed, bare, fragile, comment };
+  }
+  return { place, finish: () => stack.splice(0).reverse() };
+}
+
+// src/engine/markdown/document/strip-comments.ts
+var hasCommentMark = (inline) => inline.some((node) => node.marks.some((mark) => mark.type === "comment"));
+function stripComments(block) {
+  const regions = Object.entries(block.regions);
+  if (!regions.some(([, inline]) => hasCommentMark(inline))) return block;
+  return {
+    ...block,
+    regions: Object.fromEntries(
+      regions.map(([name, inline]) => [
+        name,
+        hasCommentMark(inline) ? removeMarkRange(inline, 0, inlineLength(inline), "comment") : inline
+      ])
+    )
+  };
+}
+
+// src/engine/markdown/document/to-markdown.ts
+function roleOf({ line: line2, hang }) {
+  if (hang > 0) return "item";
+  return line2 === "quote" ? "quote" : "other";
+}
+var closing = ({ prefix }) => ({
+  text: indentLines("</details>", prefix),
+  role: "other",
+  prefix,
+  bare: false,
+  fragile: false,
+  leadsHtml: false
+});
+function pieceOf(text2, placement) {
+  const { hang, prefix } = placement;
+  return {
+    text: indentLines(hangLines(text2, hang), prefix),
+    role: roleOf(placement),
+    prefix,
+    parent: placement.parent,
+    opened: placement.container,
+    bare: placement.bare,
+    fragile: placement.fragile,
+    leadsHtml: hang > 0 && startsHtmlBlock(text2.split("\n")[0].slice(hang))
+  };
+}
+function takenAsItemText(previous, { parent, line: line2 }) {
+  return line2 === "paragraph" && parent !== void 0 && previous?.opened === parent && previous.bare;
+}
+function separator(previous, next) {
+  const nested = next.parent !== void 0 && next.parent === previous.opened;
+  if (nested && previous.bare) return "\n";
+  if (previous.role === "item" && next.role === "item") {
+    return nested && (next.fragile || previous.leadsHtml) ? "\n\n" : "\n";
+  }
+  if (previous.role === "quote" && next.role === "quote" && previous.parent === next.parent) {
+    return `
+${next.prefix}>
+`;
+  }
+  return "\n\n";
+}
+function join(pieces) {
+  const markdown = pieces.map((piece, at) => at === 0 ? piece.text : separator(pieces[at - 1], piece) + piece.text);
+  return markdown.length === 0 ? "" : `${markdown.join("")}
+`;
+}
+function toMarkdown(blocks, options = {}) {
+  const schema = options.schema ?? createSchema();
+  const codec = createBlockCodec(schema);
+  const env = {
+    schema,
+    lossless: options.lossless === true,
+    ctx: {
+      ...codec.context,
+      resolveAssetUrl: options.resolveAssetUrl ?? ((storageKey) => storageKey),
+      comments: options.comments !== false
+    }
+  };
+  const context = createListContext();
+  const pieces = [];
+  const closeToggles = (containers) => {
+    for (const container of containers) if (container.kind === "toggle") pieces.push(closing(container));
+  };
+  for (const engineBlock of blocks.flatMap((block) => codec.toEngineBlocks(block))) {
+    const block = env.ctx.comments ? engineBlock : stripComments(engineBlock);
+    const placement = context.place(
+      block,
+      env.lossless ? (residual) => needsComment(block, residual, schema, env.ctx) : void 0
+    );
+    closeToggles(placement.closed);
+    const text2 = blockMarkdown(placement.block, env, {
+      residual: placement.residual,
+      asComment: placement.comment || env.lossless && takenAsItemText(pieces[pieces.length - 1], placement)
+    });
+    if (text2) pieces.push(pieceOf(text2, placement));
+  }
+  closeToggles(context.finish());
+  return join(pieces);
+}
+
+// src/engine/render/escape-html.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(value) {
+  return escapeHtml(value).replace(/"/g, "&quot;");
+}
+
+// src/engine/render/serialize-html.ts
+var VOID = /* @__PURE__ */ new Set(["br", "hr", "img", "input"]);
+var attrsHtml = (node) => writtenAttrs(node.attrs).map(([name, value]) => value === true ? ` ${name}` : ` ${name}="${escapeAttr(value)}"`).join("");
+var serializeHtml = (nodes) => nodes.map(
+  (node) => typeof node === "string" ? escapeHtml(node) : `<${node.tag}${attrsHtml(node)}>${VOID.has(node.tag) ? "" : `${node.html ?? serializeHtml(node.children)}</${node.tag}>`}`
+).join("");
+
+// src/engine/render/to-html.ts
+var toHTML = (blocks, options = {}) => serializeHtml(documentNodes(blocks, options));
+
+// src/engine/render/to-plain-text.ts
+function plainTextBlocks(blocks, schema) {
+  return engineBlocksOf(blocks, schema).map((block) => blockPlainText(block, schema));
+}
+function toPlainText(blocks, options = {}) {
+  return plainTextBlocks(blocks, options.schema ?? createSchema()).join("\n");
+}
+
+// src/engine/model/graphemes.ts
+var IntlWithSegmenter = Intl;
+var graphemeSegmenter = IntlWithSegmenter.Segmenter ? new IntlWithSegmenter.Segmenter(void 0, { granularity: "grapheme" }) : null;
+var wordSegmenter = IntlWithSegmenter.Segmenter ? new IntlWithSegmenter.Segmenter(void 0, { granularity: "word" }) : null;
+var WORD = /[\p{L}\p{N}_]+/gu;
+function boundaries(text2) {
+  if (!graphemeSegmenter) {
+    const result = [];
+    let i = 0;
+    for (const ch of text2) {
+      result.push(i);
+      i += ch.length;
+    }
+    return [...result, text2.length];
+  }
+  return [...[...graphemeSegmenter.segment(text2)].map((s) => s.index), text2.length];
+}
+function words(text2) {
+  if (!wordSegmenter) {
+    return [...text2.matchAll(WORD)].map((m) => ({ start: m.index, end: m.index + m[0].length }));
+  }
+  return [...wordSegmenter.segment(text2)].filter((s) => s.isWordLike).map((s) => ({ start: s.index, end: s.index + s.segment.length }));
+}
+function graphemeCount(text2) {
+  return boundaries(text2).length - 1;
+}
+function wordCount(text2) {
+  return words(text2).length;
+}
+function nextGraphemeOffset(text2, offset) {
+  return boundaries(text2).find((b) => b > offset) ?? text2.length;
+}
+function prevGraphemeOffset(text2, offset) {
+  return boundaries(text2).reverse().find((b) => b < offset) ?? 0;
+}
+function nextWordOffset(text2, offset) {
+  return words(text2).find((w) => w.end > offset)?.end ?? text2.length;
+}
+function prevWordOffset(text2, offset) {
+  return words(text2).reverse().find((w) => w.start < offset)?.start ?? 0;
+}
+
+// src/engine/render/count-block.ts
+var counted = /* @__PURE__ */ new WeakMap();
+function countBlock(block, schema) {
+  let blocks = counted.get(schema);
+  if (!blocks) counted.set(schema, blocks = /* @__PURE__ */ new WeakMap());
+  const known = blocks.get(block);
+  if (known) return known;
+  const text2 = blockPlainText(block, schema);
+  const stats = { characters: graphemeCount(text2), words: wordCount(text2) };
+  blocks.set(block, stats);
+  return stats;
+}
+
+// src/engine/render/count-text.ts
+var defaultSchema;
+function sum(blocks, schema) {
+  let characters = 0;
+  let words2 = 0;
+  for (const block of blocks) {
+    const stats = countBlock(block, schema);
+    characters += stats.characters;
+    words2 += stats.words;
+  }
+  return { characters, words: words2 };
+}
+function countText(blocks, options = {}) {
+  const schema = options.schema ?? (defaultSchema ??= createSchema());
+  return sum(engineBlocksOf(blocks, schema), schema);
+}
+function countDoc(doc, options = {}) {
+  return sum(doc.blocks, options.schema ?? (defaultSchema ??= createSchema()));
+}
+
+// src/engine/commands/block-style.ts
+function patchBlocks(state, patch, only) {
+  const changing = selectedBlockIds(state.doc, state.selection).filter((id) => {
+    const block = blockById(state.doc, id);
+    return block !== void 0 && (only === void 0 || block.type === only) && patchChangesAttrs(block.attrs, patch);
+  });
+  if (changing.length === 0) return null;
+  const tr = new Transaction(state);
+  for (const id of changing) tr.step(setAttrsStep(id, patch));
+  return tr;
+}
+function patchCommand(patch, only) {
+  return (state, dispatch) => {
+    const tr = patchBlocks(state, patch, only);
+    if (tr === null) return false;
+    dispatch?.(tr);
+    return true;
+  };
+}
+function setAttrs(patch) {
+  return patchCommand(patch);
+}
+function setTextAlign(align) {
+  return patchCommand({ align: align ?? void 0 }, "MARKDOWN");
+}
+function setBlockColor(colors) {
+  const patch = {};
+  for (const key of ["color", "background"]) {
+    const value = colors[key];
+    if (value !== void 0) patch[key] = value ?? void 0;
+  }
+  const valid = Object.values(patch).every((value) => value === void 0 || isPaletteColor(value));
+  return valid ? patchCommand(patch, "MARKDOWN") : () => false;
+}
+
+// src/engine/commands/line-join.ts
+var LINE_JOIN = "lineJoin";
+
+// src/engine/commands/paragraph-step.ts
+var PARAGRAPH3 = { kind: "paragraph", level: void 0, checked: void 0, start: void 0 };
+function paragraphStep(schema, block, region) {
+  if (block.type === "MARKDOWN") return setAttrsStep(block.id, PARAGRAPH3);
+  const paragraph = createBlock(schema, schema.defaultTextBlock, {}, block.indent, block.id);
+  return replaceBlockStep(withContent(schema, paragraph, block.regions[region]));
+}
+
+// src/engine/commands/delete-at-boundary.ts
+function textCaret(state) {
+  const { doc, schema, selection } = state;
+  if (selection?.kind !== "text" || !isCollapsed(selection)) return null;
+  const pos = selection.head;
+  const index = requireBlockIndex(doc, pos.block);
+  const block = doc.blocks[index];
+  const inFlow2 = isTextFlow(schema, block) && pos.region === primaryRegion(schema, block);
+  return inFlow2 ? { block, index, pos } : null;
+}
+function joinInto(tr, schema, target, source) {
+  const targetRegion = primaryRegion(schema, target) ?? "";
+  tr.step(joinBlocksStep(target.id, targetRegion, source.id, primaryRegion(schema, source) ?? ""));
+  capIndents(tr, requireBlockIndex(tr.doc, target.id) + 1);
+  const offset = regionLength(target, targetRegion);
+  tr.setSelection(textSelection({ block: target.id, region: targetRegion, offset }));
+}
+function joinIntoSummary(tr, schema, summary, source) {
+  const region = primaryRegion(schema, summary) ?? "";
+  const offset = regionLength(summary, region);
+  const index = requireBlockIndex(tr.doc, source.id);
+  const content = source.regions[primaryRegion(schema, source) ?? ""];
+  if (content.length > 0) tr.step(replaceInlineStep(summary.id, region, offset, offset, content));
+  tr.step(removeBlocksStep(index, 1));
+  capIndents(tr, index);
+  tr.setSelection(textSelection({ block: summary.id, region, offset }));
+}
+var deleteAtStart = (state, dispatch) => {
+  const caret = textCaret(state);
+  if (caret === null || caret.pos.offset !== 0) return false;
+  const { doc, schema } = state;
+  const { block, index, pos } = caret;
+  const previous = doc.blocks[index - 1];
+  const hidden = hidingToggle(doc, index);
+  const tr = new Transaction(state).setMeta(LINE_JOIN, true);
+  if (!isParagraph(block)) {
+    tr.step(paragraphStep(schema, block, pos.region));
+    tr.setSelection(startOf(tr.doc, schema, block.id));
+  } else if (block.indent > 0) {
+    shiftSubtree(tr, index, -1);
+  } else if (previous === void 0) {
+    return false;
+  } else if (hidden !== null) {
+    joinIntoSummary(tr, schema, doc.blocks[hidden], block);
+  } else if (isTextFlow(schema, previous)) {
+    joinInto(tr, schema, previous, block);
+  } else {
+    if (regionLength(block, pos.region) === 0) tr.step(removeBlocksStep(index, 1));
+    tr.setSelection(nodeSelection(previous.id));
+  }
+  dispatch?.(tr);
+  return true;
+};
+var deleteAtEnd = (state, dispatch) => {
+  const caret = textCaret(state);
+  if (caret === null || caret.pos.offset !== regionLength(caret.block, caret.pos.region)) return false;
+  const { doc, schema } = state;
+  const { block, index, pos } = caret;
+  const nextIndex = isClosedToggle(block) ? descendantsEnd(doc, index) : index + 1;
+  const next = doc.blocks[nextIndex];
+  if (next === void 0) return false;
+  const tr = new Transaction(state).setMeta(LINE_JOIN, true);
+  if (isTextFlow(schema, next) && nextIndex > index + 1) {
+    joinIntoSummary(tr, schema, block, next);
+  } else if (isTextFlow(schema, next)) {
+    joinInto(tr, schema, block, next);
+  } else {
+    if (isParagraph(block) && pos.offset === 0) {
+      tr.step(removeBlocksStep(index, 1));
+      capIndents(tr, index);
+    }
+    tr.setSelection(nodeSelection(next.id));
+  }
+  dispatch?.(tr);
+  return true;
+};
+
+// src/engine/commands/delete-commands.ts
+var deleteSelection = (state, dispatch) => {
+  const { doc, schema, selection } = state;
+  if (selection?.kind !== "text") return deleteBlocks(state, dispatch);
+  if (isCollapsed(selection)) return false;
+  const tr = new Transaction(state);
+  const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+  dispatch?.(tr.setSelection(textSelection(deleteRange(tr, schema, from, to))));
+  return true;
+};
+function deleteReaching(forward, reach) {
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (selection?.kind !== "text" || !isCollapsed(selection)) return deleteSelection(state, dispatch);
+    const { head } = selection;
+    const value = inlineText(state.doc.blocks[requireBlockIndex(state.doc, head.block)].regions[head.region]);
+    if (forward ? head.offset >= value.length : head.offset <= 0) {
+      return (forward ? deleteAtEnd : deleteAtStart)(state, dispatch);
+    }
+    const other = reach(value, head.offset);
+    const from = Math.min(head.offset, other);
+    const to = Math.max(head.offset, other);
+    const tr = new Transaction(state).setOrigin("input");
+    tr.step(replaceInlineStep(head.block, head.region, from, to, []));
+    dispatch?.(tr.setSelection(textSelection({ ...head, offset: from })));
+    return true;
+  };
+}
+var lineStart = (value, offset) => {
+  const start = value.lastIndexOf("\n", offset - 1) + 1;
+  return start === offset ? offset - 1 : start;
+};
+var lineEnd = (value, offset) => {
+  const found = value.indexOf("\n", offset);
+  const end = found === -1 ? value.length : found;
+  return end === offset ? offset + 1 : end;
+};
+var deleteBackward = deleteReaching(false, prevGraphemeOffset);
+var deleteForward = deleteReaching(true, nextGraphemeOffset);
+var deleteWordBackward = deleteReaching(false, prevWordOffset);
+var deleteWordForward = deleteReaching(true, nextWordOffset);
+var deleteToLineStart = deleteReaching(false, lineStart);
+var deleteToLineEnd = deleteReaching(true, lineEnd);
+
+// src/engine/commands/hard-break.ts
+var insertHardBreak = insertText("\n", { origin: "command" });
+
+// src/engine/commands/move-blocks-to.ts
+function movedRuns(doc, ids) {
+  const moved2 = new Array(doc.blocks.length).fill(false);
+  for (const id of ids) {
+    const index = doc.index.get(id);
+    if (index === void 0) return null;
+    moved2.fill(true, index, descendantsEnd(doc, index));
+  }
+  const runs = [];
+  doc.blocks.forEach((block, index) => {
+    if (!moved2[index]) return;
+    if (index > 0 && moved2[index - 1]) runs[runs.length - 1].push(block.id);
+    else runs.push([block.id]);
+  });
+  return runs;
+}
+function movedBlockIds(doc, ids) {
+  return movedRuns(doc, ids)?.flat() ?? null;
+}
+function gather(tr, runs, above) {
+  let anchor = above;
+  for (const run of runs) {
+    const from = requireBlockIndex(tr.doc, run[0]);
+    const at = anchor === null ? -1 : requireBlockIndex(tr.doc, anchor);
+    const to = at < from ? at + 1 : at + 1 - run.length;
+    if (to !== from) tr.step(moveBlocksStep(from, run.length, to));
+    anchor = run[run.length - 1];
+  }
+}
+function reindent(tr, start, count2, indent2) {
+  const delta = indent2 - tr.doc.blocks[start].indent;
+  for (const block of tr.doc.blocks.slice(start, start + count2)) {
+    const next = Math.max(0, block.indent + delta);
+    if (next !== block.indent) tr.step(setIndentStep(block.id, next));
+  }
+  capIndents(tr, start, start + count2);
+}
+function moveBlocksTo(ids, toIndex, indent2) {
+  return (state, dispatch) => {
+    const { doc } = state;
+    const runs = movedRuns(doc, ids);
+    if (runs === null || runs.length === 0) return false;
+    const moved2 = new Set(runs.flat());
+    const rest = doc.blocks.filter((block) => !moved2.has(block.id));
+    if (toIndex < 0 || toIndex > rest.length) return false;
+    const above = toIndex > 0 ? rest[toIndex - 1] : null;
+    const tr = new Transaction(state);
+    gather(tr, runs, above?.id ?? null);
+    const first = runs[0][0];
+    const last = runs[runs.length - 1];
+    const clamped = Math.min(Math.max(indent2, 0), above ? above.indent + 1 : 0);
+    reindent(tr, requireBlockIndex(tr.doc, first), moved2.size, clamped);
+    if (!tr.docChanged) return false;
+    dispatch?.(tr.setSelection(blockRangeSelection(first, last[last.length - 1])));
+    return true;
+  };
+}
+
+// src/engine/commands/selection-commands.ts
+var selectAll = (state, dispatch) => {
+  const { doc, selection } = state;
+  if (doc.blocks.length === 0) return false;
+  let next = blockRangeSelection(doc.blocks[0].id, doc.blocks[doc.blocks.length - 1].id);
+  if (selection?.kind === "text") {
+    const { anchor, head } = selection;
+    const length = inlineLength(doc.blocks[requireBlockIndex(doc, head.block)].regions[head.region] ?? []);
+    const withinRegion = anchor.block === head.block && anchor.region === head.region;
+    const covers = Math.min(anchor.offset, head.offset) === 0 && Math.max(anchor.offset, head.offset) === length;
+    if (withinRegion && !covers) next = textSelection({ ...head, offset: 0 }, { ...head, offset: length });
+  }
+  dispatch?.(new Transaction(state).setSelection(next));
+  return true;
+};
+var selectBlock = (state, dispatch) => {
+  const id = headBlockId(state.selection);
+  if (id === null) return false;
+  dispatch?.(new Transaction(state).setSelection(blockRangeSelection(id)));
+  return true;
+};
+function setSelection(selection) {
+  return (state, dispatch) => {
+    dispatch?.(new Transaction(state).setSelection(selection));
+    return true;
+  };
+}
+
+// src/engine/commands/line-split.ts
+var LINE_SPLIT = "lineSplit";
+
+// src/engine/commands/split-step.ts
+function splitStep(schema, block, region, offset, id) {
+  const next = specOf(schema, block).splitAttrs?.(block.attrs) ?? { type: block.type, attrs: block.attrs };
+  const created = createBlock(schema, next.type, next.attrs, block.indent, id);
+  const tailRegion = primaryRegion(schema, created) ?? "";
+  const { type, attrs, indent: indent2, regions } = created;
+  const step = splitBlockStep(block.id, region, offset, { id, type, attrs, indent: indent2, region: tailRegion, regions });
+  return { step, tail: { id, region: tailRegion } };
+}
+
+// src/engine/commands/split-at.ts
+function enterInHardBreakBlock({ tr, schema, block, index, pos, makeId }) {
+  const length = regionLength(block, pos.region);
+  if (pos.offset === length && inlineText(block.regions[pos.region]).endsWith("\n")) {
+    tr.step(replaceInlineStep(block.id, pos.region, length - 1, length, []));
+    const paragraph = createBlock(schema, schema.defaultTextBlock, {}, block.indent, makeId());
+    tr.step(insertBlocksStep(descendantsEnd(tr.doc, index), [paragraph]));
+    tr.setSelection(startOf(tr.doc, schema, paragraph.id));
+  } else {
+    tr.setSelection(textSelection(insertTextAt(tr, schema, pos, "\n")));
+  }
+}
+function leaveItem({ tr, schema, block, index, pos }) {
+  if (block.indent > 0) shiftSubtree(tr, index, -1);
+  else tr.step(paragraphStep(schema, block, pos.region));
+  tr.setSelection(startOf(tr.doc, schema, block.id));
+}
+function insertEmptyBefore({ tr, schema, block, index, pos, makeId }) {
+  const next = specOf(schema, block).splitAttrs?.(block.attrs);
+  const empty = createBlock(schema, next?.type ?? schema.defaultTextBlock, next?.attrs, block.indent, makeId());
+  tr.step(insertBlocksStep(index, [empty]));
+  tr.setSelection(textSelection(pos));
+}
+function splitToggle({ tr, schema, block, index, pos, makeId }) {
+  const length = regionLength(block, pos.region);
+  const open = block.attrs.open === true;
+  const tail = sliceInline(block.regions[pos.region], pos.offset, length);
+  const empty = createBlock(schema, schema.defaultTextBlock, {}, open ? block.indent + 1 : block.indent, makeId());
+  if (pos.offset < length) tr.step(replaceInlineStep(block.id, pos.region, pos.offset, length, []));
+  tr.step(insertBlocksStep(open ? index + 1 : descendantsEnd(tr.doc, index), [withContent(schema, empty, tail)]));
+  tr.setSelection(startOf(tr.doc, schema, empty.id));
+}
+function splitInTwo({ tr, schema, block, pos, makeId }) {
+  const { step, tail } = splitStep(schema, block, pos.region, pos.offset, makeId());
+  tr.step(step);
+  tr.setSelection(textSelection({ block: tail.id, region: tail.region, offset: 0 }));
+}
+function splitAt(tr, schema, pos, collapsed, makeId) {
+  const index = requireBlockIndex(tr.doc, pos.block);
+  const block = tr.doc.blocks[index];
+  if (!isTextFlow(schema, block) || pos.region !== primaryRegion(schema, block)) return false;
+  const target = { tr, schema, block, index, pos, makeId };
+  const length = regionLength(block, pos.region);
+  if (specOf(schema, block).enter === "hardBreak") enterInHardBreakBlock(target);
+  else if (collapsed && length === 0 && isItem(block)) leaveItem(target);
+  else if (pos.offset === 0 && length > 0) insertEmptyBefore(target);
+  else if (block.type === "TOGGLE") splitToggle(target);
+  else splitInTwo(target);
+  return true;
+}
+
+// src/engine/commands/split-block.ts
+function splitBlock(options = {}) {
+  const makeId = options.newId ?? newId;
+  return (state, dispatch) => {
+    const { doc, schema, selection } = state;
+    if (selection === null || selection.kind === "blocks") return false;
+    const tr = new Transaction(state).setMeta(LINE_SPLIT, true);
+    if (selection.kind === "node") {
+      const index = requireBlockIndex(doc, selection.block);
+      const paragraph = createBlock(schema, schema.defaultTextBlock, {}, doc.blocks[index].indent, makeId());
+      tr.step(insertBlocksStep(descendantsEnd(doc, index), [paragraph]));
+      tr.setSelection(startOf(tr.doc, schema, paragraph.id));
+    } else {
+      const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+      const caret = deleteRange(tr, schema, from, to, makeId);
+      if (!splitAt(tr, schema, caret, isCollapsed(selection), makeId)) return false;
+    }
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/commands/chain.ts
+var coreCommandFactories = {
+  insertText,
+  insertHardBreak: () => insertHardBreak,
+  deleteSelection: () => deleteSelection,
+  deleteBackward: () => deleteBackward,
+  deleteForward: () => deleteForward,
+  deleteWordBackward: () => deleteWordBackward,
+  deleteWordForward: () => deleteWordForward,
+  deleteToLineStart: () => deleteToLineStart,
+  deleteToLineEnd: () => deleteToLineEnd,
+  splitBlock,
+  undo: () => undo,
+  redo: () => redo,
+  undoInputRule: () => undoInputRule,
+  toggleMark,
+  setMark,
+  unsetMark,
+  setLink,
+  unsetLink: () => unsetLink,
+  clearFormatting: () => clearFormatting,
+  insertAtom,
+  insertMention,
+  setBlockType,
+  setAttrs,
+  toggleTask: () => toggleTask,
+  indent: () => indent,
+  outdent: () => outdent,
+  moveBlocksUp: () => moveBlocksUp,
+  moveBlocksDown: () => moveBlocksDown,
+  moveBlocksTo,
+  duplicateBlocks,
+  deleteBlocks: () => deleteBlocks,
+  insertBlockAfter,
+  setTextAlign,
+  setBlockColor,
+  selectAll: () => selectAll,
+  selectBlock: () => selectBlock,
+  setSelection
+};
+function createCommandHelpers(getState, dispatch, factories, live = () => true) {
+  const names = Object.keys(factories);
+  const bind = (send) => Object.fromEntries(
+    names.map((name) => [name, (...args) => live() && factories[name](...args)(getState(), send)])
+  );
+  const commands = bind(dispatch);
+  const dryRun = bind();
+  function chain() {
+    const queue = [];
+    const built = {
+      run() {
+        if (!live()) return false;
+        const { ok, tr } = runCommands(getState(), queue);
+        if (ok && tr !== null) dispatch(tr);
+        return ok;
+      }
+    };
+    for (const name of names) {
+      built[name] = (...args) => {
+        queue.push(factories[name](...args));
+        return built;
+      };
+    }
+    return built;
+  }
+  return { commands, chain, can: () => dryRun };
+}
+
+// src/engine/clipboard/slice-blocks.ts
+function freshBlocks(pieces, baseIndent, makeId) {
+  const least = pieces.reduce((smallest, block) => Math.min(smallest, block.indent), Infinity);
+  return pieces.map((block) => ({ ...block, id: makeId(), indent: block.indent - least + baseIndent }));
+}
+
+// src/engine/clipboard/paste-at-caret.ts
+function contentOf(schema, block) {
+  return block.regions[primaryRegion(schema, block) ?? ""] ?? [];
+}
+function insertAt(tr, pos, content) {
+  if (content.length > 0) tr.step(replaceInlineStep(pos.block, pos.region, pos.offset, pos.offset, content));
+}
+function insertCapped(tr, at, blocks) {
+  tr.step(insertBlocksStep(at, blocks));
+  capIndents(tr, at, at + blocks.length);
+}
+function insertClosed(tr, schema, at, blocks) {
+  insertCapped(tr, at, blocks);
+  tr.setSelection(endOf(tr.doc, schema, blocks[blocks.length - 1].id));
+}
+function replaceEmpty(tr, schema, index, blocks) {
+  tr.step(insertBlocksStep(index, blocks));
+  tr.step(removeBlocksStep(index + blocks.length, 1));
+  capIndents(tr, index, index + blocks.length);
+  tr.setSelection(endOf(tr.doc, schema, blocks[blocks.length - 1].id));
+}
+function pasteAtCaret(tr, schema, caret, ends, pieces, makeId) {
+  const index = requireBlockIndex(tr.doc, caret.block);
+  const current = tr.doc.blocks[index];
+  const { region } = caret;
+  const first = pieces[0];
+  const last = pieces[pieces.length - 1];
+  const textual = (block) => isTextFlow(schema, block);
+  if (pieces.length === 1 && ends.openStart && ends.openEnd && textual(first)) {
+    const content = contentOf(schema, first);
+    insertAt(tr, caret, content);
+    tr.setSelection(textSelection({ ...caret, offset: caret.offset + inlineLength(content) }));
+    return;
+  }
+  const fresh = freshBlocks(pieces, current.indent, makeId);
+  if (!textual(current) || region !== primaryRegion(schema, current)) {
+    insertClosed(tr, schema, descendantsEnd(tr.doc, index), fresh);
+    return;
+  }
+  const keepsTargetType = ends.plainText === true && ends.openStart && textual(first);
+  if (regionLength(current, region) === 0 && !keepsTargetType) {
+    replaceEmpty(tr, schema, index, fresh);
+    return;
+  }
+  const atEnd = caret.offset === regionLength(current, region);
+  const atStart = caret.offset === 0;
+  const mergeFirst = ends.openStart && textual(first) && (atEnd || !atStart);
+  const mergeLast = ends.openEnd && textual(last) && !atEnd && !(mergeFirst && pieces.length === 1);
+  const middle = fresh.slice(mergeFirst ? 1 : 0, mergeLast ? fresh.length - 1 : fresh.length);
+  const lastContent = mergeLast ? contentOf(schema, fresh[fresh.length - 1]) : [];
+  if (atStart && !atEnd) {
+    if (middle.length > 0) insertCapped(tr, index, middle);
+    insertAt(tr, { ...caret, offset: 0 }, lastContent);
+    tr.setSelection(textSelection({ ...caret, offset: inlineLength(lastContent) }));
+    return;
+  }
+  const firstContent = mergeFirst ? contentOf(schema, fresh[0]) : [];
+  insertAt(tr, caret, firstContent);
+  const offset = caret.offset + inlineLength(firstContent);
+  const tail = !atEnd && (mergeLast || middle.length > 0) ? splitStep(schema, current, region, offset, makeId()) : null;
+  if (tail !== null) tr.step(tail.step);
+  if (middle.length > 0) insertCapped(tr, index + 1, middle);
+  if (tail !== null && mergeLast) {
+    insertAt(tr, { block: tail.tail.id, region: tail.tail.region, offset: 0 }, lastContent);
+    tr.setSelection(textSelection({ block: tail.tail.id, region: tail.tail.region, offset: inlineLength(lastContent) }));
+  } else if (middle.length > 0) {
+    tr.setSelection(endOf(tr.doc, schema, middle[middle.length - 1].id));
+  } else {
+    tr.setSelection(textSelection({ ...caret, offset }));
+  }
+}
+
+// src/engine/clipboard/insert-slice.ts
+function replaceSelected(tr, schema, selection, pieces, makeId) {
+  const range = selectedBlockRange(tr.doc, selection);
+  if (range === null) return;
+  const fresh = freshBlocks(pieces, tr.doc.blocks[range.start].indent, makeId);
+  tr.step(insertBlocksStep(range.end, fresh));
+  tr.step(removeBlocksStep(range.start, range.end - range.start));
+  capIndents(tr, range.start, range.start + fresh.length);
+  tr.setSelection(endOf(tr.doc, schema, fresh[fresh.length - 1].id));
+}
+function appendAtEnd(tr, schema, pieces, makeId) {
+  const at = tr.doc.blocks.length;
+  const fresh = freshBlocks(pieces, 0, makeId);
+  tr.step(insertBlocksStep(at, fresh));
+  capIndents(tr, at, at + fresh.length);
+  tr.setSelection(endOf(tr.doc, schema, fresh[fresh.length - 1].id));
+}
+function insertSlice(slice, options = {}) {
+  const makeId = options.newId ?? newId;
+  return (state, dispatch) => {
+    const { doc, schema, selection } = state;
+    const codec = createBlockCodec(schema, { newId: makeId });
+    const pieces = slice.blocks.flatMap((block) => codec.toEngineBlocks(block));
+    if (pieces.length === 0) return false;
+    const tr = new Transaction(state).setOrigin("paste");
+    if (selection === null) {
+      appendAtEnd(tr, schema, pieces, makeId);
+    } else if (selection.kind === "text") {
+      const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+      pasteAtCaret(tr, schema, deleteRange(tr, schema, from, to, makeId), slice, pieces, makeId);
+    } else {
+      replaceSelected(tr, schema, selection, pieces, makeId);
+    }
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/clipboard/paste-url.ts
+var HTTP_URL = /^(?:https?:\/\/\S|www\.[^\s.])\S*$/i;
+var LINKABLE_URL = /^(?:https?:\/\/\S|mailto:\S|www\.[^\s.])\S*$/i;
+function loneUrl(text2, schemes = "http") {
+  const url = text2.trim();
+  return (schemes === "http" ? HTTP_URL : LINKABLE_URL).test(url) ? url : null;
+}
+function pastedLink(text2, schemes = "http") {
+  const token = loneUrl(text2, schemes);
+  if (token === null) return null;
+  const url = trimUrlEnd(token);
+  const href = loneUrl(url, schemes) === null ? null : autolinkHref(url);
+  return href === null ? null : { url, href, rest: token.slice(url.length) };
+}
+
+// src/engine/clipboard/paste-link.ts
+function pasteLinkOverSelection(text2) {
+  const href = pastedLink(text2, "linkable")?.href ?? null;
+  const link = setLink(href ?? "");
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (href === null || selection?.kind !== "text" || isCollapsed(selection)) return false;
+    return link(state, dispatch && ((tr) => dispatch(tr.setOrigin("paste"))));
+  };
+}
+
+// src/engine/rules/enter-rules.ts
+var FENCE = /^```([\w+#.-]*)$/;
+function fenceTransaction(state) {
+  const { selection, doc } = state;
+  if (selection?.kind !== "text" || !isCollapsed(selection)) return null;
+  const { block: id, region, offset } = selection.head;
+  const block = blockById(doc, id);
+  if (block === void 0 || !isParagraph(block) || offset !== regionLength(block, region)) return null;
+  const fence = FENCE.exec(inlineText(block.regions[region]));
+  if (fence === null) return null;
+  return convertPrefix(state, { block: id, region, from: 0, to: offset }, setBlockType("CODE", { language: fence[1] }));
+}
+function splitBlockWithRules(options = {}) {
+  const split = splitBlock(options);
+  return (state, dispatch) => {
+    const tr = fenceTransaction(state);
+    if (tr === null) return split(state, dispatch);
+    dispatch?.(tr);
+    return true;
+  };
+}
+
+// src/engine/extension/core-keymap.ts
+var HEADINGS = [1, 2, 3, 4, 5, 6];
+var line = (attrs) => setBlockType("MARKDOWN", attrs);
+var firstThatApplies = (...commands) => (state, dispatch) => commands.some((command) => command(state, dispatch));
+function coreKeymap(options = {}) {
+  return {
+    Enter: splitBlockWithRules(options),
+    "Shift-Enter": insertHardBreak,
+    Backspace: firstThatApplies(undoInputRule, deleteBackward),
+    Delete: deleteForward,
+    Tab: indent,
+    "Shift-Tab": outdent,
+    "Mod-a": selectAll,
+    Escape: selectBlock,
+    "Mod-Shift-ArrowUp": moveBlocksUp,
+    "Mod-Shift-ArrowDown": moveBlocksDown,
+    "Mod-d": duplicateBlocks(options),
+    "Mod-Alt-0": line({ kind: "paragraph" }),
+    ...Object.fromEntries(HEADINGS.map((level) => [`Mod-Alt-${level}`, line({ kind: "heading", level })])),
+    "Mod-Shift-7": line({ kind: "ordered" }),
+    "Mod-Shift-8": line({ kind: "bullet" }),
+    "Mod-Shift-9": line({ kind: "task" }),
+    "Mod-b": toggleMark("bold"),
+    "Mod-i": toggleMark("italic"),
+    "Mod-u": toggleMark("underline"),
+    "Mod-Shift-s": toggleMark("strike"),
+    "Mod-e": toggleMark("code"),
+    "Mod-Shift-h": toggleMark("highlight")
+  };
+}
+
+// src/engine/extension/define-extension.ts
+function defineExtension(extension) {
+  if (typeof extension.name !== "string" || extension.name === "") throw new Error("an extension needs a name");
+  return extension;
+}
+
+// src/engine/extension/core-extensions.ts
+var coreCommands = {
+  ...coreCommandFactories,
+  insertSlice,
+  pasteLinkOverSelection,
+  insertTextWithRules
+};
+var linkOverSelection = {
+  name: "link-over-selection",
+  match: (text2) => loneUrl(text2, "linkable") === null ? null : pasteLinkOverSelection(text2)
+};
+function coreExtensions(options = {}) {
+  const typography = options.typography ? [defineExtension({ name: "typography", inputRules: typographyRules(options.typography) })] : [];
+  return [
+    defineExtension({
+      name: "core",
+      blocks: coreBlockSpecs,
+      marks: coreMarkSpecs,
+      atoms: coreAtomSpecs,
+      commands: coreCommands,
+      pasteRules: [linkOverSelection]
+    }),
+    defineExtension({
+      name: "history",
+      plugins: [historyPlugin()],
+      keymap: { "Mod-z": undo, "Mod-Shift-z": redo, "Mod-y": redo }
+    }),
+    defineExtension({ name: "editing-keys", keymap: coreKeymap(options) }),
+    defineExtension({ name: "markdown-shortcuts", inputRules: [...blockInputRules, ...markInputRules] }),
+    ...typography
+  ];
+}
+
+// src/engine/clipboard/serialize-slice.ts
+function sliceText(slice, options) {
+  const schema = options.schema ?? createSchema();
+  if (slice.blocks.length === 1 && slice.openStart && slice.openEnd) {
+    const pieces = createBlockCodec(schema).toEngineBlocks(slice.blocks[0]);
+    const block = pieces.length === 1 ? stripComments(pieces[0]) : null;
+    const region = block === null || !isTextFlow(schema, block) ? null : primaryRegion(schema, block);
+    if (block !== null && region !== null) return inlinePlainText(block.regions[region] ?? [], schema);
+  }
+  const markdown = toMarkdown(slice.blocks, { schema, resolveAssetUrl: options.resolveAssetUrl, comments: false });
+  return markdown.replace(/\n$/, "");
+}
+function sliceToClipboard(slice, options = {}) {
+  return {
+    json: JSON.stringify({ quoin: 1, slice }),
+    html: toHTML(slice.blocks, options),
+    text: sliceText(slice, options)
+  };
+}
+
+// src/engine/clipboard/extract-slice.ts
+function isFlowRegion(schema, block, region) {
+  return isTextFlow(schema, block) && region === primaryRegion(schema, block);
+}
+function trimmed(block, region, from, to) {
+  return { ...block, regions: { ...block.regions, [region]: sliceInline(block.regions[region], from, to) } };
+}
+function insideOneRegion(schema, block, region, from, to) {
+  if (isFlowRegion(schema, block, region)) return trimmed(block, region, from, to);
+  const paragraph = createBlock(schema, schema.defaultTextBlock, {}, block.indent, block.id);
+  return withContent(schema, paragraph, sliceInline(block.regions[region], from, to));
+}
+function textBlocks({ doc, schema }, selection) {
+  const { from, to } = orderedRange(doc, selection.anchor, selection.head);
+  const start = requireBlockIndex(doc, from.block);
+  const end = requireBlockIndex(doc, to.block);
+  const first = doc.blocks[start];
+  if (start === end) {
+    if (from.region !== to.region) return [first];
+    return [insideOneRegion(schema, first, from.region, from.offset, to.offset)];
+  }
+  const last = doc.blocks[end];
+  return [
+    isFlowRegion(schema, first, from.region) ? trimmed(first, from.region, from.offset, regionLength(first, from.region)) : first,
+    ...doc.blocks.slice(start + 1, end),
+    isFlowRegion(schema, last, to.region) ? trimmed(last, to.region, 0, to.offset) : last
+  ];
+}
+function selectedBlocks(state) {
+  const { doc, selection } = state;
+  if (selection?.kind === "text") return textBlocks(state, selection);
+  const range = selectedBlockRange(doc, selection);
+  return range === null ? [] : doc.blocks.slice(range.start, range.end);
+}
+function sliceFromSelection(state, codec) {
+  const { selection } = state;
+  if (selection === null || isCollapsed(selection)) return null;
+  const blocks = selectedBlocks(state);
+  if (blocks.length === 0) return null;
+  const base = blocks.reduce((least, block) => Math.min(least, block.indent), Infinity);
+  const open = selection.kind === "text";
+  return {
+    blocks: blocks.map((block) => codec.toQuoin(base > 0 ? { ...block, indent: block.indent - base } : block)),
+    openStart: open,
+    openEnd: open
+  };
+}
+
+// src/engine/clipboard/from-text.ts
+var BLOCK_MARKERS = [
+  /^ {0,3}#{1,6}[ \t]+\S/,
+  /^[ \t]*[-*+][ \t]+\S/,
+  /^[ \t]*\d{1,9}[.)][ \t]+\S/,
+  /^ {0,3}>[ \t]?\S/,
+  /^ {0,3}(?:`{3,}|~{3,})/,
+  /^[ \t]*\|.+\|[ \t]*$/
+];
+var INLINE_SYNTAX = [/\*\*[^*\n]+\*\*/, /__[^_\n]+__/, /\[[^\]\n]+\]\([^)\s]+[^)\n]*\)/, /`[^`\n]+`/, /~~[^~\n]+~~/];
+function looksLikeMarkdown(value) {
+  return value.split(/\r\n|\r|\n/).some((line2) => BLOCK_MARKERS.some((marker) => marker.test(line2))) || INLINE_SYNTAX.some((syntax) => syntax.test(value));
+}
+function plainTextToBlocks(value, makeId = newId) {
+  return value.split(/\r\n|\r|\n/).filter((line2) => line2.trim() !== "").map((line2) => ({
+    id: makeId(),
+    type: "MARKDOWN",
+    data: { markdown: serializeInline([text(line2)], { escapeLineStart: true }) }
+  }));
+}
+
+// src/engine/clipboard/parse-slice-json.ts
+function isBlock2(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.type !== "string") return false;
+  if (!isRecord(value.data)) return false;
+  return value.indent === void 0 || Number.isInteger(value.indent) && value.indent >= 0;
+}
+function parseSliceJSON(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || parsed.quoin !== 1 || !isRecord(parsed.slice)) return null;
+  const { blocks, openStart, openEnd } = parsed.slice;
+  if (!Array.isArray(blocks) || blocks.length === 0 || !blocks.every(isBlock2)) return null;
+  if (typeof openStart !== "boolean" || typeof openEnd !== "boolean") return null;
+  return { blocks, openStart, openEnd };
+}
+
+// src/engine/clipboard/slice-from-clipboard.ts
+var isParagraph2 = (block) => block.type === "MARKDOWN" && parseLine(String(block.data.markdown ?? "")).kind === "paragraph";
+function openSlice(blocks, plainText2 = false) {
+  if (blocks.length === 0) return null;
+  const slice = { blocks, openStart: isParagraph2(blocks[0]), openEnd: isParagraph2(blocks[blocks.length - 1]) };
+  return plainText2 ? { ...slice, plainText: plainText2 } : slice;
+}
+function linkBlocks(text2, makeId) {
+  const link = pastedLink(text2);
+  if (link === null) return null;
+  const { url, href, rest } = link;
+  const linked2 = text(url, [{ type: "link", attrs: { href } }]);
+  const markdown = serializeInline(rest === "" ? [linked2] : [linked2, text(rest)]);
+  return [{ id: makeId(), type: "MARKDOWN", data: { markdown } }];
+}
+function textBlocks2(text2, makeId) {
+  const link = linkBlocks(text2, makeId);
+  if (link !== null) return link;
+  return looksLikeMarkdown(text2) ? fromMarkdown(text2, { newId: makeId }) : plainTextToBlocks(text2, makeId);
+}
+function htmlSlice(html, options) {
+  if (html === void 0) return null;
+  const parser = availableParser(options.parser);
+  return parser === null ? null : openSlice(fromHTML(html, { ...options, parser }));
+}
+function sliceFromClipboard(data, options = {}) {
+  const fromJson = data.json === void 0 ? null : parseSliceJSON(data.json);
+  if (fromJson !== null) return fromJson;
+  const fromHtml = htmlSlice(data.html, options);
+  if (fromHtml !== null) return fromHtml;
+  return data.text === void 0 ? null : openSlice(textBlocks2(data.text, options.newId ?? newId), true);
+}
+
+// src/engine/commands/is-active.ts
+function hasAttrs(block, attrs) {
+  return Object.entries(attrs ?? {}).every(([key, value]) => block.attrs[key] === value);
+}
+function isActive(state, name, attrs) {
+  if (state.schema.marks.has(name)) return selectionHasMark(state, name, attrs);
+  const blocks = selectedBlockIds(state.doc, state.selection).flatMap((id) => blockById(state.doc, id) ?? []);
+  const isBlockType = state.schema.blocks.has(name);
+  const matches = (block) => isBlockType ? block.type === name : block.type === "MARKDOWN" && block.attrs.kind === name;
+  return blocks.length > 0 && blocks.every((block) => matches(block) && hasAttrs(block, attrs));
+}
+
+// src/engine/model/same-doc.ts
+function sameDoc(a, b) {
+  if (a === b) return true;
+  return a.blocks.length === b.blocks.length && a.blocks.every((block, i) => sameValue(block, b.blocks[i]));
+}
+
+// src/engine/extension/same-blocks.ts
+function sameBlock(a, b) {
+  return a === b || a.id === b.id && a.type === b.type && (a.indent ?? 0) === (b.indent ?? 0) && sameValue(a.data, b.data);
+}
+function sameBlocks(a, b) {
+  return a === b || sameItems(a, b, sameBlock);
+}
+
+// src/engine/extension/structural-echo.ts
+var sameIds = (a, b) => sameItems(a, b, (x, y) => x.id === y.id);
+function copiedSequence(emissions, incoming) {
+  const verdicts = /* @__PURE__ */ new Map();
+  const sameAt = (block, index) => {
+    const known = verdicts.get(block);
+    if (known !== void 0) return known;
+    const same = sameBlock(block, incoming[index]);
+    verdicts.set(block, same);
+    return same;
+  };
+  return emissions.find(({ blocks }) => sameIds(blocks, incoming) && blocks.every(sameAt))?.sequence;
+}
+
+// src/engine/extension/echo-tracker.ts
+var STRUCTURAL_ECHO_WINDOW = 256;
+function createEchoTracker() {
+  const sequences = /* @__PURE__ */ new WeakMap();
+  let emitted = 0;
+  let acknowledged = 0;
+  let outstanding = [];
+  return {
+    emitted(blocks) {
+      sequences.set(blocks, ++emitted);
+      outstanding.push({ blocks, sequence: emitted });
+      if (outstanding.length > STRUCTURAL_ECHO_WINDOW) outstanding.shift();
+    },
+    classify(blocks) {
+      const sequence = sequences.get(blocks) ?? copiedSequence(outstanding, blocks);
+      if (sequence === void 0 || sequence <= acknowledged) return "foreign";
+      acknowledged = sequence;
+      outstanding = outstanding.filter((emission) => emission.sequence > sequence);
+      return "echo";
+    },
+    forgetAll() {
+      acknowledged = emitted;
+      outstanding = [];
+    }
+  };
+}
+
+// src/engine/extension/controlled-blocks.ts
+function createControlledBlocks(config) {
+  const { codec, state, dispatch, onChange, accepts } = config;
+  const tracker = createEchoTracker();
+  const quiet = /* @__PURE__ */ new WeakSet();
+  let supplied = config.initial;
+  let converted = null;
+  function getBlocks() {
+    const { doc } = state();
+    if (converted?.doc !== doc) converted = { doc, blocks: codec.blocksFromDoc(doc) };
+    return converted.blocks;
+  }
+  function reconcile(incoming) {
+    const doc = codec.docFromBlocks(incoming);
+    if (sameDoc(doc, state().doc) || !accepts(incoming)) return false;
+    tracker.forgetAll();
+    const tr = new Transaction(state()).setOrigin("reconcile").setMeta("addToHistory", false);
+    if (sameBlocks(codec.blocksFromDoc(doc), incoming)) quiet.add(tr);
+    dispatch(tr.step(replaceDocStep(doc)));
+    return true;
+  }
+  return {
+    getBlocks,
+    setBlocks(incoming) {
+      const previous = supplied;
+      supplied = incoming;
+      if (incoming === previous || tracker.classify(incoming) === "echo") return false;
+      if (sameBlocks(incoming, previous) || sameBlocks(incoming, getBlocks())) return false;
+      return reconcile(incoming);
+    },
+    committed(tr) {
+      if (!tr.docChanged || quiet.has(tr)) return;
+      const blocks = getBlocks();
+      tracker.emitted(blocks);
+      onChange?.(blocks);
+    }
+  };
+}
+
+// src/engine/extension/detect-mac.ts
+function detectMac() {
+  if (typeof navigator === "undefined") return false;
+  return /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent);
+}
+
+// src/engine/extension/dispatch-queue.ts
+function createDispatchQueue(current, commit) {
+  const accepted = /* @__PURE__ */ new WeakSet();
+  let waiting = null;
+  let committing = false;
+  function dispatch(tr) {
+    if (accepted.has(tr)) throw new RangeError("This transaction was already dispatched");
+    if (tr.before !== current() || waiting !== null) throw mismatchedTransaction();
+    accepted.add(tr);
+    if (committing) {
+      waiting = tr;
+      return;
+    }
+    committing = true;
+    try {
+      for (let next = tr; next !== null; next = waiting) {
+        waiting = null;
+        commit(next);
+      }
+    } finally {
+      committing = false;
+      waiting = null;
+    }
+  }
+  return {
+    dispatch,
+    clear() {
+      waiting = null;
+    }
+  };
+}
+
+// src/engine/extension/keymap.ts
+var MODIFIERS = ["Alt", "Ctrl", "Meta", "Shift"];
+var PHYSICAL_KEY = /^(?:Key([A-Z])|Digit([0-9]))$/;
+var PLAIN_KEY = /^[a-z0-9]$/;
+var lowerSingle = (key) => key.length === 1 ? key.toLowerCase() : key;
+var join2 = (held, key) => [...MODIFIERS.filter((m) => held.has(m)), key].join("-");
+function modifierOf(part, isMac, name) {
+  if (part === "Mod") return isMac ? "Meta" : "Ctrl";
+  if (MODIFIERS.includes(part)) return part;
+  throw new Error(`unknown modifier "${part}" in key "${name}"`);
+}
+function normalizeKey(name, isMac) {
+  const split = name.lastIndexOf("-", name.length - 2);
+  if (split < 1) return lowerSingle(name);
+  const held = new Set(
+    name.slice(0, split).split("-").map((part) => modifierOf(part, isMac, name))
+  );
+  return join2(held, lowerSingle(name.slice(split + 1)));
+}
+function eventKey({ key, code, shiftKey, altKey }, isMac) {
+  const typed2 = lowerSingle(key ?? "Unidentified");
+  if (!(shiftKey || isMac && altKey) || PLAIN_KEY.test(typed2)) return typed2;
+  const physical = code === void 0 ? null : PHYSICAL_KEY.exec(code);
+  return physical === null ? typed2 : (physical[1] ?? physical[2]).toLowerCase();
+}
+function keyName(event, isMac) {
+  const held = /* @__PURE__ */ new Set();
+  if (event.altKey) held.add("Alt");
+  if (event.ctrlKey) held.add("Ctrl");
+  if (event.metaKey) held.add("Meta");
+  if (event.shiftKey) held.add("Shift");
+  return join2(held, eventKey(event, isMac));
+}
+function runKeymap(keymap, state, dispatch, event, isMac) {
+  return (keymap.get(keyName(event, isMac)) ?? []).some((command) => command(state, dispatch));
+}
+
+// src/engine/extension/resolve-extensions.ts
+var DEFAULT_PRIORITY = 100;
+function keymapOf(extensions, isMac) {
+  const keymap = /* @__PURE__ */ new Map();
+  for (const { keymap: bindings } of extensions) {
+    for (const [name, command] of Object.entries(bindings ?? {})) {
+      const key = normalizeKey(name, isMac);
+      keymap.set(key, [...keymap.get(key) ?? [], command]);
+    }
+  }
+  return keymap;
+}
+function commandsOf(extensions) {
+  const commands = /* @__PURE__ */ new Map();
+  for (const { commands: factories } of extensions) {
+    for (const [name, factory] of Object.entries(factories ?? {})) {
+      if (!commands.has(name)) commands.set(name, factory);
+    }
+  }
+  return Object.fromEntries(commands);
+}
+function resolveExtensions(extensions, isMac) {
+  const sorted = [...extensions].sort(
+    (a, b) => (b.priority ?? DEFAULT_PRIORITY) - (a.priority ?? DEFAULT_PRIORITY)
+  );
+  return {
+    extensions: sorted,
+    schema: createSchema({
+      blocks: sorted.flatMap((extension) => extension.blocks ?? []),
+      marks: sorted.flatMap((extension) => extension.marks ?? []),
+      atoms: sorted.flatMap((extension) => extension.atoms ?? [])
+    }),
+    inputRules: sorted.flatMap((extension) => extension.inputRules ?? []),
+    pasteRules: sorted.flatMap((extension) => extension.pasteRules ?? []),
+    keymap: keymapOf(sorted, isMac),
+    commands: commandsOf(sorted),
+    plugins: sorted.flatMap((extension) => extension.plugins ?? []),
+    decorations: (state) => sorted.flatMap((extension) => extension.decorations?.(state) ?? []),
+    filterTransaction: (tr, state) => sorted.every((extension) => extension.filterTransaction?.(tr, state) !== false)
+  };
+}
+
+// src/engine/extension/editor.ts
+function createEditor(options) {
+  return createInternalEditor(options);
+}
+function createInternalEditor(options) {
+  const { newId: newId2 } = options;
+  const isMac = options.isMac ?? detectMac();
+  const resolved = resolveExtensions(options.extensions ?? coreExtensions({ newId: newId2 }), isMac);
+  const { schema, plugins } = resolved;
+  const codec = createBlockCodec(schema, { newId: newId2 });
+  const listeners = /* @__PURE__ */ new Set();
+  const mounts = /* @__PURE__ */ new Set();
+  let state = createState({ doc: codec.docFromBlocks(options.blocks), schema, plugins, clock: options.now });
+  let destroyed = false;
+  const controlled = createControlledBlocks({
+    codec,
+    initial: options.blocks,
+    state: () => state,
+    dispatch,
+    onChange: options.onChange,
+    accepts: (incoming) => resolved.extensions.every((extension) => extension.filterHostBlocks?.(incoming, state) !== false)
+  });
+  const { getBlocks } = controlled;
+  function commit(tr) {
+    const exempt = foreignOrigins.includes(tr.origin) || tr.getMeta(UNFILTERED) === true;
+    if (!exempt && !resolved.filterTransaction(tr, state)) return;
+    state = applyTransaction(state, tr);
+    for (const listener of [...listeners]) listener(state, tr);
+    for (const extension of resolved.extensions) extension.onTransaction?.(tr, state);
+    options.onTransaction?.(tr, state);
+    controlled.committed(tr);
+  }
+  const queue = createDispatchQueue(() => state, commit);
+  function dispatch(tr) {
+    if (destroyed) throw new Error("Cannot dispatch to a destroyed editor");
+    queue.dispatch(tr);
+  }
+  function paste(data, parser) {
+    if (destroyed) return false;
+    const { text: text2 } = data;
+    const ruled = text2 !== void 0 && resolved.pasteRules.some((rule) => rule.match(text2, state)?.(state, dispatch));
+    if (ruled) return true;
+    const slice = sliceFromClipboard(data, { parser, newId: newId2 });
+    return slice !== null && insertSlice(slice, { newId: newId2 })(state, dispatch);
+  }
+  function copy() {
+    const slice = sliceFromSelection(state, codec);
+    return slice === null ? null : sliceToClipboard(slice, { schema, resolveAssetUrl: options.resolveAssetUrl });
+  }
+  function exportMarkdown(markdown = {}) {
+    const resolveAssetUrl = markdown.resolveAssetUrl ?? options.resolveAssetUrl;
+    return toMarkdown(getBlocks(), { schema, ...markdown, resolveAssetUrl });
+  }
+  const helpers = createCommandHelpers(() => state, dispatch, resolved.commands, () => !destroyed);
+  const editor = {
+    get state() {
+      return state;
+    },
+    schema,
+    resolved,
+    codec,
+    dispatch,
+    createTransaction: () => new Transaction(state),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    commands: helpers.commands,
+    chain: helpers.chain,
+    can: helpers.can,
+    isActive: (name, attrs) => isActive(state, name, attrs),
+    insertText: (text2) => !destroyed && insertTextWithRules(text2, resolved.inputRules, { newId: newId2 })(state, dispatch),
+    handleKey: (event) => !destroyed && runKeymap(resolved.keymap, state, dispatch, event, isMac),
+    paste,
+    copy,
+    getBlocks,
+    setBlocks: (incoming) => !destroyed && controlled.setBlocks(incoming),
+    mount() {
+      const stops = [];
+      const unmount = () => {
+        if (mounts.delete(unmount)) for (const stop of stops) stop?.();
+      };
+      mounts.add(unmount);
+      try {
+        if (!destroyed) for (const extension of resolved.extensions) stops.push(extension.onMount?.(editor));
+      } catch (error) {
+        unmount();
+        throw error;
+      }
+      return unmount;
+    },
+    decorations: () => resolved.decorations(state),
+    toMarkdown: exportMarkdown,
+    stats: () => countDoc(state.doc, { schema }),
+    destroy() {
+      destroyed = true;
+      listeners.clear();
+      queue.clear();
+      mounts.forEach((unmount) => unmount());
+    }
+  };
+  return editor;
+}
+
+export {
+  setAttrsStep,
+  setIndentStep,
+  insertBlocksStep,
+  removeBlocksStep,
+  moveBlocksStep,
+  replaceBlockStep,
+  replaceInlineStep,
+  addMarkStep,
+  removeMarkStep,
+  commonPrefix,
+  commonSuffix,
+  replaceDocStep,
+  splitBlockStep,
+  joinBlocksStep,
+  stepFromJSON,
+  comparePos,
+  orderedRange,
+  textSelection,
+  nodeSelection,
+  blockRangeSelection,
+  isCollapsed,
+  sameSelection,
+  selectionRange,
+  selectedBlockIds,
+  mapSelection,
+  primaryRegion,
+  startOf,
+  endOf,
+  validateSelection,
+  isClosedToggle,
+  hidingToggle,
+  createState,
+  applyTransaction,
+  getPluginState,
+  createPluginKey,
+  foreignOrigins,
+  Transaction,
+  caretMarks,
+  runCommands,
+  HISTORY_PROVIDER,
+  HISTORY_GROUP,
+  undo,
+  redo,
+  undoInputRule,
+  isTextFlow,
+  isParagraph,
+  regionLength,
+  descendantsEnd,
+  createBlock,
+  withContent,
+  headBlockId,
+  selectedBlockRange,
+  capIndents,
+  toggleTask,
+  indent,
+  outdent,
+  moveBlocksUp,
+  moveBlocksDown,
+  duplicateBlocks,
+  deleteBlocks,
+  insertBlockAfter,
+  deleteRange,
+  insertTextAt,
+  insertText,
+  markExtent,
+  markRanges,
+  rangeContent,
+  markCoverage,
+  toggleMark,
+  setMark,
+  unsetMark,
+  setLink,
+  unsetLink,
+  insertMention,
+  setBlockType,
+  insertTextWithRules,
+  blockInputRules,
+  regionInline,
+  markInputRules,
+  typographyRules,
+  fromHTML,
+  toMarkdown,
+  toHTML,
+  toPlainText,
+  graphemeCount,
+  wordCount,
+  nextGraphemeOffset,
+  prevGraphemeOffset,
+  countBlock,
+  countText,
+  countDoc,
+  setAttrs,
+  setTextAlign,
+  setBlockColor,
+  LINE_JOIN,
+  deleteSelection,
+  deleteBackward,
+  deleteForward,
+  deleteWordBackward,
+  deleteWordForward,
+  deleteToLineStart,
+  deleteToLineEnd,
+  insertHardBreak,
+  movedBlockIds,
+  moveBlocksTo,
+  selectAll,
+  setSelection,
+  LINE_SPLIT,
+  freshBlocks,
+  pasteAtCaret,
+  insertSlice,
+  pastedLink,
+  defineExtension,
+  coreExtensions,
+  sliceFromSelection,
+  sliceFromClipboard,
+  isActive,
+  sameDoc,
+  detectMac,
+  normalizeKey,
+  keyName,
+  createEditor
+};
+//# sourceMappingURL=chunk-HJIQT3S5.js.map