code: def break_around(self, hinge):
          
          hinge_start = hinge[0]
          for i, node in enumerate(self.simple_selectors):
              # In this particular case, a ' ' combinator actually means "no" (or
              # any) combinator, so it should be ignored
              if hinge_start.is_superset_of(node, soft_combinator=True):
                  start_idx = i
                  break
          else:
              raise ValueError(
                  "Couldn't find hinge %r in compound selector %r" %
                  (hinge_start, self.simple_selectors))
  
          for i, hinge_node in enumerate(hinge):
              if i == 0:
                  # We just did this
                  continue
  
              self_node = self.simple_selectors[start_idx + i]
              if hinge_node.is_superset_of(self_node):
                  continue
  
              # TODO this isn't true; consider finding `a b` in `a c a b`
              raise ValueError(
                  "Couldn't find hinge %r in compound selector %r" %
                  (hinge_node, self.simple_selectors))
  
          end_idx = start_idx + len(hinge) - 1
  
          focal_node = self.simple_selectors[end_idx]
          extras = focal_node.difference(hinge[-1])
  
          return (
              self.simple_selectors[:start_idx],
              extras,
              self.simple_selectors[end_idx + 1:])
docs: Given a simple selector node contained within this one (a "hinge"),
          break it in half and return a parent selector, extra specifiers for the
          hinge, and a child selector.
  
          That is, given a hinge X, break the selector A + X.y B into A, + .y,
          and B.