         leftover_sequence =
           binary_part(sequence, first_line_end + 1, byte_size(sequence) - (first_line_end + 1))
 
-        {rows ++
-           [
-             {:error, EscapeSequenceError,
-              [
-                line: escape_start_line,
-                escape_max_lines: escape_max_lines,
-                escape_sequence_start:
-                  :binary.replace(partial_field, [@escape], @escape <> @escape, [:global]) <>
-                    @escape <>
-                    binary_part(
-                      sequence,
-                      field_start_position,
-                      first_line_end - field_start_position
-                    )
-              ]}
-           ], {[], "", {:open, 0, escape_start_line + 1}, leftover_sequence, :reparse}}
+        {rows
+         |> add_error(EscapeSequenceError,
+           line: escape_start_line,
+           escape_max_lines: escape_max_lines,
+           escape_sequence_start:
+             :binary.replace(partial_field, [@escape], @escape <> @escape, [:global]) <>
+               @escape <>
+               binary_part(
+                 sequence,
+                 field_start_position,
+                 first_line_end - field_start_position
+               )
+         ),
+         new_rows_transform_state(
+           {:open, 0, escape_start_line + 1},
+           {:unparsed, leftover_sequence}
+         )}
 
       @newline ->
         parse_byte_sequence(

            byte_size(sequence) - (first_newline_position + 1)
          )

        {rows ++
           [
             {:error, error_module,
              construct_arguments.(
                sequence:
                  binary_part(
                    sequence,
                    field_start_position,
                    token_position - field_start_position
                  )
              )}
           ], {[], "", {:open, 0, line + 1}, leftover_sequence, :reparse}}

      _ ->
        parse_byte_sequence(

         _,
         _
       ) do
    {rows
     |> add_error(error_module, construct_arguments.([]))
     |> add_stream_halted_to_errors, empty_transform_state()}
  end

  @compile {:inline, add_row: 2}
  def add_row(rows, row) do
    rows ++
      [
        {:ok, row}
      ]
  end

  @compile {:inline, add_error: 3}
  def add_error(rows, error_module, arguments) do
    rows ++
      [
        {:error, error_module, arguments}
      ]
  end

  @compile {:inline, add_stream_halted_to_errors: 1}
  defp add_stream_halted_to_errors(rows) do
    rows
    |> Enum.map(fn
