parseForContradictingClassNames = (classNames, node) => {
      // Init assets before sorting
      const sorted = groupUtil.initGroupSlots(groups);

      // Move each classname inside its dedicated group
      classNames.forEach((className) => {
        const idx = groupUtil.getGroupIndex(className, groups, mergedConfig.separator);
        if (idx > -1) {
          sorted[idx].push(className);
        }
      });

      // Only multiple classNames
      const sortedGroups = sorted.filter((slot) => slot.length > 1);
      const arbitraryPropsGroupIndex = sortedGroups.findIndex((slot) => {
        const suffix = groupUtil.getSuffix(slot[0], mergedConfig.separator);
        return groupUtil.getArbitraryProperty(suffix, mergedConfig.separator) !== '';
      });

      // Sorts each groups' classnames
      const ambiguousArbitraryValuesOrClasses = String.raw`(\[(.*${mergedConfig.separator}))|(^((?!:).)*$)`;

      sortedGroups.forEach((group, groupIndex) => {
        const variants = [];
        group.forEach((cls) => {
          const prefix = groupUtil.getPrefix(cls, mergedConfig.separator);
          const name = cls.substr(prefix.length);
          if (groupIndex === arbitraryPropsGroupIndex) {
            // Arbitrary Props
            const arbitraryProp = groupUtil.getArbitraryProperty(name, mergedConfig.separator);
            const identifier = prefix + arbitraryProp;
            const idx = variants.findIndex((v) => identifier === v.prefix);
            if (idx === -1) {
              variants.push({
                prefix: identifier,
                name: [name],
              });
            } else {
              variants[idx].name.push(name);
            }
          } else {
            // "Regular classNames"
            const rePrefix = prefix === '' ? ambiguousArbitraryValuesOrClasses : '^' + prefix;
            const idx = variants.findIndex((v) => v.prefix === rePrefix);
            if (idx === -1) {
              variants.push({
                prefix: rePrefix,
                name: [name],
              });
            } else {
              variants[idx].name.push(name);
            }
          }
        });

        // Several classNames with the same prefix
        const potentialTroubles = variants.filter((v) => v.name.length > 1);
        if (potentialTroubles.length) {
          potentialTroubles.forEach((variantGroup) => {
            const re = new RegExp(variantGroup.prefix);
            const conflicting = group.filter((c) => re.test(c));
            context.report({
              node: node,
              messageId: 'conflictingClassnames',
              data: {
                classnames: conflicting.join(', '),
              },
            });
          });
        }
      });
    }
Parse the classnames and report found conflicts
@param {Array} classNames
@param {ASTNode} node