code: function or(matches, pattern, file) {
    var length = matches.length
    var note = pattern.note
    var id = pattern.id
    var index = -1
    var match
    var next
    var siblings
    var sibling
    var value
    var nodes
    var start
    var end
  
    while (++index < length) {
      match = matches[index]
      siblings = match.parent.children
      nodes = match.nodes
      value = toString(nodes)
      next = matches[index + 1]
  
      if (next && next.parent === match.parent && next.type !== match.type) {
        start = match.end
        end = next.start
  
        while (++start < end) {
          sibling = siblings[start]
  
          if (
            sibling.type === ws ||
            (sibling.type === word && /(and|or)/.test(normalize(sibling))) ||
            (sibling.type === punc && normalize(sibling) === '/')
          ) {
            continue
          }
  
          break
        }
  
        /* If we didn't break... */
        if (start === end) {
          index++
          continue
        }
      }
  
      warn(
        file,
        id,
        value,
        pattern.considerate,
        nodes[0],
        note,
        pattern.condition
      )
    }
  }
docs: /* Handle matches for an `or` pattern.  Or-patterns
  trigger a warning unless every category is present.
  
  For example, when `him` and `her` occur adjacent
  to each other, they are not warned about. But when
  they occur alone, they are.