selectAroundMark(markType: MarkType, doc: Node, pos: number, dispatchTransaction): Mark {
    let $pos = doc.resolve(pos),
      parent = $pos.parent;

    let start = parent.childAfter($pos.parentOffset);
    if (!start.node || start.node.marks.length === 0) {
      // happens if the cursor is at the end of the line or the end of the node, use nodeAt pos - 1 to find node marks
      start.node = parent.nodeAt($pos.parentOffset - 1);
      if (!start.node) {
        return null;
      }
    }

    let targetMark = start.node.marks.find(mark => mark.type.name === markType.name);
    if (!targetMark) {
      return null;
    }

    let startIndex = $pos.index(),
      startPos = $pos.start() + start.offset;
    while (startIndex > 0 && targetMark.isInSet(parent.child(startIndex - 1).marks)) {
      startPos -= parent.child(--startIndex).nodeSize;
    }
    let endIndex = $pos.indexAfter(),
      endPos = startPos + start.node.nodeSize;
    while (endPos < parent.childCount && targetMark.isInSet(parent.child(endIndex).marks)) {
      endPos += parent.child(endIndex++).nodeSize;
    }

    let selection = Selection.between(doc.resolve(startPos), doc.resolve(endPos));
    dispatchTransaction(this.view.editor.state.tr.setSelection(selection));

    return targetMark;
  }

export function createState(schema: Schema, nodeOrJson: Node | any, plugins?: Plugin[]) {
    return EditorState.create({
        schema,
        doc: nodeOrJson instanceof Node ? nodeOrJson : Node.fromJSON(schema, nodeOrJson.doc),
        plugins,
    })
}

 const getContent = (node: Node) => {
   if (node.type.name === 'text') {
     if (translatedContent.length > 0 && node.textContent.length > 0
       && !node.textContent.match(/^\s+/)
       && !translatedContent.match(/^.+\s$/)) {
       translatedContent += ' ';
     }
     let linkMark: Mark;
     node.marks.forEach(mark => {
       if (markdownSchema.marks.link.isInSet([mark])) {
         linkMark = mark;
       }
     });
     if (linkMark) {
       translatedContent += `[${node.textContent}](${linkMark.attrs.href}`;
       if (node.marks[0].attrs.title) {
         translatedContent += ` "${linkMark.attrs.title}")`;
       } else {
         translatedContent += ')';
       }
     } else {
       translatedContent += node.textContent;
     }
   }
   // traverse the node tree and pull out the textContent and links via markdown input schema
   node.forEach((child, offset, index) => getContent(child));
 };

domOutputSpec = ['div', ['div', { class: 'foo' }, 0]];

export const nodeSpec: model.NodeSpec = {
    attrs: {
        name: { default: '' }
    },
    parseDOM: [
        {
            tag: 'span[data-name]',
            getAttrs(dom) {
                if (dom instanceof HTMLElement) {
                    return {
                        name: dom.getAttribute('data-name')!
                    };
                }
            }
        }
    ],
    toDOM(node) {
        const { name } = node.attrs;
        const attrs = {
            'data-emoji-name': name
        };
        return ['span', attrs, 0];
    }
};

const node = new model.Node();
node.nodesBetween(0, 1, () => {});
node.descendants(() => {});

                }
            }
        }
    ],
    toDOM(node) {
        const { name } = node.attrs;
        const attrs = {
            'data-emoji-name': name
        };
        return ['span', attrs, 0];
    }
};

// Verify that non-null assertion operator can be used.

const res1_1 = new model.Node();
res1_1.nodesBetween(0, 1, () => {});
res1_1.nodesBetween(0, 1, () => null);
res1_1.nodesBetween(0, 1, () => undefined);
res1_1.nodesBetween(0, 1, () => true);
res1_1.descendants(() => {});
res1_1.descendants(() => null);
res1_1.descendants(() => undefined);
res1_1.descendants(() => true);
const res1_2: model.Node = res1_1.maybeChild(0)!;
const res1_3: model.Node = res1_1.nodeAt(0)!;

const cm1 = new model.ContentMatch();
const cm2: model.ContentMatch = cm1.matchType({} as any)!;
const cm3: model.ContentMatch = cm1.matchFragment({} as any)!;
const cm4: model.Fragment = cm1.fillBefore({} as any)!;