prosekit 0.0.0-next-20230627094841

package/dist/chunk-VIKPJJET.js

@@ -0,0 +1,662 @@
+import {
+  AllSelection,
+  NodeSelection,
+  Selection,
+  TextSelection
+} from "./chunk-UTNVEPBA.js";
+import {
+  ReplaceAroundStep,
+  ReplaceStep,
+  canJoin,
+  canSplit,
+  findWrapping,
+  joinPoint,
+  liftTarget,
+  replaceStep
+} from "./chunk-ERNIDFFW.js";
+import {
+  Fragment,
+  Slice
+} from "./chunk-FAVXZAF7.js";
+
+// ../../node_modules/.pnpm/prosemirror-commands@1.5.2/node_modules/prosemirror-commands/dist/index.js
+var deleteSelection = (state, dispatch) => {
+  if (state.selection.empty)
+    return false;
+  if (dispatch)
+    dispatch(state.tr.deleteSelection().scrollIntoView());
+  return true;
+};
+function atBlockStart(state, view) {
+  let { $cursor } = state.selection;
+  if (!$cursor || (view ? !view.endOfTextblock("backward", state) : $cursor.parentOffset > 0))
+    return null;
+  return $cursor;
+}
+var joinBackward = (state, dispatch, view) => {
+  let $cursor = atBlockStart(state, view);
+  if (!$cursor)
+    return false;
+  let $cut = findCutBefore($cursor);
+  if (!$cut) {
+    let range = $cursor.blockRange(), target = range && liftTarget(range);
+    if (target == null)
+      return false;
+    if (dispatch)
+      dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+  }
+  let before = $cut.nodeBefore;
+  if (!before.type.spec.isolating && deleteBarrier(state, $cut, dispatch))
+    return true;
+  if ($cursor.parent.content.size == 0 && (textblockAt(before, "end") || NodeSelection.isSelectable(before))) {
+    let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
+    if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+      if (dispatch) {
+        let tr = state.tr.step(delStep);
+        tr.setSelection(textblockAt(before, "end") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1) : NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    }
+  }
+  if (before.isAtom && $cut.depth == $cursor.depth - 1) {
+    if (dispatch)
+      dispatch(state.tr.delete($cut.pos - before.nodeSize, $cut.pos).scrollIntoView());
+    return true;
+  }
+  return false;
+};
+var joinTextblockBackward = (state, dispatch, view) => {
+  let $cursor = atBlockStart(state, view);
+  if (!$cursor)
+    return false;
+  let $cut = findCutBefore($cursor);
+  return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+var joinTextblockForward = (state, dispatch, view) => {
+  let $cursor = atBlockEnd(state, view);
+  if (!$cursor)
+    return false;
+  let $cut = findCutAfter($cursor);
+  return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+function joinTextblocksAround(state, $cut, dispatch) {
+  let before = $cut.nodeBefore, beforeText = before, beforePos = $cut.pos - 1;
+  for (; !beforeText.isTextblock; beforePos--) {
+    if (beforeText.type.spec.isolating)
+      return false;
+    let child = beforeText.lastChild;
+    if (!child)
+      return false;
+    beforeText = child;
+  }
+  let after = $cut.nodeAfter, afterText = after, afterPos = $cut.pos + 1;
+  for (; !afterText.isTextblock; afterPos++) {
+    if (afterText.type.spec.isolating)
+      return false;
+    let child = afterText.firstChild;
+    if (!child)
+      return false;
+    afterText = child;
+  }
+  let step = replaceStep(state.doc, beforePos, afterPos, Slice.empty);
+  if (!step || step.from != beforePos || step instanceof ReplaceStep && step.slice.size >= afterPos - beforePos)
+    return false;
+  if (dispatch) {
+    let tr = state.tr.step(step);
+    tr.setSelection(TextSelection.create(tr.doc, beforePos));
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+}
+function textblockAt(node, side, only = false) {
+  for (let scan = node; scan; scan = side == "start" ? scan.firstChild : scan.lastChild) {
+    if (scan.isTextblock)
+      return true;
+    if (only && scan.childCount != 1)
+      return false;
+  }
+  return false;
+}
+var selectNodeBackward = (state, dispatch, view) => {
+  let { $head, empty } = state.selection, $cut = $head;
+  if (!empty)
+    return false;
+  if ($head.parent.isTextblock) {
+    if (view ? !view.endOfTextblock("backward", state) : $head.parentOffset > 0)
+      return false;
+    $cut = findCutBefore($head);
+  }
+  let node = $cut && $cut.nodeBefore;
+  if (!node || !NodeSelection.isSelectable(node))
+    return false;
+  if (dispatch)
+    dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos - node.nodeSize)).scrollIntoView());
+  return true;
+};
+function findCutBefore($pos) {
+  if (!$pos.parent.type.spec.isolating)
+    for (let i = $pos.depth - 1; i >= 0; i--) {
+      if ($pos.index(i) > 0)
+        return $pos.doc.resolve($pos.before(i + 1));
+      if ($pos.node(i).type.spec.isolating)
+        break;
+    }
+  return null;
+}
+function atBlockEnd(state, view) {
+  let { $cursor } = state.selection;
+  if (!$cursor || (view ? !view.endOfTextblock("forward", state) : $cursor.parentOffset < $cursor.parent.content.size))
+    return null;
+  return $cursor;
+}
+var joinForward = (state, dispatch, view) => {
+  let $cursor = atBlockEnd(state, view);
+  if (!$cursor)
+    return false;
+  let $cut = findCutAfter($cursor);
+  if (!$cut)
+    return false;
+  let after = $cut.nodeAfter;
+  if (deleteBarrier(state, $cut, dispatch))
+    return true;
+  if ($cursor.parent.content.size == 0 && (textblockAt(after, "start") || NodeSelection.isSelectable(after))) {
+    let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
+    if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+      if (dispatch) {
+        let tr = state.tr.step(delStep);
+        tr.setSelection(textblockAt(after, "start") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos)), 1) : NodeSelection.create(tr.doc, tr.mapping.map($cut.pos)));
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    }
+  }
+  if (after.isAtom && $cut.depth == $cursor.depth - 1) {
+    if (dispatch)
+      dispatch(state.tr.delete($cut.pos, $cut.pos + after.nodeSize).scrollIntoView());
+    return true;
+  }
+  return false;
+};
+var selectNodeForward = (state, dispatch, view) => {
+  let { $head, empty } = state.selection, $cut = $head;
+  if (!empty)
+    return false;
+  if ($head.parent.isTextblock) {
+    if (view ? !view.endOfTextblock("forward", state) : $head.parentOffset < $head.parent.content.size)
+      return false;
+    $cut = findCutAfter($head);
+  }
+  let node = $cut && $cut.nodeAfter;
+  if (!node || !NodeSelection.isSelectable(node))
+    return false;
+  if (dispatch)
+    dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos)).scrollIntoView());
+  return true;
+};
+function findCutAfter($pos) {
+  if (!$pos.parent.type.spec.isolating)
+    for (let i = $pos.depth - 1; i >= 0; i--) {
+      let parent = $pos.node(i);
+      if ($pos.index(i) + 1 < parent.childCount)
+        return $pos.doc.resolve($pos.after(i + 1));
+      if (parent.type.spec.isolating)
+        break;
+    }
+  return null;
+}
+var joinUp = (state, dispatch) => {
+  let sel = state.selection, nodeSel = sel instanceof NodeSelection, point;
+  if (nodeSel) {
+    if (sel.node.isTextblock || !canJoin(state.doc, sel.from))
+      return false;
+    point = sel.from;
+  } else {
+    point = joinPoint(state.doc, sel.from, -1);
+    if (point == null)
+      return false;
+  }
+  if (dispatch) {
+    let tr = state.tr.join(point);
+    if (nodeSel)
+      tr.setSelection(NodeSelection.create(tr.doc, point - state.doc.resolve(point).nodeBefore.nodeSize));
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+};
+var joinDown = (state, dispatch) => {
+  let sel = state.selection, point;
+  if (sel instanceof NodeSelection) {
+    if (sel.node.isTextblock || !canJoin(state.doc, sel.to))
+      return false;
+    point = sel.to;
+  } else {
+    point = joinPoint(state.doc, sel.to, 1);
+    if (point == null)
+      return false;
+  }
+  if (dispatch)
+    dispatch(state.tr.join(point).scrollIntoView());
+  return true;
+};
+var lift = (state, dispatch) => {
+  let { $from, $to } = state.selection;
+  let range = $from.blockRange($to), target = range && liftTarget(range);
+  if (target == null)
+    return false;
+  if (dispatch)
+    dispatch(state.tr.lift(range, target).scrollIntoView());
+  return true;
+};
+var newlineInCode = (state, dispatch) => {
+  let { $head, $anchor } = state.selection;
+  if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+    return false;
+  if (dispatch)
+    dispatch(state.tr.insertText("\n").scrollIntoView());
+  return true;
+};
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i++) {
+    let { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs())
+      return type;
+  }
+  return null;
+}
+var exitCode = (state, dispatch) => {
+  let { $head, $anchor } = state.selection;
+  if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+    return false;
+  let above = $head.node(-1), after = $head.indexAfter(-1), type = defaultBlockAt(above.contentMatchAt(after));
+  if (!type || !above.canReplaceWith(after, after, type))
+    return false;
+  if (dispatch) {
+    let pos = $head.after(), tr = state.tr.replaceWith(pos, pos, type.createAndFill());
+    tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+};
+var createParagraphNear = (state, dispatch) => {
+  let sel = state.selection, { $from, $to } = sel;
+  if (sel instanceof AllSelection || $from.parent.inlineContent || $to.parent.inlineContent)
+    return false;
+  let type = defaultBlockAt($to.parent.contentMatchAt($to.indexAfter()));
+  if (!type || !type.isTextblock)
+    return false;
+  if (dispatch) {
+    let side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;
+    let tr = state.tr.insert(side, type.createAndFill());
+    tr.setSelection(TextSelection.create(tr.doc, side + 1));
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+};
+var liftEmptyBlock = (state, dispatch) => {
+  let { $cursor } = state.selection;
+  if (!$cursor || $cursor.parent.content.size)
+    return false;
+  if ($cursor.depth > 1 && $cursor.after() != $cursor.end(-1)) {
+    let before = $cursor.before();
+    if (canSplit(state.doc, before)) {
+      if (dispatch)
+        dispatch(state.tr.split(before).scrollIntoView());
+      return true;
+    }
+  }
+  let range = $cursor.blockRange(), target = range && liftTarget(range);
+  if (target == null)
+    return false;
+  if (dispatch)
+    dispatch(state.tr.lift(range, target).scrollIntoView());
+  return true;
+};
+function splitBlockAs(splitNode) {
+  return (state, dispatch) => {
+    let { $from, $to } = state.selection;
+    if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
+      if (!$from.parentOffset || !canSplit(state.doc, $from.pos))
+        return false;
+      if (dispatch)
+        dispatch(state.tr.split($from.pos).scrollIntoView());
+      return true;
+    }
+    if (!$from.parent.isBlock)
+      return false;
+    if (dispatch) {
+      let atEnd = $to.parentOffset == $to.parent.content.size;
+      let tr = state.tr;
+      if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)
+        tr.deleteSelection();
+      let deflt = $from.depth == 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
+      let splitType = splitNode && splitNode($to.parent, atEnd);
+      let types = splitType ? [splitType] : atEnd && deflt ? [{ type: deflt }] : void 0;
+      let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
+      if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
+        if (deflt)
+          types = [{ type: deflt }];
+        can = true;
+      }
+      if (can) {
+        tr.split(tr.mapping.map($from.pos), 1, types);
+        if (!atEnd && !$from.parentOffset && $from.parent.type != deflt) {
+          let first = tr.mapping.map($from.before()), $first = tr.doc.resolve(first);
+          if (deflt && $from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt))
+            tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+        }
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+var splitBlock = splitBlockAs();
+var splitBlockKeepMarks = (state, dispatch) => {
+  return splitBlock(state, dispatch && ((tr) => {
+    let marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
+    if (marks)
+      tr.ensureMarks(marks);
+    dispatch(tr);
+  }));
+};
+var selectParentNode = (state, dispatch) => {
+  let { $from, to } = state.selection, pos;
+  let same = $from.sharedDepth(to);
+  if (same == 0)
+    return false;
+  pos = $from.before(same);
+  if (dispatch)
+    dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)));
+  return true;
+};
+var selectAll = (state, dispatch) => {
+  if (dispatch)
+    dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+  return true;
+};
+function joinMaybeClear(state, $pos, dispatch) {
+  let before = $pos.nodeBefore, after = $pos.nodeAfter, index = $pos.index();
+  if (!before || !after || !before.type.compatibleContent(after.type))
+    return false;
+  if (!before.content.size && $pos.parent.canReplace(index - 1, index)) {
+    if (dispatch)
+      dispatch(state.tr.delete($pos.pos - before.nodeSize, $pos.pos).scrollIntoView());
+    return true;
+  }
+  if (!$pos.parent.canReplace(index, index + 1) || !(after.isTextblock || canJoin(state.doc, $pos.pos)))
+    return false;
+  if (dispatch)
+    dispatch(state.tr.clearIncompatible($pos.pos, before.type, before.contentMatchAt(before.childCount)).join($pos.pos).scrollIntoView());
+  return true;
+}
+function deleteBarrier(state, $cut, dispatch) {
+  let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;
+  if (before.type.spec.isolating || after.type.spec.isolating)
+    return false;
+  if (joinMaybeClear(state, $cut, dispatch))
+    return true;
+  let canDelAfter = $cut.parent.canReplace($cut.index(), $cut.index() + 1);
+  if (canDelAfter && (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) && match.matchType(conn[0] || after.type).validEnd) {
+    if (dispatch) {
+      let end = $cut.pos + after.nodeSize, wrap = Fragment.empty;
+      for (let i = conn.length - 1; i >= 0; i--)
+        wrap = Fragment.from(conn[i].create(null, wrap));
+      wrap = Fragment.from(before.copy(wrap));
+      let tr = state.tr.step(new ReplaceAroundStep($cut.pos - 1, end, $cut.pos, end, new Slice(wrap, 1, 0), conn.length, true));
+      let joinAt = end + 2 * conn.length;
+      if (canJoin(tr.doc, joinAt))
+        tr.join(joinAt);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  }
+  let selAfter = Selection.findFrom($cut, 1);
+  let range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && liftTarget(range);
+  if (target != null && target >= $cut.depth) {
+    if (dispatch)
+      dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+  }
+  if (canDelAfter && textblockAt(after, "start", true) && textblockAt(before, "end")) {
+    let at = before, wrap = [];
+    for (; ; ) {
+      wrap.push(at);
+      if (at.isTextblock)
+        break;
+      at = at.lastChild;
+    }
+    let afterText = after, afterDepth = 1;
+    for (; !afterText.isTextblock; afterText = afterText.firstChild)
+      afterDepth++;
+    if (at.canReplace(at.childCount, at.childCount, afterText.content)) {
+      if (dispatch) {
+        let end = Fragment.empty;
+        for (let i = wrap.length - 1; i >= 0; i--)
+          end = Fragment.from(wrap[i].copy(end));
+        let tr = state.tr.step(new ReplaceAroundStep($cut.pos - wrap.length, $cut.pos + after.nodeSize, $cut.pos + afterDepth, $cut.pos + after.nodeSize - afterDepth, new Slice(end, wrap.length, 0), 0, true));
+        dispatch(tr.scrollIntoView());
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function selectTextblockSide(side) {
+  return function(state, dispatch) {
+    let sel = state.selection, $pos = side < 0 ? sel.$from : sel.$to;
+    let depth = $pos.depth;
+    while ($pos.node(depth).isInline) {
+      if (!depth)
+        return false;
+      depth--;
+    }
+    if (!$pos.node(depth).isTextblock)
+      return false;
+    if (dispatch)
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, side < 0 ? $pos.start(depth) : $pos.end(depth))));
+    return true;
+  };
+}
+var selectTextblockStart = selectTextblockSide(-1);
+var selectTextblockEnd = selectTextblockSide(1);
+function wrapIn(nodeType, attrs = null) {
+  return function(state, dispatch) {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to), wrapping = range && findWrapping(range, nodeType, attrs);
+    if (!wrapping)
+      return false;
+    if (dispatch)
+      dispatch(state.tr.wrap(range, wrapping).scrollIntoView());
+    return true;
+  };
+}
+function setBlockType(nodeType, attrs = null) {
+  return function(state, dispatch) {
+    let applicable = false;
+    for (let i = 0; i < state.selection.ranges.length && !applicable; i++) {
+      let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (applicable)
+          return false;
+        if (!node.isTextblock || node.hasMarkup(nodeType, attrs))
+          return;
+        if (node.type == nodeType) {
+          applicable = true;
+        } else {
+          let $pos = state.doc.resolve(pos), index = $pos.index();
+          applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
+        }
+      });
+    }
+    if (!applicable)
+      return false;
+    if (dispatch) {
+      let tr = state.tr;
+      for (let i = 0; i < state.selection.ranges.length; i++) {
+        let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+        tr.setBlockType(from, to, nodeType, attrs);
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function markApplies(doc, ranges, type) {
+  for (let i = 0; i < ranges.length; i++) {
+    let { $from, $to } = ranges[i];
+    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
+    doc.nodesBetween($from.pos, $to.pos, (node) => {
+      if (can)
+        return false;
+      can = node.inlineContent && node.type.allowsMarkType(type);
+    });
+    if (can)
+      return true;
+  }
+  return false;
+}
+function toggleMark(markType, attrs = null) {
+  return function(state, dispatch) {
+    let { empty, $cursor, ranges } = state.selection;
+    if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
+      return false;
+    if (dispatch) {
+      if ($cursor) {
+        if (markType.isInSet(state.storedMarks || $cursor.marks()))
+          dispatch(state.tr.removeStoredMark(markType));
+        else
+          dispatch(state.tr.addStoredMark(markType.create(attrs)));
+      } else {
+        let has = false, tr = state.tr;
+        for (let i = 0; !has && i < ranges.length; i++) {
+          let { $from, $to } = ranges[i];
+          has = state.doc.rangeHasMark($from.pos, $to.pos, markType);
+        }
+        for (let i = 0; i < ranges.length; i++) {
+          let { $from, $to } = ranges[i];
+          if (has) {
+            tr.removeMark($from.pos, $to.pos, markType);
+          } else {
+            let from = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore;
+            let spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
+            let spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
+            if (from + spaceStart < to) {
+              from += spaceStart;
+              to -= spaceEnd;
+            }
+            tr.addMark(from, to, markType.create(attrs));
+          }
+        }
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+}
+function wrapDispatchForJoin(dispatch, isJoinable) {
+  return (tr) => {
+    if (!tr.isGeneric)
+      return dispatch(tr);
+    let ranges = [];
+    for (let i = 0; i < tr.mapping.maps.length; i++) {
+      let map = tr.mapping.maps[i];
+      for (let j = 0; j < ranges.length; j++)
+        ranges[j] = map.map(ranges[j]);
+      map.forEach((_s, _e, from, to) => ranges.push(from, to));
+    }
+    let joinable = [];
+    for (let i = 0; i < ranges.length; i += 2) {
+      let from = ranges[i], to = ranges[i + 1];
+      let $from = tr.doc.resolve(from), depth = $from.sharedDepth(to), parent = $from.node(depth);
+      for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
+        let after = parent.maybeChild(index);
+        if (!after)
+          break;
+        if (index && joinable.indexOf(pos) == -1) {
+          let before = parent.child(index - 1);
+          if (before.type == after.type && isJoinable(before, after))
+            joinable.push(pos);
+        }
+        pos += after.nodeSize;
+      }
+    }
+    joinable.sort((a, b) => a - b);
+    for (let i = joinable.length - 1; i >= 0; i--) {
+      if (canJoin(tr.doc, joinable[i]))
+        tr.join(joinable[i]);
+    }
+    dispatch(tr);
+  };
+}
+function autoJoin(command, isJoinable) {
+  let canJoin2 = Array.isArray(isJoinable) ? (node) => isJoinable.indexOf(node.type.name) > -1 : isJoinable;
+  return (state, dispatch, view) => command(state, dispatch && wrapDispatchForJoin(dispatch, canJoin2), view);
+}
+function chainCommands(...commands) {
+  return function(state, dispatch, view) {
+    for (let i = 0; i < commands.length; i++)
+      if (commands[i](state, dispatch, view))
+        return true;
+    return false;
+  };
+}
+var backspace = chainCommands(deleteSelection, joinBackward, selectNodeBackward);
+var del = chainCommands(deleteSelection, joinForward, selectNodeForward);
+var pcBaseKeymap = {
+  "Enter": chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock),
+  "Mod-Enter": exitCode,
+  "Backspace": backspace,
+  "Mod-Backspace": backspace,
+  "Shift-Backspace": backspace,
+  "Delete": del,
+  "Mod-Delete": del,
+  "Mod-a": selectAll
+};
+var macBaseKeymap = {
+  "Ctrl-h": pcBaseKeymap["Backspace"],
+  "Alt-Backspace": pcBaseKeymap["Mod-Backspace"],
+  "Ctrl-d": pcBaseKeymap["Delete"],
+  "Ctrl-Alt-Backspace": pcBaseKeymap["Mod-Delete"],
+  "Alt-Delete": pcBaseKeymap["Mod-Delete"],
+  "Alt-d": pcBaseKeymap["Mod-Delete"],
+  "Ctrl-a": selectTextblockStart,
+  "Ctrl-e": selectTextblockEnd
+};
+for (let key in pcBaseKeymap)
+  macBaseKeymap[key] = pcBaseKeymap[key];
+var mac = typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform) : typeof os != "undefined" && os.platform ? os.platform() == "darwin" : false;
+var baseKeymap = mac ? macBaseKeymap : pcBaseKeymap;
+
+export {
+  deleteSelection,
+  joinBackward,
+  joinTextblockBackward,
+  joinTextblockForward,
+  selectNodeBackward,
+  joinForward,
+  selectNodeForward,
+  joinUp,
+  joinDown,
+  lift,
+  newlineInCode,
+  exitCode,
+  createParagraphNear,
+  liftEmptyBlock,
+  splitBlockAs,
+  splitBlock,
+  splitBlockKeepMarks,
+  selectParentNode,
+  selectAll,
+  selectTextblockStart,
+  selectTextblockEnd,
+  wrapIn,
+  setBlockType,
+  toggleMark,
+  autoJoin,
+  chainCommands,
+  pcBaseKeymap,
+  macBaseKeymap,
+  baseKeymap
+};