edytor 0.0.5 → 0.0.6

package/dist/edytor.cjs.development.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
-var Y = require('yjs');
+var yjs = require('yjs');
 var nanoid$1 = require('nanoid');
 var isHotkey = _interopDefault(require('is-hotkey'));
 var yWebsocket = require('y-websocket');
@@ -60,17 +60,17 @@ function _objectWithoutPropertiesLoose(source, excluded) {
 
 var _excluded = ["id", "text", "data"];
 var createLeaf$1 = function createLeaf(props) {
-  var leaf = new Y.Map();
+  var leaf = new yjs.Map();
   leaf.set("id", (props == null ? void 0 : props.id) || nanoid());
-  leaf.set("text", new Y.Text((props == null ? void 0 : props.text) || ""));
+  leaf.set("text", new yjs.Text((props == null ? void 0 : props.text) || ""));
 
   if (props) {
     var text = props.text,
         data = props.data,
         marks = _objectWithoutPropertiesLoose(props, _excluded);
 
-    leaf.set("text", new Y.Text(text || ""));
-    data && leaf.set("data", new Y.Map(Object.entries(data)));
+    leaf.set("text", new yjs.Text(text || ""));
+    data && leaf.set("data", new yjs.Map(Object.entries(data)));
     marks && Object.keys(marks).forEach(function (mark) {
       leaf.set(mark, marks[mark]);
     });
@@ -80,16 +80,16 @@ var createLeaf$1 = function createLeaf(props) {
 };
 
 var createNode = function createNode(type, props) {
-  var node = new Y.Map();
+  var node = new yjs.Map();
   node.set("id", (props == null ? void 0 : props.id) || nanoid());
   node.set("type", type);
 
   if (props != null && props.data) {
-    node.set("data", new Y.Map(Object.entries(props.data)));
+    node.set("data", new yjs.Map(Object.entries(props.data)));
   }
 
-  node.set("content", (props == null ? void 0 : props.content) instanceof Y.Array ? props.content : Y.Array.from((props == null ? void 0 : props.content) || [createLeaf$1()]));
-  node.set("children", (props == null ? void 0 : props.children) instanceof Y.Array ? props.children : Y.Array.from((props == null ? void 0 : props.children) || []));
+  node.set("content", (props == null ? void 0 : props.content) instanceof yjs.Array ? props.content : yjs.Array.from((props == null ? void 0 : props.content) || [createLeaf$1()]));
+  node.set("children", (props == null ? void 0 : props.children) instanceof yjs.Array ? props.children : yjs.Array.from((props == null ? void 0 : props.children) || []));
   return node;
 };
 var YNode = /*#__PURE__*/function (_Map) {
@@ -100,12 +100,9 @@ var YNode = /*#__PURE__*/function (_Map) {
   }
 
   return YNode;
-}(Y.Map);
+}(yjs.Map);
 
 var _excluded$1 = ["type", "content", "children"];
-var getContent = function getContent(leaf) {
-  return createLeaf$1(leaf);
-};
 var getChildren = function getChildren(_ref) {
   var type = _ref.type,
       _ref$content = _ref.content,
@@ -116,27 +113,22 @@ var getChildren = function getChildren(_ref) {
 
   return createNode(type, _extends({}, props, {
     children: children.map(getChildren),
-    content: content.map(getContent)
+    content: content.map(createLeaf$1)
   }));
 };
 var EdytorDoc = /*#__PURE__*/function (_Doc) {
   _inheritsLoose(EdytorDoc, _Doc);
 
-  function EdytorDoc(value) {
-    var _this;
-
-    _this = _Doc.call(this) || this;
-
-    return _this;
+  function EdytorDoc() {
+    return _Doc.apply(this, arguments) || this;
   }
 
   return EdytorDoc;
-}(Y.Doc);
-var DocFromJson = function DocFromJson(value) {
-  var doc = new Y.Doc();
-  var array = doc.getArray("children");
+}(yjs.Doc);
+var DocFromJson = function DocFromJson(value, initialDoc) {
+  var array = (initialDoc || new yjs.Doc()).getArray("children");
   array.insert(0, value.map(getChildren));
-  return doc;
+  return array.doc;
 };
 
 var deleteText = function deleteText(editor, _ref) {
@@ -155,21 +147,28 @@ var deleteText = function deleteText(editor, _ref) {
     case "collapsed":
       {
         if (mode === "backward" && edges.startNode) {
-          console.log(start.nodeIndex, leafNodeChildrenLength(start.leaf), start.path.length); // unnest node if its the last of its parent and if he is nested
+          if (edges.startDocument) return; // unnest node if its the last of its parent and if he is nested or it's the first its the only child of its parent
 
-          if (start.nodeIndex === start.node.parent.length - 1 && start.path.length > 1 && start.nodeIndex !== 0) {
-            console.log(start.leafId);
+          if (start.nodeIndex === start.node.parent.length - 1 && start.path.length > 2 && (start.nodeIndex !== 0 || start.node.parent.length === 1)) {
             var node = copyNode(start.node);
+            var nodeGrandParent = start.node.parent.parent;
+            var index = getIndex(nodeGrandParent);
             start.node.parent["delete"](start.nodeIndex);
-            start.node.parent.parent.parent.insert(getIndex(start.node.parent.parent) + 1, [node]);
-            setPosition(start.leafId, {
+            nodeGrandParent.parent.insert(index + 1, [node]);
+            return setPosition(start.leafId, {
               offset: 0
             });
           } else {
-            // merge node with the prev one if it's not the last of its parent regardless of its nesting
-            mergeContentWithPrevLeaf(editor);
-            return setPosition(start.leafId, {
-              offset: 0
+            return editor.doc.transact(function () {
+              var _mergeContentWithPrev = mergeContentWithPrevLeaf(editor),
+                  prevLeaf = _mergeContentWithPrev[0],
+                  offset = _mergeContentWithPrev[1];
+
+              setTimeout(function () {
+                setPosition(prevLeaf.get("id"), {
+                  offset: offset
+                });
+              });
             });
           }
         }
@@ -185,14 +184,22 @@ var deleteText = function deleteText(editor, _ref) {
 
         if (mode === "forward" && edges.endNode) {
           // merge node with the next node because we are at edge end of it
-          return mergeContentWithNextLeaf(editor);
+          return editor.doc.transact(function () {
+            mergeContentWithNextLeaf(editor);
+            setTimeout(function () {
+              setPosition(start.leafId, {
+                offset: start.offset
+              });
+            });
+          });
         }
 
         if (mode === "forward" && edges.endLeaf) {
           // delete content in the next leaf because we are at its edge end
           var nextLeaf = leafNodeContent(start.leaf).get(start.leafIndex + 1);
           return deleteLeafText(nextLeaf, 0, length || 1);
-        }
+        } // just delete text
+
 
         deleteLeafText(start.leaf, start.offset + (mode === "backward" ? -length || -1 : length), length || 1);
         setPosition(start.leaf.get("id"), {
@@ -205,11 +212,11 @@ var deleteText = function deleteText(editor, _ref) {
       {
         deleteLeafText(start.leaf, start.offset, length, true);
 
-        if (hasChildren(getNode(start.leaf))) {
+        if (isNodeContentEmpty(start.node)) {
           leafNodeContent(start.leaf).insert(0, [createLeaf$1()]);
         }
 
-        setPosition(start.leaf.get("id"), {
+        setPosition(start.leafId, {
           offset: start.offset
         });
         break;
@@ -257,7 +264,7 @@ var deleteText = function deleteText(editor, _ref) {
 
 var applyMarksFromParent = function applyMarksFromParent(parent, leafs) {
   Array.from(parent.keys(), function (key) {
-    if (key !== "text") {
+    if (key !== "text" && key !== "id" && key !== "data") {
       leafs.forEach(function (leaf) {
         leaf.set(key, parent.get(key));
       });
@@ -329,74 +336,76 @@ var formatText = function formatText(editor, mark) {
     switch (type) {
       case "collapsed":
         {
-          var isMarkActive = start.leaf.has(format);
+          var isMarkActive = start.leaf.has(format) && start.leaf.get(format) === value;
 
-          if (isMarkActive && isLeafEmpty(start.leaf)) {
-            start.leaf["delete"](format);
-            newPath = leafNodeContent(start.leaf).toArray().indexOf(start.leaf);
+          if (isLeafEmpty(start.leaf)) {
+            // if the leaf is empty we only toggle the mark
+            isMarkActive ? start.leaf["delete"](format) : start.leaf.set(format, value);
           } else {
+            var _createLeaf;
+
+            // if leaf is not empty we split the current leaf in half to insert an empty fragment with the desired mark
+            splitLeaf(editor);
+            var fragment = createLeaf$1((_createLeaf = {
+              text: ""
+            }, _createLeaf[format] = value, _createLeaf)); // we are applying the current marks on the fragment
+
+            applyMarksFromParent(start.leaf, [fragment]); // we remove the mark if its here
+
+            if (isMarkActive) fragment["delete"](format); // we insert the fragment after the spitted leaf
+
+            leafNodeContent(start.leaf).insert(start.leafIndex + 1, [fragment]); // we remove the spitted leaf if empty
+
             if (isLeafEmpty(start.leaf)) {
-              isMarkActive ? start.leaf["delete"](format) : start.leaf.set(format, value);
-            } else {
-              var _createLeaf;
+              leafNodeContent(start.leaf)["delete"](start.leafIndex);
+            }
 
-              splitLeaf(editor, {
-                yText: start.leaf.get("text"),
-                at: start
+            setTimeout(function () {
+              setPosition(fragment.get("id"), {
+                offset: 0
               });
-              var newChild = createLeaf$1((_createLeaf = {
-                text: ""
-              }, _createLeaf[format] = value, _createLeaf));
-              applyMarksFromParent(start.leaf, [newChild]);
-              if (isMarkActive) newChild["delete"](format);
-              leafNodeContent(start.leaf).insert(start.path.slice().reverse()[0] + 1, [newChild]);
-
-              if (isLeafEmpty(start.leaf)) {
-                leafNodeContent(start.leaf)["delete"](start.path.slice().reverse()[0]);
-              }
+              console.log(leafNodeContent(start.leaf).toJSON());
+            });
+          } // we merge leaves to avoid two subsequent leaves with the same marks
 
-              newPath = leafNodeContent(start.leaf).toArray().indexOf(newChild);
-            }
-          }
 
           mergeLeafs(leafNodeContent(start.leaf));
-          break; // return newPath;
+          break;
         }
 
       case "singlenode":
         {
-          editor.doc.transact(function () {
-            var formatedLeaf = formatAtEqualPath({
-              format: format,
-              value: value,
-              start: start,
-              end: end,
-              length: length
-            });
-            mergeLeafs(leafNodeContent(start.leaf));
-            var isRemoved = formatedLeaf._item.deleted;
+          var formatedLeaf = formatAtEqualPath({
+            format: format,
+            value: value,
+            start: start,
+            end: end,
+            length: length
+          });
+          mergeLeafs(leafNodeContent(start.leaf));
+          var isRemoved = formatedLeaf._item.deleted;
 
-            if (!isRemoved) {
-              setPosition(start.leaf.get("id"), {
-                offset: start.offset
-              });
-              setTimeout(function () {
-                setPosition(formatedLeaf.get("id"), {
-                  offset: 0,
-                  end: leafLength(formatedLeaf)
-                });
+          if (!isRemoved) {
+            setPosition(start.leaf.get("id"), {
+              offset: start.offset
+            });
+            setTimeout(function () {
+              setPosition(formatedLeaf.get("id"), {
+                offset: 0,
+                end: leafLength(formatedLeaf)
               });
-            } else {
-              var remainingLeaf = formatedLeaf.parent.get(start.leafIndex - 1);
-              var offset = leafText(remainingLeaf).toJSON().indexOf(selectedText);
-              setTimeout(function () {
-                setPosition(remainingLeaf.get("id"), {
-                  offset: offset,
-                  end: offset + selectedText.length
-                });
+            });
+          } else {
+            var remainingLeaf = formatedLeaf.parent.get(start.leafIndex - 1);
+            var offset = leafText(remainingLeaf).toJSON().indexOf(selectedText);
+            setTimeout(function () {
+              setPosition(remainingLeaf.get("id"), {
+                offset: offset,
+                end: offset + selectedText.length
               });
-            }
-          });
+            });
+          }
+
           break;
         }
 
@@ -577,21 +586,19 @@ var removeEmptyText = function removeEmptyText(yText) {
   }
 };
 
-var splitLeaf = function splitLeaf(editor, _ref) {
-  var _yText$parent;
-
-  var yText = _ref.yText,
-      at = _ref.at;
-  var content = yText.toString();
-  var rightText = content.substring(at.offset, yText.length);
-  if (at.offset === yText.length) return;
-  var newText = new Y.Text(rightText);
-  var newLeave = new Y.Map();
-  newLeave.set("text", newText);
-  applyMarksFromParent(yText.parent, [newLeave]);
-  var parent = yText == null ? void 0 : (_yText$parent = yText.parent) == null ? void 0 : _yText$parent.parent;
-  yText["delete"](at.offset, yText.length);
-  parent.insert(at.path.slice().reverse()[0] + 1, [newLeave]);
+var splitLeaf = function splitLeaf(editor) {
+  var _editor$selection$sta = editor.selection.start,
+      leaf = _editor$selection$sta.leaf,
+      leafIndex = _editor$selection$sta.leafIndex,
+      offset = _editor$selection$sta.offset;
+  var content = leafString(leaf);
+  var rightText = content.substring(offset, content.length);
+  if (offset === content.length) return;
+  deleteLeafText(leaf, offset, rightText.length);
+  leafNodeContent(leaf).insert(leafIndex + 1, [createLeaf$1(_extends({}, leaf.toJSON(), {
+    text: rightText,
+    id: undefined
+  }))]);
 };
 
 var splitNode = function splitNode(editor) {
@@ -623,17 +630,16 @@ var splitNode = function splitNode(editor) {
         return createLeaf$1(leaf.toJSON());
       }))
     })]);
+    setPosition(newLeaf.get("id"), {
+      offset: 0
+    });
     leafContent["delete"](indexOfLeaf + 1, leafNodeContentLength(start.leaf) - indexOfLeaf - 1);
-    setTimeout(function () {
-      setPosition(newLeaf.get("id"), {
-        offset: 0
-      });
-    }, 10);
   };
 
   var doSplit = (!edges.startNode || !edges.endNode) && type !== "multinodes";
 
   if ((edges.endNode || edges.startNode) && type === "collapsed") {
+    // if cursor is at edge node with insert a default block before of after the current node
     var newNode = createNode(editor.defaultBlock);
     node.parent.insert(indexOfNode + (edges.endNode ? 1 : 0), [newNode]);
     return setTimeout(function () {
@@ -683,7 +689,7 @@ var nestNode = function nestNode(editor) {
       end = _editor$selection.end,
       setPosition = _editor$selection.setPosition;
   var startNode = getNode(start.leaf);
-  var startJsonNode = startNode.toJSON();
+  var nodeCopy = copyNode(startNode);
   var startPath = getPath(startNode);
 
   var _startPath$slice$reve = startPath.slice().reverse(),
@@ -701,10 +707,7 @@ var nestNode = function nestNode(editor) {
         var id = start.leaf.get("id");
         var prevChildren = prevNode.get("children");
         startContainer["delete"](index);
-        prevChildren.insert(prevChildren.length, [createNode(startJsonNode.type, _extends({}, startJsonNode, {
-          children: startJsonNode.children.map(getChildren),
-          content: startJsonNode.content.map(getContent)
-        }))]);
+        prevChildren.insert(prevChildren.length, [nodeCopy]);
         setPosition(id, {
           offset: start.offset
         });
@@ -728,11 +731,7 @@ var nestNode = function nestNode(editor) {
             if (path.length === startPath.length) {
               if (path <= endPathString && path >= startPathString) {
                 length++;
-                var jsonNode = node.toJSON();
-                newNodes.push(createNode(jsonNode.type, _extends({}, jsonNode, {
-                  children: jsonNode.children.map(getChildren),
-                  content: jsonNode.content.map(getContent)
-                })));
+                newNodes.push(copyNode(node));
               }
             }
           }
@@ -786,17 +785,26 @@ var mergeContentWithPrevLeaf = function mergeContentWithPrevLeaf(editor) {
     }
   });
   if (!prevLeaf) return;
+  var prevLeafLength = leafLength(prevLeaf);
   leafNodeContent(prevLeaf).insert(leafNodeContentLength(prevLeaf), leafNodeContent(start.leaf).toArray().map(function (leaf) {
     return createLeaf$1(leaf.toJSON());
   }));
   mergeLeafs(leafNodeContent(prevLeaf));
-  start.leaf.parent.parent["delete"](getIndex(getNode(start.leaf)));
+  var children = start.node.get("children").toArray().map(copyNode);
+
+  if (children.length) {
+    start.node.parent.insert(start.nodeIndex, children);
+  }
+
+  start.node.parent["delete"](start.nodeIndex + children.length);
+  return [prevLeaf, prevLeafLength]; // (start.leaf.parent.parent as YArray<YNode>).delete(index);
 };
 var mergeContentWithNextLeaf = function mergeContentWithNextLeaf(editor) {
-  var start = editor.selection.start;
+  var start = editor.selection.start; // 1 .get the next leaf
+
   var nextLeaf;
   var stop = false;
-  editor.doc.traverse(function (node, isText) {
+  traverse(editor, function (node, isText) {
     if (isText) {
       if (node === start.leaf) {
         stop = true;
@@ -805,24 +813,21 @@ var mergeContentWithNextLeaf = function mergeContentWithNextLeaf(editor) {
         stop = false;
       }
     }
-  }); //TODO the children should be pull to the depth level of the removed parent
+  }); // end of document do nothing
+
+  if (!nextLeaf) return; // 2 .merge the next leaf with the start leaf
 
-  console.log(leafNodeContent(nextLeaf).toArray());
   leafNodeContent(start.leaf).insert(leafNodeContentLength(start.leaf), leafNodeContent(nextLeaf).toArray().map(function (leaf) {
     return createLeaf$1(leaf.toJSON());
   }));
-  mergeLeafs(leafNodeContent(start.leaf));
-  console.log(start.leaf.parent.toJSON());
-  var node = getNode(nextLeaf);
+  mergeLeafs(leafNodeContent(start.leaf)); // 3 get the merged node children if any and place it where the merged node was
 
-  if (hasChildren(node)) {
-    console.log(node.get("children").toJSON());
-    node.parent.insert(getIndex(node), node.get("children").toJSON().map(function (node) {
-      return createNode(node.type, node);
-    }));
-  }
-
-  node.parent["delete"](getIndex(node));
+  var node = getNode(nextLeaf);
+  var index = getIndex(node);
+  var parent = node.parent;
+  var children = node.get("children").toArray();
+  children.length > 0 && parent.insert(index, children.map(copyNode));
+  parent["delete"](index + children.length);
   return nextLeaf;
 };
 var deleteNode = function deleteNode(node, defaultBlock) {
@@ -868,9 +873,19 @@ var copyNode = function copyNode(node) {
   var jsonNode = node.toJSON();
   return createNode(jsonNode.type, _extends({}, jsonNode, {
     children: jsonNode.children.map(getChildren),
-    content: jsonNode.content.map(getContent)
+    content: jsonNode.content.map(createLeaf$1)
   }));
 };
+var nodeString = function nodeString(node) {
+  var text = "";
+  getNodeContent(node).forEach(function (leaf) {
+    text += leafString(leaf);
+  });
+  getNodeChildren(node).forEach(function (node) {
+    text += nodeString(node);
+  });
+  return text;
+};
 
 var nanoid = function nanoid() {
   return "y-" + nanoid$1.customAlphabet("346789ABCDEFGHJKLMNPQRTUV-WXYabcdefghijkmnpqrtwxyz", 20)();
@@ -985,7 +1000,7 @@ var toString = function toString(editor) {
   var array = editor.children.toArray();
 
   for (var i = 0; i < array.length; i++) {
-    t += leafString(array[i]);
+    t += nodeString(array[i]);
   }
 
   return t;
@@ -1073,6 +1088,7 @@ var setLeafData = function setLeafData(leaf, data) {
 };
 var removeIfEmpty = function removeIfEmpty(leaf) {
   if (isLeafEmpty(leaf)) {
+    console.log("isEmpty", leafNodeContent(leaf).toJSON());
     leafNodeContent(leaf)["delete"](getIndex(leaf)); // if (leafNodeContentLength(leaf) === 0) {
     //   deleteNode(leafNode(leaf));
     // }
@@ -1118,6 +1134,7 @@ var Dropper = function Dropper() {
   this.startDrag = function (node, e) {
     var _e$dataTransfer;
 
+    if (!_this.editor.dnd.active) return;
     _this.node = node;
     var dndIndicator = document.getElementById("dndIndicator");
     dndIndicator.style.opacity = "1";
@@ -1180,6 +1197,8 @@ var Dropper = function Dropper() {
   };
 
   this.onDrag = function (e) {
+    if (!_this.editor.dnd.active) return;
+
     var _this$getHoveredNode = _this.getHoveredNode(e.target),
         hoveredElement = _this$getHoveredNode.hoveredElement,
         hoveredNode = _this$getHoveredNode.hoveredNode;
@@ -1344,11 +1363,15 @@ var EdytorSelection = function EdytorSelection() {
     _this.length = _this.selectedText.length;
     _this.range = range;
     _this.selection = selection;
+    var startNode = _this.start.offset === 0 && getIndex(_this.start.leaf) === 0;
+    var endNode = _this.end.offset === leafLength(_this.end.leaf) && getIndex(_this.start.leaf) === leafNodeContentLength(_this.end.leaf) - 1;
     _this.edges = {
       startLeaf: _this.start.offset === 0,
-      startNode: _this.start.offset === 0 && getIndex(_this.start.leaf) === 0,
       endLeaf: _this.end.offset === leafLength(_this.end.leaf),
-      endNode: _this.end.offset === leafLength(_this.end.leaf) && getIndex(_this.start.leaf) === leafNodeContentLength(_this.end.leaf) - 1
+      startNode: startNode,
+      endNode: endNode,
+      startDocument: startNode && _this.start.path.join("") === "00",
+      endDocument: false
     };
     _this.type = isCollapsed ? "collapsed" : equalPaths ? "singlenode" : _this.start.node === _this.end.node ? "multileaves" : "multinodes";
 
@@ -1358,7 +1381,16 @@ var EdytorSelection = function EdytorSelection() {
   this.onChange = function () {
     _this.observers.forEach(function (o) {
       return o(_this);
-    });
+    }); // console.log(this.editor.awareness);
+    // if (this.collaborationPosition?.node !== this.start.node.get("id")) {
+    //   this.collaborationPosition = {
+    //     node: this.start.node.get("id"),
+    //     leaf: this.start.leaf.get("id"),
+    //     offset: this.start.offset
+    //   };
+    //   this.editor.awareness.setLocalStateField("position", this.collaborationPosition);
+    // }
+
   };
 
   this.setPosition = function (id, _ref) {
@@ -1370,6 +1402,10 @@ var EdytorSelection = function EdytorSelection() {
 
     var node = _this.container.querySelector("#" + id);
 
+    console.log({
+      node: node
+    });
+
     while (node && node.nodeType !== 3 && (_node = node) != null && _node.firstChild) {
       var _node;
 
@@ -1413,14 +1449,21 @@ var getDataTransfer = function getDataTransfer(e) {
 };
 
 var onBeforeInput = function onBeforeInput(_ref, e) {
-  var doc = _ref[0],
-      onChange = _ref[1],
-      editor = _ref[2];
-  prevent(e); // console.log(e);
+  var _e$target;
 
+  var onChange = _ref[1],
+      editor = _ref[2];
+  // console.log(e);
   var _editor$selection = editor.selection,
       start = _editor$selection.start,
-      length = _editor$selection.length;
+      length = _editor$selection.length,
+      setPosition = _editor$selection.setPosition; // if (e.composedPath().some((el) => el.getAttribute && el.getAttribute("data-edytor-void") === "true")) {
+  //   return;
+  // }
+
+  var tag = (_e$target = e.target) == null ? void 0 : _e$target.tagName;
+  if (tag === "TEXTAREA" || tag === "INPUT") return;
+  prevent(e);
 
   switch (e.inputType) {
     case "insertFromPaste":
@@ -1517,8 +1560,9 @@ var onBeforeInput = function onBeforeInput(_ref, e) {
 
     case "insertReplacementText":
       {
-        doc().doc.transact(function () {
-          replaceLeafText(start.leaf, start.offset, length, getDataTransfer(e));
+        replaceLeafText(start.leaf, start.offset, length, getDataTransfer(e));
+        setPosition(start.leafId, {
+          offset: start.offset
         });
       }
   }
@@ -1543,32 +1587,71 @@ var onKeyDown = function onKeyDown(editor, e) {
       return editor.undoManager.redo();
     }
 
-    for (var i = 0; i < editor.hotkeys.length; i++) {
-      var _editor$hotkeys$i = editor.hotkeys[i],
-          keys = _editor$hotkeys$i.keys,
-          operation = _editor$hotkeys$i.operation,
-          mark = _editor$hotkeys$i.mark;
+    if (editor.hotkeys) {
+      for (var i = 0; i < editor.hotkeys.length; i++) {
+        var _editor$hotkeys$i = editor.hotkeys[i],
+            keys = _editor$hotkeys$i.keys,
+            operation = _editor$hotkeys$i.operation,
+            mark = _editor$hotkeys$i.mark;
 
-      if (isHotkey(keys, e)) {
-        e.preventDefault();
-        e.stopPropagation();
+        if (isHotkey(keys, e)) {
+          e.preventDefault();
+          e.stopPropagation();
 
-        if (typeof operation === "function") {
-          return operation(editor);
-        }
+          if (typeof operation === "function") {
+            return operation(editor);
+          }
 
-        switch (operation) {
-          case "formatText":
-            {
-              return formatText(editor, mark);
-            }
-        }
+          switch (operation) {
+            case "formatText":
+              {
+                return formatText(editor, mark);
+              }
+          }
 
-        break;
+          break;
+        }
       }
     }
   }
 };
+var defaultHotkeys = [{
+  operation: "formatText",
+  keys: "mod+b",
+  mark: {
+    bold: true
+  }
+}, {
+  operation: "formatText",
+  keys: "mod+i",
+  mark: {
+    italic: true
+  }
+}, {
+  operation: "formatText",
+  keys: "mod+u",
+  mark: {
+    underline: true
+  }
+}, {
+  operation: "formatText",
+  keys: "mod+shift+c",
+  mark: {
+    code: true
+  }
+}, {
+  operation: "formatText",
+  keys: "mod+shift+x",
+  mark: {
+    strikethrough: true
+  }
+}, {
+  operation: "formatText",
+  keys: "mod+shift+h",
+  mark: {
+    highlight: true
+  }
+}];
 
 var onDrop = function onDrop(editor, e) {
   var _e$dataTransfer;
@@ -1593,15 +1676,12 @@ var onDragOver = function onDragOver(editor, e) {
   }
 };
 
-var createWebRtcProvider = function createWebRtcProvider(doc, room, opts) {// const fakeDoc = new Doc();
-};
-
 var createWSProvider = function createWSProvider(room) {
   return new Promise(function (res) {
-    var doc = new Y.Doc();
-    var dev = "ws://localhost:1234";
+    var doc = new yjs.Doc();
+    var prod = "wss://edytor-production.up.railway.app";
     console.log("development");
-    var provider = new yWebsocket.WebsocketProvider( dev, room || "edytor", doc, {
+    var provider = new yWebsocket.WebsocketProvider( prod, room || "edytor", doc, {
       connect: true
     });
     provider.on("status", function (_ref) {
@@ -1626,7 +1706,7 @@ exports.copyNode = copyNode;
 exports.createLeaf = createLeaf$1;
 exports.createNode = createNode;
 exports.createWSProvider = createWSProvider;
-exports.createWebRtcProvider = createWebRtcProvider;
+exports.defaultHotkeys = defaultHotkeys;
 exports.deleteLeafText = deleteLeafText;
 exports.deleteNode = deleteNode;
 exports.deleteText = deleteText;
@@ -1634,7 +1714,6 @@ exports.formatAtEqualPath = formatAtEqualPath;
 exports.formatText = formatText;
 exports.getChildren = getChildren;
 exports.getContainerAtPath = getContainerAtPath;
-exports.getContent = getContent;
 exports.getId = getId;
 exports.getIndex = getIndex;
 exports.getLeafAtPath = getLeafAtPath;
@@ -1667,6 +1746,7 @@ exports.mergeLeafs = mergeLeafs;
 exports.moveNode = moveNode;
 exports.nanoid = nanoid;
 exports.nestNode = nestNode;
+exports.nodeString = nodeString;
 exports.onBeforeInput = onBeforeInput;
 exports.onDragOver = onDragOver;
 exports.onDrop = onDrop;