How to use the slate.Mark.create function in slate

function handleMarkedText(node: Text, content) {
  const isBdo = (m: Mark) => m.type === 'bdo';
  const isForeign = (m: Mark) => m.type === 'foreign';

  // const marks = node.marks.toArray().map(m => m.type);
  const marks = node.marks.toArray();

  // if bdo is present, it must be the first element that
  // we place in the OLI JSON.  This is a DTD constraint.
  const adjustedMarks = marks.some(isBdo)
    ? [Mark.create({ type: 'bdo' }), ...marks.filter(m => !isBdo(m))]
    : marks;

  const root = { root: {} };
  let last = root;

  adjustedMarks.forEach((mark) => {
    // For each style, create the object representation for that style
    if (mark === undefined) {
      return;
    }

    const type = mark.type;
    const container = styleContainers[type];
    let style;
    if (container === undefined) {
      style = Object.assign({}, styleContainers.em());

key: currentTextNode.key,
      path: currentTextNode.path,
      offset: isBackwards ? other.length + 1 : offset
    })
    const range = Range.create({
      anchor,
      focus
    })

    return editor
      .deleteAtRange(range)
      .insertTextByKey(
        currentTextNode.key,
        isBackwards ? offset : other.length,
        inlineCode,
        [Mark.create({ type })]
      )
      .command(editor =>
        editor.value.marks.forEach(mark => {
          editor.removeMark(mark)
        })
      )
  }

  next()
}

) {
  const matchedLength = matched[0].length;
  const reg = matched[1] === "*" ? /\*/ : matched[1];
  const addText = matched[0].replace(new RegExp(reg, "g"), "");

  return change
    .deleteAtRange(
      Range.create({
        anchorKey: currentTextNode.key,
        focusKey: currentTextNode.key,
        anchorOffset: matched.index,
        focusOffset: matched.index + matchedLength
      })
    )
    .insertTextByKey(currentTextNode.key, matched.index, addText, [
      Mark.create({ type: "ITALIC" })
    ])
    .call(trailingSpace, currentTextNode, matched.index)
    .call(removeAllMark);
}

return new Set(tags.map(tag => {
    return Mark.create({type: tag, data: {}})
  }))
}

export default (type, currentTextNode, matched, change) => {
  const matchedLength = matched[0].length;
  const reg = matched[1] === "***" ? /\*\*\*/ : matched[1];
  const addText = matched[0].trim().replace(new RegExp(reg, "g"), "");

  return change
    .deleteAtRange(
      Range.create({
        anchorKey: currentTextNode.key,
        focusKey: currentTextNode.key,
        anchorOffset: matched.index,
        focusOffset: matched.index + matchedLength,
      }),
    )
    .insertTextByKey(currentTextNode.key, matched.index, addText, [
      Mark.create({ type: "bold" }),
      Mark.create({ type: "italic" }),
    ])
    .call(trailingSpace, currentTextNode, matched.index)
    .call(removeAllMark);
};

export default (type, currentTextNode, matched, change) => {
  const matchedLength = matched[0].length;
  const reg = matched[1] === "*" ? /\*/ : matched[1];
  const addText = matched[0].replace(new RegExp(reg, "g"), "");

  return change
    .deleteAtRange(
      Range.create({
        anchorKey: currentTextNode.key,
        focusKey: currentTextNode.key,
        anchorOffset: matched.index,
        focusOffset: matched.index + matchedLength,
      }),
    )
    .insertTextByKey(currentTextNode.key, matched.index, addText, [
      Mark.create({ type }),
    ])
    .call(trailingSpace, currentTextNode, matched.index)
    .call(removeAllMark);
};

function onPaste(event, change, editor) {
  const html = event.clipboardData.getData('text/html');
  const plain = event.clipboardData.getData('text/plain');
  const regex = RegExpUtils.urlRegex({ matchStartOfString: true, matchTailOfString: true });
  if (!html && plain && plain.match(regex)) {
    const mark = Mark.create({ type: LINK_TYPE, data: { href: plain } });
    change
      .addMark(mark)
      .insertText(plain)
      .removeMark(mark);
    return true;
  }
}

transform: (transform, e, matches) => {
      const text = matches.before[2];
      const mark = Mark.create({ type: MARK_CONFIG.bold.type });
      const marks = Mark.createSet([mark]);
      transform.insertText(text, marks).removeMark(mark.type);
    },
  }),