code: def parseAnchorName(
      anchorName,
      markPrefix=MARK_PREFIX,
      ligaSeparator=LIGA_SEPARATOR,
      ligaNumRE=LIGA_NUM_RE,
      ignoreRE=None,
  ):
      
      number = None
      if ignoreRE is not None:
          anchorName = re.sub(ignoreRE, "", anchorName)
  
      m = ligaNumRE.match(anchorName)
      if not m:
          key = anchorName
      else:
          number = m.group(1)
          key = anchorName.rstrip(number)
          separator = ligaSeparator
          if key.endswith(separator):
              assert separator
              key = key[: -len(separator)]
              number = int(number)
          else:
              # not a valid ligature anchor name
              key = anchorName
              number = None
  
      if anchorName.startswith(markPrefix) and key:
          if number is not None:
              raise ValueError("mark anchor cannot be numbered: %r" % anchorName)
          isMark = True
          key = key[len(markPrefix) :]
          if not key:
              raise ValueError("mark anchor key is nil: %r" % anchorName)
      else:
          isMark = False
  
      return isMark, key, number
docs: Parse anchor name and return a tuple that specifies:
      1) whether the anchor is a "mark" anchor (bool);
      2) the "key" name of the anchor, i.e. the name after stripping all the
         prefixes and suffixes, which identifies the class it belongs to (str);
      3) An optional number (int), starting from 1, which identifies that index
         of the ligature component the anchor refers to.
  
      The 'ignoreRE' argument is an optional regex pattern (str) identifying
      sub-strings in the anchor name that should be ignored when parsing the
      three elements above.