docs: private void updateMappingsWithLocalReferences(MtasParserObject currentObject,
        Map<String, List<MtasParserObject>> currentList,
        Map<String, Map<Integer, Set<String>>> updateList) {
      if (currentObject.getType().type.equals(MAPPING_TYPE_GROUP)) {
        for (Integer tokenId : updateList
            .get(UPDATE_TYPE_LOCAL_REF_POSITION_START).keySet()) {
          if (updateList.get(UPDATE_TYPE_LOCAL_REF_POSITION_END)
              .containsKey(tokenId)
              && updateList.get(UPDATE_TYPE_LOCAL_REF_OFFSET_START)
                  .containsKey(tokenId)
              && updateList.get(UPDATE_TYPE_LOCAL_REF_OFFSET_END)
                  .containsKey(tokenId)) {
            Iterator<String> startPositionIt = updateList
                .get(UPDATE_TYPE_LOCAL_REF_POSITION_START).get(tokenId)
                .iterator();
            Iterator<String> endPositionIt = updateList
                .get(UPDATE_TYPE_LOCAL_REF_POSITION_END).get(tokenId).iterator();
            Iterator<String> startOffsetIt = updateList
                .get(UPDATE_TYPE_LOCAL_REF_OFFSET_START).get(tokenId).iterator();
            Iterator<String> endOffsetIt = updateList
                .get(UPDATE_TYPE_LOCAL_REF_OFFSET_END).get(tokenId).iterator();
            Integer startPosition = null;
            Integer endPosition = null;
            Integer startOffset = null;
            Integer endOffset = null;
            Integer newValue = null;
            while (startPositionIt.hasNext()) {
              String localKey = startPositionIt.next();
              if (currentObject.referredStartPosition.containsKey(localKey)) {
                newValue = currentObject.referredStartPosition.get(localKey);
                startPosition = (startPosition == null) ? newValue
                    : Math.min(startPosition, newValue);
              }
            }
            while (endPositionIt.hasNext()) {
              String localKey = endPositionIt.next();
              if (currentObject.referredEndPosition.containsKey(localKey)) {
                newValue = currentObject.referredEndPosition.get(localKey);
                endPosition = (endPosition == null) ? newValue
                    : Math.max(endPosition, newValue);
              }
            }
            while (startOffsetIt.hasNext()) {
              String localKey = startOffsetIt.next();
              if (currentObject.referredStartOffset.containsKey(localKey)) {
                newValue = currentObject.referredStartOffset.get(localKey);
                startOffset = (startOffset == null) ? newValue
                    : Math.min(startOffset, newValue);
              }
            }
            while (endOffsetIt.hasNext()) {
              String localKey = endOffsetIt.next();
              if (currentObject.referredEndOffset.containsKey(localKey)) {
                newValue = currentObject.referredEndOffset.get(localKey);
                endOffset = (endOffset == null) ? newValue
                    : Math.max(endOffset, newValue);
              }
            }
            if (startPosition != null && endPosition != null
                && startOffset != null && endOffset != null) {
              MtasToken token = tokenCollection.get(tokenId);
              token.addPositionRange(startPosition, endPosition);
              token.setOffset(startOffset, endOffset);
            }
          }
        }
  
      }
      if (!currentList.get(MAPPING_TYPE_GROUP).isEmpty()) {
        MtasParserObject parentGroup = currentList.get(MAPPING_TYPE_GROUP)
            .get(currentList.get(MAPPING_TYPE_GROUP).size() - 1);
        parentGroup.referredStartPosition
            .putAll(currentObject.referredStartPosition);
        parentGroup.referredEndPosition.putAll(currentObject.referredEndPosition);
        parentGroup.referredStartOffset.putAll(currentObject.referredStartOffset);
        parentGroup.referredEndOffset.putAll(currentObject.referredEndOffset);
      }
      currentObject.referredStartPosition.clear();
      currentObject.referredEndPosition.clear();
      currentObject.referredStartOffset.clear();
      currentObject.referredEndOffset.clear();
    }