def METHOD_NAME(self, data: List[str]) -> List[str]:
    current_e = 0.0
    to_compensate = 0  # Used when extrusion mode is relative.
    is_active = False  # Whether retract-continue is in effect.
    current_pos = Vector(0.0, 0.0, 0.0)
    last_pos = Vector(0.0, 0.0, 0.0)
    extra_retraction_speed = self.getSettingValueByKey("extra_retraction_speed")
    relative_extrusion = Application.getInstance().getGlobalContainerStack().getProperty(
        "relative_extrusion", "value"
    )
    for layer_number, layer in enumerate(data):
        lines = layer.split("\n")
        for line_number, line in enumerate(lines):
            # Focus on move-type lines.
            code_g = self.getValue(line, "G")
            if code_g not in [0, 1]:
                continue
            # Track X,Y,Z location.
            last_pos = last_pos.set(current_pos.x, current_pos.y, current_pos.z)
            current_pos = current_pos.set(
                self.getValue(line, "X", current_pos.x),
                self.getValue(line, "Y", current_pos.y),
                self.getValue(line, "Z", current_pos.z)
            )
            # Track extrusion 'axis' position.
            last_e = current_e
            e_value = self.getValue(line, "E")
            if e_value:
                current_e = (current_e if relative_extrusion else 0) + e_value
            # Handle lines: Detect retractions and compensate relative if G1, potential retract-continue if G0.
            if code_g == 1:
                if last_e > (current_e + 0.0001):  # Account for floating point inaccuracies.
                    # There is a retraction, each following G0 command needs to continue the retraction.
                    is_active = True
                    continue
                elif relative_extrusion and is_active:
                    # If 'relative', the first G1 command after the total retraction will have to compensate more.
                    travel, f = self._getTravelMove(lines[line_number], current_pos)
                    lines[line_number] = self._travelMoveString(travel, f, to_compensate + e_value)
                    to_compensate = 0.0
                # There is no retraction (see continue in the retract-clause) and everything else has been handled.
                is_active = False
            elif code_g == 0:
                if not is_active:
                    continue
                # The retract-continue is active, so each G0 until the next extrusion needs to continue retraction.
                travel, f = self._getTravelMove(lines[line_number], current_pos)
                travel_length = (current_pos - last_pos).length()
                extra_retract = travel_length * extra_retraction_speed
                new_e = (0 if relative_extrusion else current_e) - extra_retract
                to_compensate += extra_retract
                current_e -= extra_retract
                lines[line_number] = self._travelMoveString(travel, f, new_e)
        new_layer = "\n".join(lines)
        data[layer_number] = new_layer
    return data