docs: private boolean processElementAttributes(Element element) {
      Attributes attributes = element.getAttributes();
      if (attributes == null) {
        return false;
      }
  
      boolean shouldPopContext = false;
      registerMandatoryAttributes(attributes);
  
      Attribute vForAttribute = attributes.get("v-for");
      Attribute slotScopeAttribute = attributes.get("slot-scope");
      if (vForAttribute != null || slotScopeAttribute != null) {
        // Add a context layer
        shouldPopContext = true;
        context.addContextLayer(vForAttribute != null);
      }
  
      if (vForAttribute != null) {
        String processedVForValue = processVForValue(vForAttribute.getValue());
        outputDocument.replace(vForAttribute.getValueSegment(), processedVForValue);
      }
  
      if (slotScopeAttribute != null) {
        String processedScopedSlotValue = processSlotScopeValue(slotScopeAttribute.getValue());
        outputDocument.replace(slotScopeAttribute.getValueSegment(), processedScopedSlotValue);
      }
  
      Optional<LocalComponent> localComponent = getLocalComponentForElement(element);
  
      Attribute refAttribute = attributes.get("ref");
      if (refAttribute != null) {
        result.addRef(
            refAttribute.getValue(),
            localComponent.map(LocalComponent::getComponentType)
                .orElse(getTypeFromDOMElement(element)),
            context.isInVFor()
        );
      }
  
      Map<String, Class<?>> elementPropertiesType = getPropertiesForDOMElement(element)
          .orElse(new HashMap<>());
  
      // Iterate on element attributes
      Set<LocalComponentProp> foundProps = new HashSet<>();
      for (Attribute attribute : element.getAttributes()) {
        String key = attribute.getKey();
        if ("v-for".equals(key) || "slot-scope".equals(key)) {
          continue;
        }
  
        if ("v-model".equals(key)) {
          processVModel(attribute);
          continue;
        }
  
        Optional<LocalComponentProp> optionalProp =
            localComponent.flatMap(lc -> lc.getPropForAttribute(attribute.getName()));
        optionalProp.ifPresent(foundProps::add);
  
        if (!VUE_ATTR_PATTERN.matcher(key).matches()) {
          optionalProp.ifPresent(this::validateStringPropBinding);
          continue;
        }
  
        context.setCurrentSegment(attribute);
  
        currentAttribute = attribute;
        currentProp = optionalProp.orElse(null);
        currentExpressionReturnType = getExpressionReturnTypeForAttribute(attribute,
            elementPropertiesType);
        String processedExpression = processExpression(attribute.getValue());
  
        if (attribute.getValueSegment() != null) {
          outputDocument.replace(attribute.getValueSegment(), processedExpression);
        }
      }
  
      localComponent.ifPresent(lc -> validateRequiredProps(lc, foundProps));
  
      return shouldPopContext;
    }