createLinkItem(url, title) {
   if (this.markActive(this.view.editor.state, this.outputSchema.marks.link)) {
     // can't see how to edit mark, only toggle. So toggle off to toggle back on with new attrs
     toggleMark(this.outputSchema.marks.link)(this.view.editor.state, this.view.props.dispatchTransaction);
   }
   toggleMark(this.outputSchema.marks.link, {
     href: url,
     title
   })(this.view.editor.state, this.view.props.dispatchTransaction);
 }

 return (state, dispatch) => {
     const { subsup } = state.schema.marks
     if (subsup) {
         if (isMarkActive(state, subsup.create({ type: "sup" }))) {
             return toggleMark(subsup)(state, dispatch)
         }
         return toggleMark(subsup, { type: "sub" })(state, dispatch)
     }
     return false
 }

 return (state, dispatch) => {
     const { strong } = state.schema.marks
     if (strong) {
         return toggleMark(strong)(state, dispatch)
     }
     return false
 }

 return (state, dispatch) => {
     const { em } = state.schema.marks
     if (em) {
         return toggleMark(em)(state, dispatch)
     }
     return false
 }

 return (state, dispatch) => {
     const { underline } = state.schema.marks
     if (underline) {
         return toggleMark(underline)(state, dispatch)
     }
     return false
 }

 markItem(markType, options) {
   let passedOptions = {
     active: (state) => {
       return this.markActive(state, markType);
     }
   };
   for (let prop in options) {
     if (options.hasOwnProperty(prop)) {
       passedOptions[prop] = options[prop];
     }
   }
   return this.cmdItem(toggleMark(markType), passedOptions);
 }

 constructor() {
     this.tool = {
         tooltip: "Toggle Subscript",
         icon: "fa-subscript",
         run: toggleSubscript(),
         active(state) {
             const { subsup } = state.schema.marks
             if (subsup) {
                 return isMarkActive(state, subsup.create({ type: "sub" }))
             }
             return false
         },
         enable(state) {
             const { subsup } = state.schema.marks
             if (subsup) {
                 return toggleMark(subsup, { type: "sub" })(state)
             }
             return false
         },
     }
 }

export const getTextFormattingState = (editorState: EditorState): TextFormattingState => {
    const { em, code, strike, strong, subsup, underline } = editorState.schema.marks
    const state: TextFormattingState = {}

    if (code) {
        state.codeActive = isMarkActive(editorState, code.create())
        state.codeDisabled = !toggleMark(code)(editorState)
    }
    if (em) {
        state.emActive = isMarkTypeActive(editorState, em)
        state.emDisabled = state.codeActive ? true : !toggleMark(em)(editorState)
    }
    if (strike) {
        state.strikeActive = isMarkTypeActive(editorState, strike)
        state.strikeDisabled = state.codeActive ? true : !toggleMark(strike)(editorState)
    }
    if (strong) {
        state.strongActive = isMarkTypeActive(editorState, strong)
        state.strongDisabled = state.codeActive ? true : !toggleMark(strong)(editorState)
    }
    if (subsup) {
        const subMark = subsup.create({ type: "sub" })
        const supMark = subsup.create({ type: "sup" })
        state.subscriptActive = isMarkActive(editorState, subMark)
        state.subscriptDisabled = state.codeActive
            ? true
            : !toggleMark(subsup, { type: "sub" })(editorState)
        state.superscriptActive = isMarkActive(editorState, supMark)
        state.superscriptDisabled = state.codeActive
            ? true
            : !toggleMark(subsup, { type: "sup" })(editorState)
    }
    if (underline) {
        state.underlineActive = isMarkTypeActive(editorState, underline)
        state.underlineDisabled = state.codeActive ? true : !toggleMark(underline)(editorState)
    }
    return state
}

  buildKeymap(mapKeys = undefined) {
    const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
    let keys = {};
    function bind(key, cmd) {
      if (mapKeys) {
        let mapped = mapKeys[key];
        if (mapped === false) {
          return;
        }
        if (mapped) {
          key = mapped;
        }
      }
      keys[key] = cmd;
    }

    if (this.outputSchema.marks.strong) {
      bind('Mod-b', toggleMark(this.outputSchema.marks.strong));
    }
    if (this.outputSchema.marks.em) {
      bind('Mod-i', toggleMark(this.outputSchema.marks.em));
    }
    if (this.outputSchema.marks.code) {
      bind('Mod-`', toggleMark(this.outputSchema.marks.code));
    }
    if (this.outputSchema.nodes.bullet_list) {
      bind('Shift-Ctrl-8', wrapInList(this.outputSchema.nodes.bullet_list));
    }
    if (this.outputSchema.nodes.ordered_list) {
      bind('Shift-Ctrl-9', wrapInList(this.outputSchema.nodes.ordered_list));
    }
    if (this.outputSchema.nodes.blockquote) {
      bind('Ctrl->', wrapIn(this.outputSchema.nodes.blockquote));
    }
    if (this.outputSchema.nodes.hard_break) {
      let cmd = chainCommands(newlineInCode, (state, dispatchTransaction) => {
        dispatchTransaction(state.tr.replaceSelectionWith(this.outputSchema.nodes.hard_break.create()).scrollIntoView());
        return true;
      });
      bind('Mod-Enter', cmd);
      bind('Shift-Enter', cmd);
      if (mac) {
        bind('Ctrl-Enter', cmd);
      }
    }
    if (this.outputSchema.nodes.list_item) {
      bind('Enter', splitListItem(this.outputSchema.nodes.list_item));
      bind('Mod-[', liftListItem(this.outputSchema.nodes.list_item));
      bind('Mod-]', sinkListItem(this.outputSchema.nodes.list_item));
    }
    if (this.outputSchema.nodes.paragraph) {
      bind('Shift-Ctrl-0', setBlockType(this.outputSchema.nodes.paragraph));
    }
    if (this.outputSchema.nodes.code_block) {
      bind('Shift-Ctrl-\\', setBlockType(this.outputSchema.nodes.code_block));
    }
    if (this.outputSchema.nodes.heading) {
      for (let i = 1; i <= 6; i++) {
        bind('Shift-Ctrl-' + i, setBlockType(this.outputSchema.nodes.heading, {level: i}));
      }
    }
    if (this.outputSchema.nodes.horizontal_rule) {
      bind('Mod-_', (state, dispatchTransaction) => {
        dispatchTransaction(state.tr.replaceSelectionWith(this.outputSchema.nodes.horizontal_rule.create()).scrollIntoView());
        return true;
      });
    }

    return keys;
  }