diff --git a/Project.toml b/Project.toml
index a5e59587e..b2f918c20 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "SciMLBase"
 uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 authors = ["Chris Rackauckas <accounts@chrisrackauckas.com> and contributors"]
-version = "2.19.0"
+version = "2.19.1"
 
 [deps]
 ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
diff --git a/src/problems/basic_problems.jl b/src/problems/basic_problems.jl
index cd35498a5..a37ba0c54 100644
--- a/src/problems/basic_problems.jl
+++ b/src/problems/basic_problems.jl
@@ -87,7 +87,7 @@ struct StandardNonlinearProblem end
 @doc doc"""
 
 Defines an interval nonlinear system problem.
-Documentation Page: https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/
+Documentation Page: [https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/](https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/)
 
 ## Mathematical Specification of an Interval Nonlinear Problem
 
@@ -98,7 +98,7 @@ which defines the nonlinear system:
 f(t,p) = u = 0
 ```
 
-along with an interval `tspan`, ``t \\in [t_0,t_f]``, within which the root should be found.
+along with an interval `tspan`, ``t \in [t_0,t_f]``, within which the root should be found.
 `f` should be specified as `f(t,p)` (or in-place as `f(u,t,p)`), and `tspan` should be a
 `Tuple{T,T} where T <: Number`.
 
@@ -114,8 +114,8 @@ along with an interval `tspan`, ``t \\in [t_0,t_f]``, within which the root shou
 ### Constructors
 
 ```julia
-IntervalNonlinearProblem(f::NonlinearFunction,tspan,p=NullParameters();kwargs...)
-IntervalNonlinearProblem{isinplace}(f,tspan,p=NullParameters();kwargs...)
+IntervalNonlinearProblem(f::NonlinearFunction, tspan, p = NullParameters(); kwargs...)
+IntervalNonlinearProblem{isinplace}(f, tspan, p = NullParameters(); kwargs...)
 ```
 
 `isinplace` optionally sets whether the function is in-place or not. This is
@@ -188,7 +188,7 @@ end
 @doc doc"""
 
 Defines a nonlinear system problem.
-Documentation Page: https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/
+Documentation Page: [https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/](https://docs.sciml.ai/NonlinearSolve/stable/basics/NonlinearProblem/)
 
 ## Mathematical Specification of a Nonlinear Problem
 
@@ -199,8 +199,8 @@ which defines the nonlinear system:
 f(u,p) = 0
 ```
 
-and an initial guess ``u₀`` of where `f(u,p)=0`. `f` should be specified as `f(u,p)`
-(or in-place as `f(du,u,p)`), and `u₀` should be an AbstractArray (or number)
+and an initial guess ``u₀`` of where `f(u, p) = 0`. `f` should be specified as `f(u, p)`
+(or in-place as `f(du, u, p)`), and `u₀` should be an AbstractArray (or number)
 whose geometry matches the desired geometry of `u`. Note that we are not limited
 to numbers or vectors for `u₀`; one is allowed to provide `u₀` as arbitrary
 matrices / higher-dimension tensors as well.
@@ -210,8 +210,8 @@ matrices / higher-dimension tensors as well.
 ### Constructors
 
 ```julia
-NonlinearProblem(f::NonlinearFunction,u0,p=NullParameters();kwargs...)
-NonlinearProblem{isinplace}(f,u0,p=NullParameters();kwargs...)
+NonlinearProblem(f::NonlinearFunction, u0, p = NullParameters(); kwargs...)
+NonlinearProblem{isinplace}(f, u0, p = NullParameters(); kwargs...)
 ```
 
 `isinplace` optionally sets whether the function is in-place or not. This is
@@ -223,8 +223,8 @@ parameters. Any extra keyword arguments are passed on to the solvers. For exampl
 if you set a `callback` in the problem, then that `callback` will be added in
 every solve call.
 
-For specifying Jacobians and mass matrices, see the [NonlinearFunctions](@ref nonlinearfunctions)
-page.
+For specifying Jacobians and mass matrices, see the
+[NonlinearFunctions](@ref nonlinearfunctions) page.
 
 ### Fields
 
@@ -328,7 +328,7 @@ nonlinear system:
 ```
 
 and an initial guess ``u_0`` for the minimization problem. ``f`` should be specified as
-``f(u, p)`` (or in-place as ``f(du, u, p)``), and ``u_0``` should be an AbstractArray (or
+``f(u, p)`` (or in-place as ``f(du, u, p)``), and ``u_0`` should be an AbstractArray (or
 number) whose geometry matches the desired geometry of ``u``. Note that we are not limited
 to numbers or vectors for ``u_0``; one is allowed to provide ``u_0`` as arbitrary
 matrices / higher-dimension tensors as well.
@@ -338,8 +338,8 @@ matrices / higher-dimension tensors as well.
 ### Constructors
 
 ```julia
-NonlinearLeastSquaresProblem(f::NonlinearFunction, u0, p=NullParameters(); kwargs...)
-NonlinearLeastSquaresProblem{isinplace}(f, u0, p=NullParameters(); kwargs...)
+NonlinearLeastSquaresProblem(f::NonlinearFunction, u0, p = NullParameters(); kwargs...)
+NonlinearLeastSquaresProblem{isinplace}(f, u0, p = NullParameters(); kwargs...)
 ```
 
 `isinplace` optionally sets whether the function is in-place or not. This is
diff --git a/src/problems/steady_state_problems.jl b/src/problems/steady_state_problems.jl
index c963db916..376b139b2 100644
--- a/src/problems/steady_state_problems.jl
+++ b/src/problems/steady_state_problems.jl
@@ -1,7 +1,7 @@
 @doc doc"""
 
 Defines a steady state ODE problem.
-Documentation Page: https://docs.sciml.ai/DiffEqDocs/stable/types/steady_state_types/
+Documentation Page: [https://docs.sciml.ai/DiffEqDocs/stable/types/steady_state_types/](https://docs.sciml.ai/DiffEqDocs/stable/types/steady_state_types/)
 
 ## Mathematical Specification of a Steady State Problem
 
@@ -9,27 +9,27 @@ To define a Steady State Problem, you simply need to give the function ``f``
 which defines the ODE:
 
 ```math
-\frac{du}{dt} = f(u,p,t)
+\frac{du}{dt} = f(u, p, t)
 ```
 
-and an initial guess ``u_0`` of where `f(u,p,t)=0`. `f` should be specified as `f(u,p,t)`
-(or in-place as `f(du,u,p,t)`), and `u₀` should be an AbstractArray (or number)
-whose geometry matches the desired geometry of `u`. Note that we are not limited
+and an initial guess ``u_0`` of where `f(u, p, t) = 0`. `f` should be specified as
+`f(u, p, t)` (or in-place as `f(du, u, p, t)`), and `u₀` should be an AbstractArray
+(or number) whose geometry matches the desired geometry of `u`. Note that we are not limited
 to numbers or vectors for `u₀`; one is allowed to provide `u₀` as arbitrary
 matrices / higher dimension tensors as well.
 
 Note that for the steady-state to be defined, we must have that `f` is autonomous,
 that is `f` is independent of `t`. But the form which matches the standard ODE
 solver should still be used. The steady state solvers interpret the `f` by
-fixing ``t=\\infty``.
+fixing ``t = \infty``.
 
 ## Problem Type
 
 ### Constructors
 
 ```julia
-SteadyStateProblem(f::ODEFunction,u0,p=NullParameters();kwargs...)
-SteadyStateProblem{isinplace,specialize}(f,u0,p=NullParameters();kwargs...)
+SteadyStateProblem(f::ODEFunction, u0, p = NullParameters(); kwargs...)
+SteadyStateProblem{isinplace, specialize}(f, u0, p = NullParameters(); kwargs...)
 ```
 
 `isinplace` optionally sets whether the function is inplace or not. This is