anchor.diff:                              send-data
                               body-complete-p))
                    (if body-complete-p
  +                     ;; there are no more chunks in thie field, make sure we mark
  +                     ;; the state vars as such, and trim the data down to the next
  +                     ;; boundary
                        (progn
                          (setf current-field-headers nil
                                current-field-name nil
                                current-field-kv nil
                                just-finished-chunk t)
                          (setf data (subseq data (+ 2 body-end boundary-length))))
  +                     ;; there are more chunks but we don't have the data yet.
  +                     ;; truncate `data`.
                        (setf data (make-array 0 :element-type '(unsigned-byte 8))))))
  -          ;; loop until no more boundaries found
  +          ;; loop until while there are more chunk boundaries found or when we
  +          ;; just finished a chunk in the last loop, meaning there is probably
  +          ;; more data to process even if there isn't a boundary (since we might
  +          ;; have all the headers for the next field)
             (loop while (or (search boundary data)
                             just-finished-chunk)
                   for data-length = (length data) do
  
positive.code:                             current-field-kv kv
                              current-field-name field-name)
                        (send-data-to-callback body-start body-end body-complete-p)))))
              (when (= (length data) data-length)
                (return-from leave-parser))))))))
  
  
negative.code:                      "multipart/form-data;")
        (return-from make-multipart-parser nil))
      (lambda (chunk-data)
        ;; continuously append new data to our data array
        (setf data (append-array data chunk-data))
        (block leave-parser
          ;; define a function that sends parsed multipart data to the given
          ;; callback and trims the `data` variable of bytes that have been parsed
          ;; (to keep it continuously small).
          (flet ((send-data-to-callback (body-start body-end body-complete-p)
                   (let ((send-data (subseq data body-start (if body-complete-p body-end nil))))
                     (funcall callback
  