   "Internal lazy-seq parser"
   [^JsonParser parser key-fn array-coerce-fn]
   (lazy-seq
-   (let [elem (parse parser key-fn eof array-coerce-fn)]
+   (let [elem (parse/parse parser key-fn eof array-coerce-fn)]
      (when-not (identical? elem eof)
        (cons elem (parsed-seq* parser key-fn array-coerce-fn))))))
 

  ([obj opt-map]
     (let [baos (ByteArrayOutputStream.)
           generator (.createJsonGenerator ^SmileFactory
                                           (or *smile-factory* smile-factory)
                                           baos)]
       (generate generator obj (or (:date-format opt-map) default-date-format)
                 (:ex opt-map))
       (.flush generator)
       (.toByteArray baos))))

     (generate-stream obj writer nil))
  ([obj ^BufferedWriter writer opt-map]
     (let [generator (.createJsonGenerator
                      ^JsonFactory (or factory/*json-factory*
                                       factory/json-factory) writer)]
       (when (:pretty opt-map)
         (.useDefaultPrettyPrinter generator))
       (when (:escape-non-ascii opt-map)
         (.enable generator JsonGenerator$Feature/ESCAPE_NON_ASCII))
       (gen/generate generator obj (or (:date-format opt-map)
                                       factory/default-date-format)
                 (:ex opt-map))
       (.flush generator)
       writer)))
