From 7f1ab5767311d651c20482b3d2dba25c6b1e58bf Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 08:18:34 +0100
Subject: [PATCH 1/7] Road to #164

    - added .formatter.exs
    - modified CI to check for formatted, WIP
---
 .formatter.exs               | 10 ++++++++++
 .github/workflows/elixir.yml |  5 +++++
 2 files changed, 15 insertions(+)
 create mode 100644 .formatter.exs

diff --git a/.formatter.exs b/.formatter.exs
new file mode 100644
index 0000000..119aa3d
--- /dev/null
+++ b/.formatter.exs
@@ -0,0 +1,10 @@
+[
+  force_do_end_blocks: true,
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 120,
+  migrate: true,
+  migrate_bitstring_modifiers: true,
+  migrate_charlists_as_sigils: true,
+  migrate_unless: false,
+]
+# SPDX-License-Identifier: Apache-2.0
diff --git a/.github/workflows/elixir.yml b/.github/workflows/elixir.yml
index 87fe759..6214b73 100644
--- a/.github/workflows/elixir.yml
+++ b/.github/workflows/elixir.yml
@@ -68,6 +68,11 @@ jobs:
         env:
           CC: gcc-10
           CXX: g++-10
+      - run: mix format --check-formatted
+        if: matrix.warnings_as_errors
+        env:
+          CC: gcc-10
+          CXX: g++-10
       - run: mix compile
         if: ${{! matrix.warnings_as_errors}}
         env:

From faae95251e6ca2e73704ceae342c5c0510be4ff5 Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 11:19:29 +0100
Subject: [PATCH 2/7] Road to #164

    - added .formatter.exs
    - modified CI to check for formatted, WIP
    - modified CI to run on this branch
---
 .github/workflows/elixir.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/elixir.yml b/.github/workflows/elixir.yml
index 6214b73..e094096 100644
--- a/.github/workflows/elixir.yml
+++ b/.github/workflows/elixir.yml
@@ -4,6 +4,7 @@ on:
   pull_request:
   push:
     branches:
+      - i164-use-formatter
       - master
 
 jobs:

From 7aa41276e381f20ff4bc681335fd81d68bdf94ea Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 11:24:32 +0100
Subject: [PATCH 3/7] Road to #164

  - Commented all but one matrix entry as we will use lots of workers here
  - Put formatting action at the end to check all other actions for each
    pushed commit
---
 .github/workflows/elixir.yml | 56 ++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/.github/workflows/elixir.yml b/.github/workflows/elixir.yml
index e094096..a6086c4 100644
--- a/.github/workflows/elixir.yml
+++ b/.github/workflows/elixir.yml
@@ -15,29 +15,29 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - elixir: 1.14.x
-            otp: 25
-            os: ubuntu-latest
-          - elixir: 1.15.x
-            otp: 25
-            os: ubuntu-latest
-            warnings_as_errors: true
-          - elixir: 1.16.x
-            otp: 26
-            os: ubuntu-latest
-            warnings_as_errors: true
-          - elixir: 1.17.x
-            otp: 27
-            os: ubuntu-latest
-            warnings_as_errors: true
-          - elixir: 1.18.0-otp-25
-            otp: 25
-            os: ubuntu-latest
-            warnings_as_errors: true
-          - elixir: 1.18.0-otp-27
-            otp: 27
-            os: ubuntu-latest
-            warnings_as_errors: true
+          # - elixir: 1.14.x
+          #   otp: 25
+          #   os: ubuntu-latest
+          # - elixir: 1.15.x
+          #   otp: 25
+          #   os: ubuntu-latest
+          #   warnings_as_errors: true
+          # - elixir: 1.16.x
+          #   otp: 26
+          #   os: ubuntu-latest
+          #   warnings_as_errors: true
+          # - elixir: 1.17.x
+          #   otp: 27
+          #   os: ubuntu-latest
+          #   warnings_as_errors: true
+          # - elixir: 1.18.0-otp-25
+          #   otp: 25
+          #   os: ubuntu-latest
+          #   warnings_as_errors: true
+          # - elixir: 1.18.0-otp-27
+          #   otp: 27
+          #   os: ubuntu-latest
+          #   warnings_as_errors: true
           - elixir: 1.18.3-otp-27
             otp: 27
             os: ubuntu-latest
@@ -69,11 +69,6 @@ jobs:
         env:
           CC: gcc-10
           CXX: g++-10
-      - run: mix format --check-formatted
-        if: matrix.warnings_as_errors
-        env:
-          CC: gcc-10
-          CXX: g++-10
       - run: mix compile
         if: ${{! matrix.warnings_as_errors}}
         env:
@@ -89,6 +84,11 @@ jobs:
         env:
           CC: gcc-10
           CXX: g++-10
+      - run: mix format --check-formatted
+        if: matrix.warnings_as_errors
+        env:
+          CC: gcc-10
+          CXX: g++-10
 
 # This workflow uses actions that are not certified by GitHub.
 # They are provided by a third-party and are governed by

From dcaa98373da2e713d74ff33bdec3b5acf83c3b6c Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 13:05:36 +0100
Subject: [PATCH 4/7] Road to #164

  - formatted files:
    - mix.exs
    - lib/earmark_parser.ex
    - lib/earmark_parser/ast/**/*.ex
---
 lib/earmark_parser.ex                         |  9 +--
 lib/earmark_parser/ast/emitter.ex             | 21 ++++--
 lib/earmark_parser/ast/inline.ex              | 51 +++++++++----
 lib/earmark_parser/ast/renderer/ast_walker.ex | 72 ++++++++++++-------
 .../ast/renderer/footnote_renderer.ex         | 13 ++--
 .../ast/renderer/html_renderer.ex             | 18 ++++-
 .../ast/renderer/table_renderer.ex            | 25 +++++--
 mix.exs                                       | 14 +++-
 8 files changed, 159 insertions(+), 64 deletions(-)

diff --git a/lib/earmark_parser.ex b/lib/earmark_parser.ex
index d6cfaa8..49ef870 100644
--- a/lib/earmark_parser.ex
+++ b/lib/earmark_parser.ex
@@ -615,7 +615,7 @@ defmodule EarmarkParser do
 
   The AST is exposed in the spirit of [Floki's](https://hex.pm/packages/floki).
   """
-  @spec as_ast(binary()|list(binary()), any()) :: t()
+  @spec as_ast(binary() | list(binary()), any()) :: t()
   def as_ast(lines, options \\ %Options{})
 
   def as_ast(lines, %Options{} = options) do
@@ -644,7 +644,7 @@ defmodule EarmarkParser do
   end
 
   def as_ast(_, options) do
-    raise ArgumentError, "#{inspect options} not a legal options map or keyword list"
+    raise ArgumentError, "#{inspect(options)} not a legal options map or keyword list"
   end
 
   defp _as_ast(lines, options) do
@@ -657,8 +657,9 @@ defmodule EarmarkParser do
     `iex` usage.
   """
   def version() do
-    with {:ok, version} <- :application.get_key(:earmark_parser, :vsn),
-      do: to_string(version)
+    with {:ok, version} <- :application.get_key(:earmark_parser, :vsn) do
+      to_string(version)
+    end
   end
 end
 
diff --git a/lib/earmark_parser/ast/emitter.ex b/lib/earmark_parser/ast/emitter.ex
index f71b710..7e0e3b2 100644
--- a/lib/earmark_parser/ast/emitter.ex
+++ b/lib/earmark_parser/ast/emitter.ex
@@ -2,28 +2,41 @@ defmodule EarmarkParser.Ast.Emitter do
   @moduledoc false
 
   def emit(tag, content \\ [], atts \\ [], meta \\ %{})
+
   def emit(tag, content, atts, meta) when is_binary(content) or is_tuple(content) do
     {tag, _to_atts(atts), [content], meta}
   end
+
   def emit(tag, content, atts, meta) do
     {tag, _to_atts(atts), content, meta}
   end
 
-
   defp _to_atts(atts)
-  defp _to_atts(nil), do: []
+
+  defp _to_atts(nil) do
+    []
+  end
+
   defp _to_atts(atts) when is_map(atts) do
     atts
     |> Enum.into([])
     |> Enum.map(fn {name, value} -> {to_string(name), _to_string(value)} end)
   end
+
   defp _to_atts(atts) do
     atts
     |> Enum.map(fn {name, value} -> {to_string(name), _to_string(value)} end)
   end
 
   defp _to_string(value)
-  defp _to_string(value) when is_list(value), do: Enum.join(value, " ")
-  defp _to_string(value), do: to_string(value)
+
+  defp _to_string(value) when is_list(value) do
+    Enum.join(value, " ")
+  end
+
+  defp _to_string(value) do
+    to_string(value)
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/ast/inline.ex b/lib/earmark_parser/ast/inline.ex
index f785132..da4c6e1 100644
--- a/lib/earmark_parser/ast/inline.ex
+++ b/lib/earmark_parser/ast/inline.ex
@@ -32,7 +32,9 @@ defmodule EarmarkParser.Ast.Inline do
     prepend(context, src)
   end
 
-  defp _convert("", _, context, _), do: context
+  defp _convert("", _, context, _) do
+    context
+  end
 
   defp _convert(src, current_lnb, context, use_linky?) do
     {src1, lnb1, context1, use_linky1?} = _convert_next(src, current_lnb, context, use_linky?)
@@ -218,7 +220,9 @@ defmodule EarmarkParser.Ast.Inline do
     end
   end
 
-  def converter_for_sub(_), do: nil
+  def converter_for_sub(_) do
+    nil
+  end
 
   def converter_for_sup({src, _, %{options: %{sub_sup: true}}, _} = conv_tuple) do
     sup_rgx = ~r{\A\^(?=\S)(.*?\S)\^}
@@ -228,7 +232,9 @@ defmodule EarmarkParser.Ast.Inline do
     end
   end
 
-  def converter_for_sup(_), do: nil
+  def converter_for_sup(_) do
+    nil
+  end
 
   def converter_for_math_inline({src, lnb, %{options: %{math: true}} = context, use_linky?}) do
     math_inline_rgx = ~r{\A\$(?=[^\s$])([\s\S]*?[^\s\\])\$}
@@ -241,7 +247,9 @@ defmodule EarmarkParser.Ast.Inline do
     end
   end
 
-  def converter_for_math_inline(_), do: nil
+  def converter_for_math_inline(_) do
+    nil
+  end
 
   def converter_for_math_display({src, lnb, %{options: %{math: true}} = context, use_linky?}) do
     math_display_rgx = ~r{\A\$\$([\s\S]+?)\$\$}
@@ -254,7 +262,9 @@ defmodule EarmarkParser.Ast.Inline do
     end
   end
 
-  def converter_for_math_display(_), do: nil
+  def converter_for_math_display(_) do
+    nil
+  end
 
   def converter_for_code({src, lnb, context, use_linky?}) do
     code = ~r{^
@@ -326,8 +336,7 @@ defmodule EarmarkParser.Ast.Inline do
 
     context1 = _convert(content, lnb, set_value(context, []), use_linky?)
 
-    {behead(src, match1), lnb, prepend(context, emit(for_tag, context1.value |> Enum.reverse())),
-     use_linky?}
+    {behead(src, match1), lnb, prepend(context, emit(for_tag, context1.value |> Enum.reverse())), use_linky?}
   end
 
   defp _prepend_footnote(context, out, id) do
@@ -339,7 +348,13 @@ defmodule EarmarkParser.Ast.Inline do
   defp convert_autolink(link, separator)
 
   defp convert_autolink(link, _separator = "@") do
-    link = if String.at(link, 6) == ":", do: behead(link, 7), else: link
+    link =
+      if String.at(link, 6) == ":" do
+        behead(link, 7)
+      else
+        link
+      end
+
     text = link
     href = "mailto:" <> text
     {href, text}
@@ -359,8 +374,14 @@ defmodule EarmarkParser.Ast.Inline do
   end
 
   defp hard_line_breaks(text, gfm)
-  defp hard_line_breaks(text, false), do: text
-  defp hard_line_breaks(text, nil), do: text
+
+  defp hard_line_breaks(text, false) do
+    text
+  end
+
+  defp hard_line_breaks(text, nil) do
+    text
+  end
 
   defp hard_line_breaks(text, _) do
     text
@@ -460,8 +481,14 @@ defmodule EarmarkParser.Ast.Inline do
   end
 
   defp _remove_leading_empty(list)
-  defp _remove_leading_empty(["" | rest]), do: rest
-  defp _remove_leading_empty(list), do: list
+
+  defp _remove_leading_empty(["" | rest]) do
+    rest
+  end
+
+  defp _remove_leading_empty(list) do
+    list
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/ast/renderer/ast_walker.ex b/lib/earmark_parser/ast/renderer/ast_walker.ex
index 3a60b0b..7fce56f 100644
--- a/lib/earmark_parser/ast/renderer/ast_walker.ex
+++ b/lib/earmark_parser/ast/renderer/ast_walker.ex
@@ -1,54 +1,74 @@
 defmodule EarmarkParser.Ast.Renderer.AstWalker do
-  
   @moduledoc false
 
-  def walk(anything, fun, ignore_map_keys \\ false), do: _walk(anything, fun, ignore_map_keys, false)
-
-  def walk_ast(ast, fun), do: _walk_ast(ast, fun, [])
+  def walk(anything, fun, ignore_map_keys \\ false) do
+    _walk(anything, fun, ignore_map_keys, false)
+  end
 
+  def walk_ast(ast, fun) do
+    _walk_ast(ast, fun, [])
+  end
 
   defp _walk(ast, fun, ignore_map_keys, child_of_map)
-  defp _walk([], _fun, _ignore_map_keys, _child_of_map), do: []
+
+  defp _walk([], _fun, _ignore_map_keys, _child_of_map) do
+    []
+  end
+
   defp _walk(list, fun, ignore_map_keys, _child_of_map) when is_list(list) do
-    Enum.map(list, &(_walk(&1, fun, ignore_map_keys, false)))
+    Enum.map(list, &_walk(&1, fun, ignore_map_keys, false))
   end
+
   defp _walk(map, fun, ignore_map_keys, _child_of_map) when is_map(map) do
     map
-      |> Enum.into(%{}, &(_walk(&1, fun, ignore_map_keys, true)))
+    |> Enum.into(%{}, &_walk(&1, fun, ignore_map_keys, true))
   end
+
   defp _walk(tuple, fun, ignore_map_keys, child_of_map) when is_tuple(tuple) do
     if child_of_map && ignore_map_keys do
       _walk_map_element(tuple, fun, ignore_map_keys)
     else
       tuple
-      |> Tuple.to_list
-      |> Enum.map(&(_walk(&1, fun, ignore_map_keys, false)))
-      |> List.to_tuple
+      |> Tuple.to_list()
+      |> Enum.map(&_walk(&1, fun, ignore_map_keys, false))
+      |> List.to_tuple()
     end
   end
-  defp _walk(ele, fun, _ignore_map_keys, _child_of_map), do: fun.(ele)
 
-  defp _walk_map_element({key, value}, fun, ignore_map_keys) do 
-    {key, _walk(value, fun, ignore_map_keys, false)}
+  defp _walk(ele, fun, _ignore_map_keys, _child_of_map) do
+    fun.(ele)
   end
 
+  defp _walk_map_element({key, value}, fun, ignore_map_keys) do
+    {key, _walk(value, fun, ignore_map_keys, false)}
+  end
 
   defp _walk_ast(ast, fun, res)
-  defp _walk_ast([], _fun, res), do: Enum.reverse(res)
-  defp _walk_ast(stringy, fun, res) when is_binary(stringy), do: _walk_ast([stringy], fun, res)
-  defp _walk_ast([stringy|rest], fun, res) when is_binary(stringy) do
-    res1 = 
-    case fun.(stringy) do
-      []          -> res
-      [_|_]=trans -> List.flatten([Enum.reverse(trans)|res])
-      stringy1    -> [stringy1|res]
-    end
+
+  defp _walk_ast([], _fun, res) do
+    Enum.reverse(res)
+  end
+
+  defp _walk_ast(stringy, fun, res) when is_binary(stringy) do
+    _walk_ast([stringy], fun, res)
+  end
+
+  defp _walk_ast([stringy | rest], fun, res) when is_binary(stringy) do
+    res1 =
+      case fun.(stringy) do
+        [] -> res
+        [_ | _] = trans -> List.flatten([Enum.reverse(trans) | res])
+        stringy1 -> [stringy1 | res]
+      end
+
     _walk_ast(rest, fun, res1)
   end
-  defp _walk_ast([{tag, atts, content, meta}|rest], fun, res) do
-    _walk_ast(rest, fun, [{tag, atts, _walk_ast(content, fun, []), meta}|res])
+
+  defp _walk_ast([{tag, atts, content, meta} | rest], fun, res) do
+    _walk_ast(rest, fun, [{tag, atts, _walk_ast(content, fun, []), meta} | res])
   end
-  defp _walk_ast([list|rest], fun, res) when is_list(list) do
-    _walk_ast(rest, fun, [_walk_ast(list, fun, [])|res])
+
+  defp _walk_ast([list | rest], fun, res) when is_list(list) do
+    _walk_ast(rest, fun, [_walk_ast(list, fun, []) | res])
   end
 end
diff --git a/lib/earmark_parser/ast/renderer/footnote_renderer.ex b/lib/earmark_parser/ast/renderer/footnote_renderer.ex
index 3010387..d284154 100644
--- a/lib/earmark_parser/ast/renderer/footnote_renderer.ex
+++ b/lib/earmark_parser/ast/renderer/footnote_renderer.ex
@@ -23,26 +23,27 @@ defmodule EarmarkParser.Ast.Renderer.FootnoteRenderer do
     prepend(context, ast) |> Message.add_messages(errors)
   end
 
-  defp _render_footnote_def(%Block.FnDef{blocks: blocks, id: id}, {ast, errors, context}=acc) do
+  defp _render_footnote_def(%Block.FnDef{blocks: blocks, id: id}, {ast, errors, context} = acc) do
     if MapSet.member?(context.referenced_footnote_ids, id) do
       context1 = AstRenderer.render(blocks, clear_value(context))
       a_attrs = %{title: "return to article", class: "reversefootnote", href: "#fnref:#{id}"}
+
       footnote_li_ast =
-        emit("li", [emit("a", ["&#x21A9;"], a_attrs, %{verbatim: true}) | context1.value],
-         id: "fn:#{id}")
-      {[footnote_li_ast|ast], MapSet.union(errors, context1.options.messages), context}
+        emit("li", [emit("a", ["&#x21A9;"], a_attrs, %{verbatim: true}) | context1.value], id: "fn:#{id}")
+
+      {[footnote_li_ast | ast], MapSet.union(errors, context1.options.messages), context}
     else
       acc
     end
   end
 
-
   defp render_footnote_blocks(footnotes, context) do
     {elements, errors, _} =
       footnotes
       |> Enum.reduce({[], @empty_set, context}, &_render_footnote_def/2)
 
-    {elements|>Enum.reverse, errors}
+    {elements |> Enum.reverse(), errors}
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/ast/renderer/html_renderer.ex b/lib/earmark_parser/ast/renderer/html_renderer.ex
index 0e61afd..e58cd05 100644
--- a/lib/earmark_parser/ast/renderer/html_renderer.ex
+++ b/lib/earmark_parser/ast/renderer/html_renderer.ex
@@ -10,13 +10,27 @@ defmodule EarmarkParser.Ast.Renderer.HtmlRenderer do
 
   def render_html_block(lines, context, annotation) do
     [tag] = parse_html(lines)
-    tag_ = if annotation, do: annotate(tag, annotation), else: tag
+
+    tag_ =
+      if annotation do
+        annotate(tag, annotation)
+      else
+        tag
+      end
+
     prepend(context, tag_)
   end
 
   def render_html_oneline([line | _], context, annotation \\ []) do
     [tag | rest] = parse_html([line])
-    tag_ = if annotation, do: annotate(tag, annotation), else: tag
+
+    tag_ =
+      if annotation do
+        annotate(tag, annotation)
+      else
+        tag
+      end
+
     prepend(context, [tag_ | rest])
   end
 
diff --git a/lib/earmark_parser/ast/renderer/table_renderer.ex b/lib/earmark_parser/ast/renderer/table_renderer.ex
index 1411ef4..dfa6ee7 100644
--- a/lib/earmark_parser/ast/renderer/table_renderer.ex
+++ b/lib/earmark_parser/ast/renderer/table_renderer.ex
@@ -11,18 +11,19 @@ defmodule EarmarkParser.Ast.Renderer.TableRenderer do
       header
       |> Enum.zip(aligns)
       |> Enum.map_reduce(context, &_render_col(&1, &2, lnb, "th"))
+
     {emit("thead", emit("tr", th_ast)), context1}
   end
 
   def render_rows(rows, lnb, aligns, context) do
     {rows1, context1} =
       rows
-        |> Enum.zip(Stream.iterate(lnb, &(&1 + 1)))
-        |> Enum.map_reduce(context, &_render_row(&1, &2, aligns))
+      |> Enum.zip(Stream.iterate(lnb, &(&1 + 1)))
+      |> Enum.map_reduce(context, &_render_row(&1, &2, aligns))
+
     {[emit("tbody", rows1)], context1}
   end
 
-
   defp _render_cols(row, lnb, aligns, context, coltype \\ "td") do
     row
     |> Enum.zip(aligns)
@@ -31,7 +32,7 @@ defmodule EarmarkParser.Ast.Renderer.TableRenderer do
 
   defp _render_col({col, align}, context, lnb, coltype) do
     context1 = Inline.convert(col, lnb, Context.clear_value(context))
-    {emit(coltype, context1.value |> Enum.reverse, _align_to_style(align)), context1} 
+    {emit(coltype, context1.value |> Enum.reverse(), _align_to_style(align)), context1}
   end
 
   defp _render_row({row, lnb}, context, aligns) do
@@ -40,8 +41,18 @@ defmodule EarmarkParser.Ast.Renderer.TableRenderer do
   end
 
   defp _align_to_style(align)
-  defp _align_to_style(:left), do: [{"style", "text-align: left;"}]
-  defp _align_to_style(:right), do: [{"style", "text-align: right;"}]
-  defp _align_to_style(:center), do: [{"style", "text-align: center;"}]
+
+  defp _align_to_style(:left) do
+    [{"style", "text-align: left;"}]
+  end
+
+  defp _align_to_style(:right) do
+    [{"style", "text-align: right;"}]
+  end
+
+  defp _align_to_style(:center) do
+    [{"style", "text-align: center;"}]
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/mix.exs b/mix.exs
index 2501baf..1c43e8f 100644
--- a/mix.exs
+++ b/mix.exs
@@ -59,9 +59,17 @@ defmodule EarmarkParser.MixProject do
     ]
   end
 
-  defp elixirc_paths(:test), do: ["lib", "test/support", "dev"]
-  defp elixirc_paths(:dev), do: ["lib", "bench", "dev"]
-  defp elixirc_paths(_), do: ["lib"]
+  defp elixirc_paths(:test) do
+    ["lib", "test/support", "dev"]
+  end
+
+  defp elixirc_paths(:dev) do
+    ["lib", "bench", "dev"]
+  end
+
+  defp elixirc_paths(_) do
+    ["lib"]
+  end
 
   @module "EarmarkParser"
   defp build_docs(_) do

From 2513e71503914b23b1055e552d28eb1d8d3ece22 Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 13:08:50 +0100
Subject: [PATCH 5/7] Road to #164

  This commit completes reformatting of all application files
  NEXT: test/

  - formatted files:
    - lib/earmark_parser/*.ex (main modules)
    - lib/earmark_parser/line_scanner/
    - lib/earmark_parser/parser/

  anterior commits:
    - lib/earmark_parser/block/
    - lib/earmark_parser/enum/
    - lib/earmark_parser/helpers/
    - mix.exs
    - lib/earmark_parser.ex
    - lib/earmark_parser/ast/**/*.ex
---
 2                                             |   0
 lib/earmark_parser/ast_renderer.ex            |  17 +-
 lib/earmark_parser/block/block_quote.ex       |   1 +
 lib/earmark_parser/block/code.ex              |   1 +
 lib/earmark_parser/block/fn_def.ex            |   1 +
 lib/earmark_parser/block/fn_list.ex           |   1 +
 lib/earmark_parser/block/heading.ex           |   1 +
 lib/earmark_parser/block/html.ex              |   1 +
 lib/earmark_parser/block/html_comment.ex      |   1 +
 lib/earmark_parser/block/html_oneline.ex      |   1 +
 lib/earmark_parser/block/ial.ex               |   1 +
 lib/earmark_parser/block/id_def.ex            |   1 +
 lib/earmark_parser/block/list.ex              |   1 +
 lib/earmark_parser/block/list_item.ex         |   1 +
 lib/earmark_parser/block/para.ex              |   1 +
 lib/earmark_parser/block/ruler.ex             |   1 +
 lib/earmark_parser/block/table.ex             |   1 +
 lib/earmark_parser/block/text.ex              |   1 +
 lib/earmark_parser/context.ex                 |  27 ++-
 lib/earmark_parser/enum/ext.ex                |  16 +-
 lib/earmark_parser/helpers.ex                 |  28 ++-
 lib/earmark_parser/helpers/ast_helpers.ex     |  55 ++++--
 lib/earmark_parser/helpers/attr_parser.ex     |  64 ++++---
 lib/earmark_parser/helpers/html_parser.ex     |  46 ++---
 lib/earmark_parser/helpers/leex_helpers.ex    |  31 ++--
 lib/earmark_parser/helpers/line_helpers.ex    |  44 +++--
 .../helpers/lookahead_helpers.ex              |  35 ++--
 .../helpers/pure_link_helpers.ex              |  10 +-
 lib/earmark_parser/helpers/reparse_helpers.ex |   9 +-
 lib/earmark_parser/helpers/string_helpers.ex  |   3 +-
 lib/earmark_parser/helpers/yecc_helpers.ex    |   9 +-
 lib/earmark_parser/line.ex                    |  50 ++++--
 lib/earmark_parser/line_scanner.ex            |  76 +++++---
 lib/earmark_parser/line_scanner/rgx.ex        |  93 +++++++---
 lib/earmark_parser/message.ex                 |  11 +-
 lib/earmark_parser/options.ex                 |  86 ++++-----
 lib/earmark_parser/parser.ex                  | 109 +++++++++---
 lib/earmark_parser/parser/footnote_parser.ex  |   4 +-
 lib/earmark_parser/parser/link_parser.ex      |  80 ++++++---
 lib/earmark_parser/parser/list_info.ex        |  14 +-
 lib/earmark_parser/parser/list_parser.ex      | 165 +++++++++++-------
 41 files changed, 719 insertions(+), 379 deletions(-)
 create mode 100644 2

diff --git a/2 b/2
new file mode 100644
index 0000000..e69de29
diff --git a/lib/earmark_parser/ast_renderer.ex b/lib/earmark_parser/ast_renderer.ex
index 6a51ade..d339ba2 100644
--- a/lib/earmark_parser/ast_renderer.ex
+++ b/lib/earmark_parser/ast_renderer.ex
@@ -17,7 +17,10 @@ defmodule EarmarkParser.AstRenderer do
   end
 
   defp _render(blocks, context, loose?)
-  defp _render([], context, _loose?), do: context
+
+  defp _render([], context, _loose?) do
+    context
+  end
 
   defp _render([block | blocks], context, loose?) do
     context1 = render_block(block, clear_value(context), loose?)
@@ -139,9 +142,11 @@ defmodule EarmarkParser.AstRenderer do
          _loose?
        ) do
     classes =
-      if language && language != "",
-        do: [code_classes(language, options.code_class_prefix)],
-        else: []
+      if language && language != "" do
+        [code_classes(language, options.code_class_prefix)]
+      else
+        []
+      end
 
     lines = render_code(block)
 
@@ -232,7 +237,9 @@ defmodule EarmarkParser.AstRenderer do
   # IDDef is ignored #
   ####################
 
-  defp render_block(%Block.IdDef{}, context, _loose?), do: context
+  defp render_block(%Block.IdDef{}, context, _loose?) do
+    context
+  end
 
   # Helpers
   # -------
diff --git a/lib/earmark_parser/block/block_quote.ex b/lib/earmark_parser/block/block_quote.ex
index e457e03..6cb001e 100644
--- a/lib/earmark_parser/block/block_quote.ex
+++ b/lib/earmark_parser/block/block_quote.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.BlockQuote do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, blocks: []
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/code.ex b/lib/earmark_parser/block/code.ex
index 495ed72..820dc36 100644
--- a/lib/earmark_parser/block/code.ex
+++ b/lib/earmark_parser/block/code.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Code do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, lines: [], language: nil
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/fn_def.ex b/lib/earmark_parser/block/fn_def.ex
index 8819b47..5d26767 100644
--- a/lib/earmark_parser/block/fn_def.ex
+++ b/lib/earmark_parser/block/fn_def.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.FnDef do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, id: nil, number: nil, blocks: []
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/fn_list.ex b/lib/earmark_parser/block/fn_list.ex
index 2b21881..173a0d2 100644
--- a/lib/earmark_parser/block/fn_list.ex
+++ b/lib/earmark_parser/block/fn_list.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.FnList do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: ".footnotes", blocks: []
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/heading.ex b/lib/earmark_parser/block/heading.ex
index 5a95464..2ef0405 100644
--- a/lib/earmark_parser/block/heading.ex
+++ b/lib/earmark_parser/block/heading.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Heading do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, content: nil, level: nil
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/html.ex b/lib/earmark_parser/block/html.ex
index d147b2b..ba01b0d 100644
--- a/lib/earmark_parser/block/html.ex
+++ b/lib/earmark_parser/block/html.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Html do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, html: [], tag: nil
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/html_comment.ex b/lib/earmark_parser/block/html_comment.ex
index bbc4c85..63dfd90 100644
--- a/lib/earmark_parser/block/html_comment.ex
+++ b/lib/earmark_parser/block/html_comment.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.HtmlComment do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, lines: []
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/html_oneline.ex b/lib/earmark_parser/block/html_oneline.ex
index d910d40..ef6a429 100644
--- a/lib/earmark_parser/block/html_oneline.ex
+++ b/lib/earmark_parser/block/html_oneline.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.HtmlOneline do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, html: ""
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/ial.ex b/lib/earmark_parser/block/ial.ex
index 42e4aba..5a397b0 100644
--- a/lib/earmark_parser/block/ial.ex
+++ b/lib/earmark_parser/block/ial.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Ial do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, content: nil, verbatim: ""
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/id_def.ex b/lib/earmark_parser/block/id_def.ex
index 51fc1e1..9e860cb 100644
--- a/lib/earmark_parser/block/id_def.ex
+++ b/lib/earmark_parser/block/id_def.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.IdDef do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, id: nil, url: nil, title: nil
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/list.ex b/lib/earmark_parser/block/list.ex
index 9b09930..e7e4f9a 100644
--- a/lib/earmark_parser/block/list.ex
+++ b/lib/earmark_parser/block/list.ex
@@ -14,4 +14,5 @@ defmodule EarmarkParser.Block.List do
             start: "",
             type: :ul
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/list_item.ex b/lib/earmark_parser/block/list_item.ex
index e575c75..de9d682 100644
--- a/lib/earmark_parser/block/list_item.ex
+++ b/lib/earmark_parser/block/list_item.ex
@@ -9,4 +9,5 @@ defmodule EarmarkParser.Block.ListItem do
             spaced?: true,
             type: :ul
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/para.ex b/lib/earmark_parser/block/para.ex
index ef015cb..4e35d7d 100644
--- a/lib/earmark_parser/block/para.ex
+++ b/lib/earmark_parser/block/para.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Para do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, lines: []
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/ruler.ex b/lib/earmark_parser/block/ruler.ex
index 75a4aa6..17c8a30 100644
--- a/lib/earmark_parser/block/ruler.ex
+++ b/lib/earmark_parser/block/ruler.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Ruler do
   @moduledoc false
   defstruct lnb: 0, annotation: nil, attrs: nil, type: nil
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/table.ex b/lib/earmark_parser/block/table.ex
index 33a4988..fb9b90b 100644
--- a/lib/earmark_parser/block/table.ex
+++ b/lib/earmark_parser/block/table.ex
@@ -6,4 +6,5 @@ defmodule EarmarkParser.Block.Table do
     %__MODULE__{alignments: Elixir.List.duplicate(:left, n)}
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/block/text.ex b/lib/earmark_parser/block/text.ex
index ac96550..a0a2d8d 100644
--- a/lib/earmark_parser/block/text.ex
+++ b/lib/earmark_parser/block/text.ex
@@ -2,4 +2,5 @@ defmodule EarmarkParser.Block.Text do
   @moduledoc false
   defstruct attrs: nil, lnb: 0, annotation: nil, line: ""
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/context.ex b/lib/earmark_parser/context.ex
index d57f865..ec139ac 100644
--- a/lib/earmark_parser/context.ex
+++ b/lib/earmark_parser/context.ex
@@ -52,29 +52,34 @@ defmodule EarmarkParser.Context do
          %__MODULE__{referenced_footnote_ids: new} = context2
        ) do
     context_ = _merge_messages(context1, context2)
-    %{context_| referenced_footnote_ids: MapSet.union(orig, new)}
+    %{context_ | referenced_footnote_ids: MapSet.union(orig, new)}
   end
 
   defp _merge_messages(context, context_or_messages)
+
   defp _merge_messages(context, %__MODULE__{options: %Options{messages: messages}}) do
     _merge_messages(context, messages)
   end
+
   defp _merge_messages(context, messages) do
-    %{context | options: %{context.options|messages: MapSet.union(context.options.messages, messages)}}
+    %{context | options: %{context.options | messages: MapSet.union(context.options.messages, messages)}}
   end
 
+  defp _prepend(ctxt, []) do
+    ctxt
+  end
 
-  defp _prepend(ctxt, []), do: ctxt
-
-  defp _prepend(%{value: value} = ctxt, {:comment, _, _, _} = ct),
-    do: %{ctxt | value: [ct | value]}
+  defp _prepend(%{value: value} = ctxt, {:comment, _, _, _} = ct) do
+    %{ctxt | value: [ct | value]}
+  end
 
   defp _prepend(%{value: value} = ctxt, tuple) when is_tuple(tuple) do
     %{ctxt | value: [tuple | value] |> List.flatten()}
   end
 
-  defp _prepend(%{value: value} = ctxt, list) when is_list(list),
-    do: %{ctxt | value: List.flatten(list ++ value)}
+  defp _prepend(%{value: value} = ctxt, list) when is_list(list) do
+    %{ctxt | value: List.flatten(list ++ value)}
+  end
 
   @doc """
   Convenience method to prepend to the value list
@@ -83,7 +88,9 @@ defmodule EarmarkParser.Context do
     %{ctx | value: value}
   end
 
-  def clear_value(%__MODULE__{} = ctx), do: %{ctx | value: []}
+  def clear_value(%__MODULE__{} = ctx) do
+    %{ctx | value: []}
+  end
 
   # this is called by the command line processor to update
   # the inline-specific rules in light of any options
@@ -109,12 +116,14 @@ defmodule EarmarkParser.Context do
       else
         ""
       end
+
     math =
       if options.math do
         "$"
       else
         ""
       end
+
     rule_updates =
       if options.gfm do
         rules = [
diff --git a/lib/earmark_parser/enum/ext.ex b/lib/earmark_parser/enum/ext.ex
index b23ffc1..9a2c405 100644
--- a/lib/earmark_parser/enum/ext.ex
+++ b/lib/earmark_parser/enum/ext.ex
@@ -21,10 +21,12 @@ defmodule EarmarkParser.Enum.Ext do
   penalty concerning the complexity of the reducer function
   """
   def reduce_with_end(collection, initial_acc, reducer_fn)
+
   def reduce_with_end([], acc, reducer_fn) do
     reducer_fn.(:end, acc)
   end
-  def reduce_with_end([ele|rest], acc, reducer_fn) do
+
+  def reduce_with_end([ele | rest], acc, reducer_fn) do
     reduce_with_end(rest, reducer_fn.({:element, ele}, acc), reducer_fn)
   end
 
@@ -45,11 +47,17 @@ defmodule EarmarkParser.Enum.Ext do
 
   # Helpers {{{
   defp _reverse_map_reduce(list, acc, result, fun)
-  defp _reverse_map_reduce([], acc, result, _fun), do: {result, acc}
-  defp _reverse_map_reduce([fst|rst], acc, result, fun) do
+
+  defp _reverse_map_reduce([], acc, result, _fun) do
+    {result, acc}
+  end
+
+  defp _reverse_map_reduce([fst | rst], acc, result, fun) do
     {new_ele, new_acc} = fun.(fst, acc)
-    _reverse_map_reduce(rst, new_acc, [new_ele|result], fun)
+    _reverse_map_reduce(rst, new_acc, [new_ele | result], fun)
   end
+
   # }}}
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers.ex b/lib/earmark_parser/helpers.ex
index 8ecdb33..a075102 100644
--- a/lib/earmark_parser/helpers.ex
+++ b/lib/earmark_parser/helpers.ex
@@ -58,13 +58,25 @@ defmodule EarmarkParser.Helpers do
     end
   end
 
-  defp _trim_line({line, annot}),
-    do: {line |> String.trim_trailing("\n") |> String.trim_trailing("\r"), annot}
+  defp _trim_line({line, annot}) do
+    {line |> String.trim_trailing("\n") |> String.trim_trailing("\r"), annot}
+  end
 
-  defp pad(1), do: " "
-  defp pad(2), do: "  "
-  defp pad(3), do: "   "
-  defp pad(4), do: "    "
+  defp pad(1) do
+    " "
+  end
+
+  defp pad(2) do
+    "  "
+  end
+
+  defp pad(3) do
+    "   "
+  end
+
+  defp pad(4) do
+    "    "
+  end
 
   @doc """
   `Regex.replace` with the arguments in the correct order
@@ -80,7 +92,9 @@ defmodule EarmarkParser.Helpers do
    convert non-entity ampersands.
   """
 
-  def escape(html), do: _escape(Regex.replace(~r{&(?!#?\w+;)}, html, "&amp;"))
+  def escape(html) do
+    _escape(Regex.replace(~r{&(?!#?\w+;)}, html, "&amp;"))
+  end
 
   defp _escape(html) do
     html
diff --git a/lib/earmark_parser/helpers/ast_helpers.ex b/lib/earmark_parser/helpers/ast_helpers.ex
index c9cf30d..0686279 100644
--- a/lib/earmark_parser/helpers/ast_helpers.ex
+++ b/lib/earmark_parser/helpers/ast_helpers.ex
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Helpers.AstHelpers do
-
   @moduledoc false
 
   import EarmarkParser.Ast.Emitter
@@ -9,29 +8,41 @@ defmodule EarmarkParser.Helpers.AstHelpers do
 
   @doc false
   def annotate(node, from_block)
-  def annotate(node, %{annotation: nil}), do: node
-  def annotate({tag, atts, children, meta}, %{annotation: annotation}),
-    do: {tag, atts, children, Map.put(meta, :annotation, annotation)}
-  def annotate({tag, atts, children, meta}, annotation),
-    do: {tag, atts, children, Map.put(meta, :annotation, annotation)}
+
+  def annotate(node, %{annotation: nil}) do
+    node
+  end
+
+  def annotate({tag, atts, children, meta}, %{annotation: annotation}) do
+    {tag, atts, children, Map.put(meta, :annotation, annotation)}
+  end
+
+  def annotate({tag, atts, children, meta}, annotation) do
+    {tag, atts, children, Map.put(meta, :annotation, annotation)}
+  end
 
   @doc false
   def attrs_to_string_keys(key_value_pair)
+
   def attrs_to_string_keys({k, vs}) when is_list(vs) do
     {to_string(k), Enum.join(vs, " ")}
   end
+
   def attrs_to_string_keys({k, vs}) do
-    {to_string(k),to_string(vs)}
+    {to_string(k), to_string(vs)}
   end
 
   @doc false
   def augment_tag_with_ial(tags, ial, src)
-  def augment_tag_with_ial([{t, a, c, m}|tags], atts, _src) do
-    [{t, merge_attrs(a, atts), c, m}|tags]
+
+  def augment_tag_with_ial([{t, a, c, m} | tags], atts, _src) do
+    [{t, merge_attrs(a, atts), c, m} | tags]
   end
+
   def augment_tag_with_ial([], _atts, _src) do
     []
   end
+
   def augment_tag_with_ial([any], _atts, src) do
     [any <> src]
   end
@@ -41,7 +52,8 @@ defmodule EarmarkParser.Helpers.AstHelpers do
     classes =
       ["" | String.split(prefix || "")]
       |> Enum.map(fn pfx -> "#{pfx}#{language}" end)
-      {"class", classes |> Enum.join(" ")}
+
+    {"class", classes |> Enum.join(" ")}
   end
 
   @doc false
@@ -84,7 +96,6 @@ defmodule EarmarkParser.Helpers.AstHelpers do
     emit("a", text, href: _encode(url))
   end
 
-
   ##############################################
   # add attributes to the outer tag in a block #
   ##############################################
@@ -94,15 +105,24 @@ defmodule EarmarkParser.Helpers.AstHelpers do
     |> String.split(~r<%[\da-f]{2}>i, include_captures: true)
     |> Enum.chunk_every(2)
     |> Enum.map(&_encode_chunk/1)
-    |> IO.chardata_to_string
+    |> IO.chardata_to_string()
+  end
+
+  defp _encode_chunk([encodable, verbatim]) do
+    [URI.encode(encodable), verbatim]
   end
 
-  defp _encode_chunk([encodable, verbatim]), do: [URI.encode(encodable), verbatim]
-  defp _encode_chunk([encodable]), do: URI.encode(encodable)
+  defp _encode_chunk([encodable]) do
+    URI.encode(encodable)
+  end
 
   @doc false
   def merge_attrs(maybe_atts, new_atts)
-  def merge_attrs(nil, new_atts), do: new_atts
+
+  def merge_attrs(nil, new_atts) do
+    new_atts
+  end
+
   def merge_attrs(atts, new) when is_list(atts) do
     atts
     |> Enum.into(%{})
@@ -117,13 +137,14 @@ defmodule EarmarkParser.Helpers.AstHelpers do
   end
 
   defp _value_merger(key, val1, val2)
+
   defp _value_merger(_, val1, val2) when is_list(val1) do
     val1 ++ [val2]
   end
+
   defp _value_merger(_, val1, val2) do
     [val1, val2]
   end
-
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/attr_parser.ex b/lib/earmark_parser/helpers/attr_parser.ex
index 398833f..64fd722 100644
--- a/lib/earmark_parser/helpers/attr_parser.ex
+++ b/lib/earmark_parser/helpers/attr_parser.ex
@@ -1,61 +1,71 @@
 defmodule EarmarkParser.Helpers.AttrParser do
-
   @moduledoc false
 
-  import EarmarkParser.Helpers.StringHelpers, only: [ behead: 2 ]
+  import EarmarkParser.Helpers.StringHelpers, only: [behead: 2]
   import EarmarkParser.Message, only: [add_message: 2]
 
-
-  @type errorlist :: list(String.t)
+  @type errorlist :: list(String.t())
 
   def parse_attrs(context, attrs, lnb) do
-    { attrs, errors } = _parse_attrs(%{}, attrs, [], lnb)
-    { add_errors(context, errors, lnb), attrs }
+    {attrs, errors} = _parse_attrs(%{}, attrs, [], lnb)
+    {add_errors(context, errors, lnb), attrs}
   end
 
   defp _parse_attrs(dict, attrs, errors, lnb) do
     cond do
-      Regex.match?(~r{^\s*$}, attrs) -> {dict, errors}
+      Regex.match?(~r{^\s*$}, attrs) ->
+        {dict, errors}
 
       match = Regex.run(~r{^\.(\S+)\s*}, attrs) ->
-        [ leader, class ] = match
-          Map.update(dict, "class", [ class ], &[ class | &1])
-          |> _parse_attrs(behead(attrs, leader), errors, lnb)
+        [leader, class] = match
+
+        Map.update(dict, "class", [class], &[class | &1])
+        |> _parse_attrs(behead(attrs, leader), errors, lnb)
 
       match = Regex.run(~r{^\#(\S+)\s*}, attrs) ->
-        [ leader, id ] = match
-          Map.update(dict, "id", [ id ], &[ id | &1])
-          |> _parse_attrs(behead(attrs, leader), errors, lnb)
+        [leader, id] = match
+
+        Map.update(dict, "id", [id], &[id | &1])
+        |> _parse_attrs(behead(attrs, leader), errors, lnb)
 
       # Might we being running into escape issues here too?
-      match = Regex.run(~r{^(\S+)=\'([^\']*)'\s*}, attrs) -> #'
-      [ leader, name, value ] = match
-        Map.update(dict, name, [ value ], &[ value | &1])
+      # '
+      match = Regex.run(~r{^(\S+)=\'([^\']*)'\s*}, attrs) ->
+        [leader, name, value] = match
+
+        Map.update(dict, name, [value], &[value | &1])
         |> _parse_attrs(behead(attrs, leader), errors, lnb)
 
       # Might we being running into escape issues here too?
-      match = Regex.run(~r{^(\S+)=\"([^\"]*)"\s*}, attrs) -> #"
-      [ leader, name, value ] = match
-        Map.update(dict, name, [ value ], &[ value | &1])
+      # "
+      match = Regex.run(~r{^(\S+)=\"([^\"]*)"\s*}, attrs) ->
+        [leader, name, value] = match
+
+        Map.update(dict, name, [value], &[value | &1])
         |> _parse_attrs(behead(attrs, leader), errors, lnb)
 
       match = Regex.run(~r{^(\S+)=(\S+)\s*}, attrs) ->
-        [ leader, name, value ] = match
-          Map.update(dict, name, [ value ], &[ value | &1])
-          |> _parse_attrs(behead(attrs, leader), errors, lnb)
+        [leader, name, value] = match
+
+        Map.update(dict, name, [value], &[value | &1])
+        |> _parse_attrs(behead(attrs, leader), errors, lnb)
 
       match = Regex.run(~r{^(\S+)\s*(.*)}, attrs) ->
-        [ _, incorrect, rest  ] = match
-        _parse_attrs(dict, rest, [ incorrect | errors ], lnb)
+        [_, incorrect, rest] = match
+        _parse_attrs(dict, rest, [incorrect | errors], lnb)
 
       :otherwise ->
-        {dict, [attrs | errors ]}
+        {dict, [attrs | errors]}
     end
   end
 
-  defp add_errors(context, [], _lnb), do: context
-  defp add_errors(context, errors, lnb), do: add_message(context, {:warning, lnb, "Illegal attributes #{inspect errors} ignored in IAL"})
+  defp add_errors(context, [], _lnb) do
+    context
+  end
 
+  defp add_errors(context, errors, lnb) do
+    add_message(context, {:warning, lnb, "Illegal attributes #{inspect(errors)} ignored in IAL"})
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/html_parser.ex b/lib/earmark_parser/helpers/html_parser.ex
index 23a05fc..d210ca3 100644
--- a/lib/earmark_parser/helpers/html_parser.ex
+++ b/lib/earmark_parser/helpers/html_parser.ex
@@ -1,17 +1,17 @@
 defmodule EarmarkParser.Helpers.HtmlParser do
-
   @moduledoc false
 
   import EarmarkParser.Helpers.StringHelpers, only: [behead: 2]
   import EarmarkParser.LineScanner, only: [void_tag?: 1]
 
   def parse_html(lines)
-  def parse_html([tag_line|rest]) do
+
+  def parse_html([tag_line | rest]) do
     case _parse_tag(tag_line) do
-      { :ok, tag, "" }      -> [_parse_rest(rest, tag, [])]
-      { :ok, tag, suffix }  -> [_parse_rest(rest, tag, [suffix])]
-      { :ext, tag, "" }     -> [_parse_rest(rest, tag, [])]
-      { :ext, tag, suffix } -> [_parse_rest(rest, tag, []), [suffix]]
+      {:ok, tag, ""} -> [_parse_rest(rest, tag, [])]
+      {:ok, tag, suffix} -> [_parse_rest(rest, tag, [suffix])]
+      {:ext, tag, ""} -> [_parse_rest(rest, tag, [])]
+      {:ext, tag, suffix} -> [_parse_rest(rest, tag, []), [suffix]]
     end
   end
 
@@ -22,14 +22,16 @@ defmodule EarmarkParser.Helpers.HtmlParser do
     quoted_attr = ~r{\A ([-\w]+) \s* = \s* (["']) (.*?) \2 \s*}x
 
     case Regex.run(quoted_attr, string) do
-      [all, name, _delim, value] -> _parse_atts(behead(string, all), tag, [{name, value}|atts])
+      [all, name, _delim, value] ->
+        _parse_atts(behead(string, all), tag, [{name, value} | atts])
+
       _ ->
         unquoted_attr = ~r{\A ([-\w]+) (?: \s* = \s* ([^&\s>]*))? \s*}x
 
         case Regex.run(unquoted_attr, string) do
-             [all, name, value] -> _parse_atts(behead(string, all), tag, [{name, value}|atts])
-             [all, name]        -> _parse_atts(behead(string, all), tag, [{name, name}|atts])
-             _                  -> _parse_tag_tail(string, tag, atts)
+          [all, name, value] -> _parse_atts(behead(string, all), tag, [{name, value} | atts])
+          [all, name] -> _parse_atts(behead(string, all), tag, [{name, name} | atts])
+          _ -> _parse_tag_tail(string, tag, atts)
         end
     end
   end
@@ -37,6 +39,7 @@ defmodule EarmarkParser.Helpers.HtmlParser do
   # Are leading and trailing "-"s ok?
   defp _parse_tag(string) do
     tag_head = ~r{\A \s* <([-\w]+) \s*}x
+
     case Regex.run(tag_head, string) do
       [all, tag] -> _parse_atts(behead(string, all), tag, [])
     end
@@ -44,8 +47,9 @@ defmodule EarmarkParser.Helpers.HtmlParser do
 
   defp _parse_tag_tail(string, tag, atts) do
     tag_tail = ~r{\A .*? (/?)> \s* (.*) \z}x
+
     case Regex.run(tag_tail, string) do
-      [_, closing, suffix]  ->
+      [_, closing, suffix] ->
         suffix1 = String.replace(suffix, ~r{\s*</#{tag}>.*}, "")
         _close_tag_tail(tag, atts, closing != "", suffix1)
     end
@@ -53,9 +57,9 @@ defmodule EarmarkParser.Helpers.HtmlParser do
 
   defp _close_tag_tail(tag, atts, closing?, suffix) do
     if closing? || void_tag?(tag) do
-      {:ext, {tag, Enum.reverse(atts)}, suffix }
+      {:ext, {tag, Enum.reverse(atts)}, suffix}
     else
-      {:ok, {tag, Enum.reverse(atts)}, suffix }
+      {:ok, {tag, Enum.reverse(atts)}, suffix}
     end
   end
 
@@ -64,26 +68,28 @@ defmodule EarmarkParser.Helpers.HtmlParser do
 
   @verbatim %{verbatim: true}
   defp _parse_rest(rest, tag_tpl, lines)
+
   defp _parse_rest([], tag_tpl, lines) do
     _tag_append(tag_tpl, lines)
   end
-  defp _parse_rest([last_line], {tag, _}=tag_tpl, lines) do
+
+  defp _parse_rest([last_line], {tag, _} = tag_tpl, lines) do
     case Regex.run(~r{\A\s*</#{tag}>\s*(.*)}, last_line) do
-      nil         -> _tag_append(tag_tpl, [last_line|lines])
-      [_, ""]     -> _tag_append(tag_tpl, lines)
+      nil -> _tag_append(tag_tpl, [last_line | lines])
+      [_, ""] -> _tag_append(tag_tpl, lines)
       [_, suffix] -> [_tag_append(tag_tpl, lines), suffix]
     end
   end
-  defp _parse_rest([inner_line|rest], tag_tpl, lines) do
-    _parse_rest(rest, tag_tpl, [inner_line|lines])
-  end
 
+  defp _parse_rest([inner_line | rest], tag_tpl, lines) do
+    _parse_rest(rest, tag_tpl, [inner_line | lines])
+  end
 
   defp _tag_append(tag_tpl, lines) do
     tag_tpl
     |> Tuple.insert_at(2, Enum.reverse(lines))
     |> Tuple.insert_at(3, @verbatim)
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/leex_helpers.ex b/lib/earmark_parser/helpers/leex_helpers.ex
index 12c06f2..7043f6f 100644
--- a/lib/earmark_parser/helpers/leex_helpers.ex
+++ b/lib/earmark_parser/helpers/leex_helpers.ex
@@ -1,31 +1,36 @@
 defmodule EarmarkParser.Helpers.LeexHelpers do
-
   @moduledoc false
   @doc """
     Allows to lex an Elixir string with a leex lexer and returns
     the tokens as needed for a yecc parser.
   """
-  def lex text, with: lexer do
+  def lex(text, with: lexer) do
     case text
-      |> String.to_charlist()
-      |> lexer.string() do
-        {:ok, tokens, _} -> tokens
-      end
+         |> String.to_charlist()
+         |> lexer.string() do
+      {:ok, tokens, _} -> tokens
+    end
   end
 
-  def tokenize line, with: lexer do
+  def tokenize(line, with: lexer) do
     {:ok, tokens, _} =
-    line
-    |> to_charlist()
-    |> lexer.string()
-    elixirize_tokens(tokens,[])
+      line
+      |> to_charlist()
+      |> lexer.string()
+
+    elixirize_tokens(tokens, [])
     |> Enum.reverse()
   end
 
   defp elixirize_tokens(tokens, rest)
-  defp elixirize_tokens([], result), do: result
-  defp elixirize_tokens([{token, _, text}|rest], result), do: elixirize_tokens(rest, [{token,to_string(text)}|result])
 
+  defp elixirize_tokens([], result) do
+    result
+  end
+
+  defp elixirize_tokens([{token, _, text} | rest], result) do
+    elixirize_tokens(rest, [{token, to_string(text)} | result])
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/line_helpers.ex b/lib/earmark_parser/helpers/line_helpers.ex
index 0f5398f..7fa8d88 100644
--- a/lib/earmark_parser/helpers/line_helpers.ex
+++ b/lib/earmark_parser/helpers/line_helpers.ex
@@ -1,17 +1,31 @@
 defmodule EarmarkParser.Helpers.LineHelpers do
-
   @moduledoc false
 
   alias EarmarkParser.Line
 
-  def blank?(%Line.Blank{}),   do: true
-  def blank?(_),               do: false
+  def blank?(%Line.Blank{}) do
+    true
+  end
+
+  def blank?(_) do
+    false
+  end
+
+  def blockquote_or_text?(%Line.BlockQuote{}) do
+    true
+  end
 
-  def blockquote_or_text?(%Line.BlockQuote{}), do: true
-  def blockquote_or_text?(struct),             do: text?(struct)
+  def blockquote_or_text?(struct) do
+    text?(struct)
+  end
 
-  def indent_or_blank?(%Line.Indent{}), do: true
-  def indent_or_blank?(line),           do: blank?(line)
+  def indent_or_blank?(%Line.Indent{}) do
+    true
+  end
+
+  def indent_or_blank?(line) do
+    blank?(line)
+  end
 
   # Gruber's tests have
   #
@@ -27,10 +41,18 @@ defmodule EarmarkParser.Helpers.LineHelpers do
   #
   # I think the second is a better interpretation, so I commented
   # out the 2nd match below.
-  def text?(%Line.Text{}),      do: true
-  def text?(%Line.TableLine{}), do: true
-#  def text?(%Line.ListItem{}), do: true
-  def text?(_),                 do: false
+  def text?(%Line.Text{}) do
+    true
+  end
+
+  def text?(%Line.TableLine{}) do
+    true
+  end
 
+  #  def text?(%Line.ListItem{}), do: true
+  def text?(_) do
+    false
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/lookahead_helpers.ex b/lib/earmark_parser/helpers/lookahead_helpers.ex
index 86243d3..7b66c0c 100644
--- a/lib/earmark_parser/helpers/lookahead_helpers.ex
+++ b/lib/earmark_parser/helpers/lookahead_helpers.ex
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Helpers.LookaheadHelpers do
-
   @moduledoc false
 
   import EarmarkParser.Helpers.LeexHelpers
@@ -41,22 +40,31 @@ defmodule EarmarkParser.Helpers.LookaheadHelpers do
   defp has_still_opening_backtix(tokens, opened_so_far)
 
   # Empty, done, but take care of tangeling escape (\)
-  defp has_still_opening_backtix([], :force_outside), do: nil
-  defp has_still_opening_backtix([], open), do: open
+  defp has_still_opening_backtix([], :force_outside) do
+    nil
+  end
+
+  defp has_still_opening_backtix([], open) do
+    open
+  end
 
   # Outside state, represented by nil
-  defp has_still_opening_backtix([{:other, _} | rest], nil),
-    do: has_still_opening_backtix(rest, nil)
+  defp has_still_opening_backtix([{:other, _} | rest], nil) do
+    has_still_opening_backtix(rest, nil)
+  end
 
-  defp has_still_opening_backtix([{:backtix, btx} | rest], nil),
-    do: has_still_opening_backtix(rest, {:new, btx})
+  defp has_still_opening_backtix([{:backtix, btx} | rest], nil) do
+    has_still_opening_backtix(rest, {:new, btx})
+  end
 
-  defp has_still_opening_backtix([{:escape, _} | rest], nil),
-    do: has_still_opening_backtix(rest, :force_outside)
+  defp has_still_opening_backtix([{:escape, _} | rest], nil) do
+    has_still_opening_backtix(rest, :force_outside)
+  end
 
   # Next state forced outside, represented by :force_outside
-  defp has_still_opening_backtix([_ | rest], :force_outside),
-    do: has_still_opening_backtix(rest, nil)
+  defp has_still_opening_backtix([_ | rest], :force_outside) do
+    has_still_opening_backtix(rest, nil)
+  end
 
   # Inside state, represented by { :old | :new, btx }
   defp has_still_opening_backtix([{:backtix, btx} | rest], open = {_, openedbtx}) do
@@ -67,8 +75,9 @@ defmodule EarmarkParser.Helpers.LookaheadHelpers do
     end
   end
 
-  defp has_still_opening_backtix([_ | rest], open = {_, _}),
-    do: has_still_opening_backtix(rest, open)
+  defp has_still_opening_backtix([_ | rest], open = {_, _}) do
+    has_still_opening_backtix(rest, open)
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/pure_link_helpers.ex b/lib/earmark_parser/helpers/pure_link_helpers.ex
index e30332f..8064b86 100644
--- a/lib/earmark_parser/helpers/pure_link_helpers.ex
+++ b/lib/earmark_parser/helpers/pure_link_helpers.ex
@@ -56,9 +56,13 @@ defmodule EarmarkParser.Helpers.PureLinkHelpers do
   # balance parens and return unbalanced *trailing* paren count
   defp balance_parens(reverse_text, trailing_count, non_trailing_count \\ 0)
 
-  defp balance_parens(<<>>, trailing_paren_count, _non_trailing_count), do: trailing_paren_count
+  defp balance_parens(<<>>, trailing_paren_count, _non_trailing_count) do
+    trailing_paren_count
+  end
 
-  defp balance_parens(_reverse_text, 0, _non_trailing_count), do: 0
+  defp balance_parens(_reverse_text, 0, _non_trailing_count) do
+    0
+  end
 
   defp balance_parens(")" <> rest, trailing_paren_count, non_trailing_count) do
     balance_parens(rest, trailing_paren_count, non_trailing_count + 1)
@@ -73,7 +77,7 @@ defmodule EarmarkParser.Helpers.PureLinkHelpers do
     end
   end
 
-  defp balance_parens(<<_::utf8,rest::binary>>, trailing_paren_count, non_trailing_count) do
+  defp balance_parens(<<_::utf8, rest::binary>>, trailing_paren_count, non_trailing_count) do
     balance_parens(rest, trailing_paren_count, non_trailing_count)
   end
 end
diff --git a/lib/earmark_parser/helpers/reparse_helpers.ex b/lib/earmark_parser/helpers/reparse_helpers.ex
index d91f0e4..2cd7fca 100644
--- a/lib/earmark_parser/helpers/reparse_helpers.ex
+++ b/lib/earmark_parser/helpers/reparse_helpers.ex
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Helpers.ReparseHelpers do
-
   @moduledoc false
 
   alias EarmarkParser.Line
@@ -10,13 +9,15 @@ defmodule EarmarkParser.Helpers.ReparseHelpers do
   """
   # Add additional spaces for any indentation past level 1
   def properly_indent(%Line.Indent{level: level, content: content}, target_level)
-  when level == target_level do
+      when level == target_level do
     content
   end
+
   def properly_indent(%Line.Indent{level: level, content: content}, target_level)
-  when level > target_level do
-    String.duplicate("    ", level-target_level) <> content
+      when level > target_level do
+    String.duplicate("    ", level - target_level) <> content
   end
+
   def properly_indent(line, _) do
     line.content
   end
diff --git a/lib/earmark_parser/helpers/string_helpers.ex b/lib/earmark_parser/helpers/string_helpers.ex
index 4b3b5a8..6795e24 100644
--- a/lib/earmark_parser/helpers/string_helpers.ex
+++ b/lib/earmark_parser/helpers/string_helpers.ex
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Helpers.StringHelpers do
-
   @moduledoc false
 
   @doc """
@@ -13,6 +12,6 @@ defmodule EarmarkParser.Helpers.StringHelpers do
   def behead(str, leading_string) do
     behead(str, String.length(leading_string))
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/helpers/yecc_helpers.ex b/lib/earmark_parser/helpers/yecc_helpers.ex
index 1d232dd..baa103d 100644
--- a/lib/earmark_parser/helpers/yecc_helpers.ex
+++ b/lib/earmark_parser/helpers/yecc_helpers.ex
@@ -1,16 +1,15 @@
 defmodule EarmarkParser.Helpers.YeccHelpers do
-
   @moduledoc false
   import EarmarkParser.Helpers.LeexHelpers, only: [lex: 2]
 
-  def parse!( text, lexer: lexer, parser: parser ) do
+  def parse!(text, lexer: lexer, parser: parser) do
     case parse(text, lexer: lexer, parser: parser) do
-        {:ok, ast}  -> ast
-        {:error, _} -> nil
+      {:ok, ast} -> ast
+      {:error, _} -> nil
     end
   end
 
-  def parse( text, lexer: lexer, parser: parser ) do
+  def parse(text, lexer: lexer, parser: parser) do
     with tokens <- lex(text, with: lexer) do
       parser.parse(tokens)
     end
diff --git a/lib/earmark_parser/line.ex b/lib/earmark_parser/line.ex
index 54ce40b..df4d142 100644
--- a/lib/earmark_parser/line.ex
+++ b/lib/earmark_parser/line.ex
@@ -1,66 +1,67 @@
 defmodule EarmarkParser.Line do
-
   @moduledoc false
 
-defmodule Blank  do
+  defmodule Blank do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, content: "")
   end
-defmodule Ruler  do
+
+  defmodule Ruler do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, type: "- or * or _")
   end
 
-defmodule Heading  do
+  defmodule Heading do
     @moduledoc false
     defstruct(annotation: nil, ial: nil, lnb: 0, line: "", indent: -1, level: 1, content: "inline text")
   end
 
-defmodule BlockQuote  do
+  defmodule BlockQuote do
     @moduledoc false
     defstruct(annotation: nil, ial: nil, lnb: 0, line: "", indent: -1, content: "text")
   end
 
-defmodule Indent  do
+  defmodule Indent do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, level: 0, content: "text")
   end
 
-defmodule Fence  do
+  defmodule Fence do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, delimiter: "~ or `", language: nil)
   end
 
-defmodule HtmlOpenTag  do
+  defmodule HtmlOpenTag do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, tag: "", content: "")
   end
 
-defmodule HtmlCloseTag  do
+  defmodule HtmlCloseTag do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, tag: "<... to eol")
   end
-defmodule HtmlComment  do
+
+  defmodule HtmlComment do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, complete: true)
   end
 
-defmodule HtmlOneLine  do
+  defmodule HtmlOneLine do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, tag: "", content: "")
   end
 
-defmodule IdDef  do
+  defmodule IdDef do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, id: nil, url: nil, title: nil)
   end
 
-defmodule FnDef  do
+  defmodule FnDef do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, id: nil, content: "text")
   end
 
-defmodule ListItem do
+  defmodule ListItem do
     @moduledoc false
     defstruct(
       annotation: nil,
@@ -76,23 +77,34 @@ defmodule ListItem do
     )
   end
 
-defmodule SetextUnderlineHeading  do
+  defmodule SetextUnderlineHeading do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, level: 1)
   end
 
-defmodule TableLine  do
+  defmodule TableLine do
     @moduledoc false
-    defstruct(annotation: nil, lnb: 0, line: "", indent: -1, content: "", columns: 0, is_header: false, needs_header: false)
+    defstruct(
+      annotation: nil,
+      lnb: 0,
+      line: "",
+      indent: -1,
+      content: "",
+      columns: 0,
+      is_header: false,
+      needs_header: false
+    )
   end
 
-defmodule Ial  do
+  defmodule Ial do
     @moduledoc false
     defstruct(annotation: nil, ial: nil, lnb: 0, line: "", indent: -1, attrs: "", verbatim: "")
   end
-defmodule Text  do
+
+  defmodule Text do
     @moduledoc false
     defstruct(annotation: nil, lnb: 0, line: "", indent: -1, content: "")
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/line_scanner.ex b/lib/earmark_parser/line_scanner.ex
index c5a56a9..0ac8760 100644
--- a/lib/earmark_parser/line_scanner.ex
+++ b/lib/earmark_parser/line_scanner.ex
@@ -7,7 +7,9 @@ defmodule EarmarkParser.LineScanner do
   # This is the re that matches the ridiculous "[id]: url title" syntax
 
   @doc false
-  def void_tag?(tag), do: Regex.match?(void_tag_rgx(), "<#{tag}>")
+  def void_tag?(tag) do
+    Regex.match?(void_tag_rgx(), "<#{tag}>")
+  end
 
   def scan_lines(lines, options, recursive) do
     _lines_with_count(lines, options.line - 1)
@@ -15,8 +17,9 @@ defmodule EarmarkParser.LineScanner do
   end
 
   def type_of(line, recursive)
-      when is_boolean(recursive),
-      do: type_of(line, %Options{}, recursive)
+      when is_boolean(recursive) do
+    type_of(line, %Options{}, recursive)
+  end
 
   def type_of({line, lnb}, options = %Options{annotations: annotations}, recursive)
       when is_binary(line) do
@@ -112,7 +115,14 @@ defmodule EarmarkParser.LineScanner do
 
       match = lt_four? && id_def_matches(content) ->
         [_, id, url | title] = match
-        title = if(Enum.empty?(title), do: "", else: hd(title))
+
+        title =
+          if(Enum.empty?(title)) do
+            ""
+          else
+            hd(title)
+          end
+
         %Line.IdDef{id: id, url: url, title: title, indent: indent, line: line}
 
       match = options.footnotes && footnote_def_matches(line) ->
@@ -153,7 +163,7 @@ defmodule EarmarkParser.LineScanner do
         }
 
       line
-      |> String.replace(table_header_rgx(),  "")
+      |> String.replace(table_header_rgx(), "")
       |> String.match?(table_first_column_rgx()) ->
         columns = _split_table_columns(line)
 
@@ -180,7 +190,14 @@ defmodule EarmarkParser.LineScanner do
 
       match = set_ext_underline_matches(line) ->
         [_, type] = match
-        level = if(String.starts_with?(type, "="), do: 1, else: 2)
+
+        level =
+          if(String.starts_with?(type, "=")) do
+            1
+          else
+            2
+          end
+
         %Line.SetextUnderlineHeading{level: level, indent: 0, line: line}
 
       match = lt_four? && ial_matches(content) ->
@@ -192,17 +209,24 @@ defmodule EarmarkParser.LineScanner do
     end
   end
 
-  defp _attribute_escape(string),
-    do:
-      string
-      |> String.replace("&", "&amp;")
-      |> String.replace("<", "&lt;")
+  defp _attribute_escape(string) do
+    string
+    |> String.replace("&", "&amp;")
+    |> String.replace("<", "&lt;")
+  end
 
   defp _create_list_item(match, indent, line)
 
   defp _create_list_item([_, bullet, spaces, text], indent, line) do
     sl = byte_size(spaces)
-    sl1 = if sl > 3, do: 1, else: sl + 1
+
+    sl1 =
+      if sl > 3 do
+        1
+      else
+        sl + 1
+      end
+
     sl2 = sl1 + byte_size(bullet)
 
     %Line.ListItem{
@@ -220,17 +244,21 @@ defmodule EarmarkParser.LineScanner do
     _create_text(line, content, indent)
   end
 
-  defp _create_text(line, "", indent),
-    do: %Line.Blank{indent: indent, line: line}
+  defp _create_text(line, "", indent) do
+    %Line.Blank{indent: indent, line: line}
+  end
 
-  defp _create_text(line, content, indent),
-    do: %Line.Text{content: content, indent: indent, line: line}
+  defp _create_text(line, content, indent) do
+    %Line.Text{content: content, indent: indent, line: line}
+  end
 
-  defp _count_indent(<<space, rest::binary>>, indent) when space in [?\s, ?\t],
-    do: _count_indent(rest, indent + 1)
+  defp _count_indent(<<space, rest::binary>>, indent) when space in [?\s, ?\t] do
+    _count_indent(rest, indent + 1)
+  end
 
-  defp _count_indent(rest, indent),
-    do: {rest, indent}
+  defp _count_indent(rest, indent) do
+    {rest, indent}
+  end
 
   defp _lines_with_count(lines, offset) do
     Enum.zip(lines, offset..(offset + Enum.count(lines)))
@@ -250,9 +278,13 @@ defmodule EarmarkParser.LineScanner do
     end
   end
 
-  defp _with_lookahead([], _options, _recursive), do: []
+  defp _with_lookahead([], _options, _recursive) do
+    []
+  end
 
-  defp _lookahead_until_match([], _, _, _), do: []
+  defp _lookahead_until_match([], _, _, _) do
+    []
+  end
 
   defp _lookahead_until_match([{line, lnb} | lines], regex, options, recursive) do
     if line =~ regex do
diff --git a/lib/earmark_parser/line_scanner/rgx.ex b/lib/earmark_parser/line_scanner/rgx.ex
index 168ca6d..dfc8185 100644
--- a/lib/earmark_parser/line_scanner/rgx.ex
+++ b/lib/earmark_parser/line_scanner/rgx.ex
@@ -32,42 +32,66 @@ defmodule EarmarkParser.LineScanner.Rgx do
             void_tag_matches: 1,
             void_tag_rgx: 0}
 
-  def block_quote_matches(content), do: Regex.run(~r/\A > \s? (.*)/x, content)
+  def block_quote_matches(content) do
+    Regex.run(~r/\A > \s? (.*)/x, content)
+  end
 
-  def bullet_list_item_matches(content), do: Regex.run(~r/\A ([-*+]) \s (\s*) (.*)/x, content)
+  def bullet_list_item_matches(content) do
+    Regex.run(~r/\A ([-*+]) \s (\s*) (.*)/x, content)
+  end
 
-  def dash_ruler_matches(content), do: Regex.run(~r/\A (?:-\s?){3,} \z/x, content)
+  def dash_ruler_matches(content) do
+    Regex.run(~r/\A (?:-\s?){3,} \z/x, content)
+  end
 
-  def fence_matches(content),
-    do: Regex.run(~r/\A (\s*) (`{3,} | ~{3,}) \s* ([^`\s]*) \s* \z/ux, content)
+  def fence_matches(content) do
+    Regex.run(~r/\A (\s*) (`{3,} | ~{3,}) \s* ([^`\s]*) \s* \z/ux, content)
+  end
 
-  def footnote_def_matches(content), do: Regex.run(~r/\A \[\^([^\s\]]+)\] : \s+ (.*)/x, content)
+  def footnote_def_matches(content) do
+    Regex.run(~r/\A \[\^([^\s\]]+)\] : \s+ (.*)/x, content)
+  end
 
   # @heading ~r/\A
   # (\#{1,6}) \s+
   #   (?|(.*?) \s* #* \s* \z
   #   |
   #   (.*))/ux
-  def heading_matches(content),
-    do: Regex.run(~r/\A(\#{1,6})\s+(?|(.*?)\s*#*\s*\z|(.*))/u, content)
+  def heading_matches(content) do
+    Regex.run(~r/\A(\#{1,6})\s+(?|(.*?)\s*#*\s*\z|(.*))/u, content)
+  end
 
-  def html_close_tag_matches(content), do: Regex.run(~r/\A < \/ ([-\w]+?) >/x, content)
+  def html_close_tag_matches(content) do
+    Regex.run(~r/\A < \/ ([-\w]+?) >/x, content)
+  end
 
-  def html_comment_start_matches(content), do: Regex.run(~r/\A <!-- .*? \z/x, content)
+  def html_comment_start_matches(content) do
+    Regex.run(~r/\A <!-- .*? \z/x, content)
+  end
 
-  def html_comment_matches(content), do: Regex.run(~r/\A <! (?: -- .*? -- \s* )+ > \z/x, content)
+  def html_comment_matches(content) do
+    Regex.run(~r/\A <! (?: -- .*? -- \s* )+ > \z/x, content)
+  end
 
-  def html_one_line_matches(content),
-    do: Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? > .* <\/\1>/x, content)
+  def html_one_line_matches(content) do
+    Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? > .* <\/\1>/x, content)
+  end
 
-  def html_open_tag_matches(content), do: Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? >/x, content)
+  def html_open_tag_matches(content) do
+    Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? >/x, content)
+  end
 
-  def html_self_closing_matches(content),
-    do: Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? \/> .*/x, content)
+  def html_self_closing_matches(content) do
+    Regex.run(~r/\A < ([-\w]+?) (?:\s.*)? \/> .*/x, content)
+  end
 
-  def set_ext_underline_matches(content), do: Regex.run(~r/\A (=|-)+ \s* \z/x, content)
+  def set_ext_underline_matches(content) do
+    Regex.run(~r/\A (=|-)+ \s* \z/x, content)
+  end
 
-  def ial_matches(content), do: Regex.run(~r/\A {: (\s*[^}]+) } \s* \z/x, content)
+  def ial_matches(content) do
+    Regex.run(~r/\A {: (\s*[^}]+) } \s* \z/x, content)
+  end
 
   @id_title_part ~S"""
         (?|
@@ -107,20 +131,33 @@ defmodule EarmarkParser.LineScanner.Rgx do
     )
   end
 
-  def numbered_list_item_matches(content),
-    do: Regex.run(~r/\A (\d{1,9} [.)] ) \s (\s*) (.*)/x, content)
+  def numbered_list_item_matches(content) do
+    Regex.run(~r/\A (\d{1,9} [.)] ) \s (\s*) (.*)/x, content)
+  end
 
-  def star_ruler_matches(content), do: Regex.run(~r/\A (?:\*\s?){3,} \z/x, content)
+  def star_ruler_matches(content) do
+    Regex.run(~r/\A (?:\*\s?){3,} \z/x, content)
+  end
 
-  def table_column_rgx, do: ~r/\A (\s*) .* \| /x
+  def table_column_rgx do
+    ~r/\A (\s*) .* \| /x
+  end
 
-  def table_first_column_rgx, do: ~r/\A (\s*) .* \s \| \s /x
+  def table_first_column_rgx do
+    ~r/\A (\s*) .* \s \| \s /x
+  end
 
-  def table_header_rgx, do: ~r/\[\[ .*? \]\]/x
+  def table_header_rgx do
+    ~r/\[\[ .*? \]\]/x
+  end
 
-  def table_line_matches(content), do: Regex.run(~r/\A \| (?: [^|]+ \|)+ \s* \z/x, content)
+  def table_line_matches(content) do
+    Regex.run(~r/\A \| (?: [^|]+ \|)+ \s* \z/x, content)
+  end
 
-  def underline_ruler_matches(content), do: Regex.run(~r/\A (?:_\s?){3,} \z/x, content)
+  def underline_ruler_matches(content) do
+    Regex.run(~r/\A (?:_\s?){3,} \z/x, content)
+  end
 
   @void_tags ~w{area br hr img wbr}
   def void_tag_rgx do
@@ -131,7 +168,9 @@ defmodule EarmarkParser.LineScanner.Rgx do
     '''x
   end
 
-  def void_tag_matches(content), do: Regex.run(void_tag_rgx(), content)
+  def void_tag_matches(content) do
+    Regex.run(void_tag_rgx(), content)
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/message.ex b/lib/earmark_parser/message.ex
index 249efb6..97ef10e 100644
--- a/lib/earmark_parser/message.ex
+++ b/lib/earmark_parser/message.ex
@@ -9,8 +9,9 @@ defmodule EarmarkParser.Message do
   @type ts :: list(t)
   @type container_type :: Options.t() | Context.t()
 
-  def add_messages(container, messages),
-    do: Enum.reduce(messages, container, &add_message(&2, &1))
+  def add_messages(container, messages) do
+    Enum.reduce(messages, container, &add_message(&2, &1))
+  end
 
   def add_message(container, message)
 
@@ -23,7 +24,10 @@ defmodule EarmarkParser.Message do
   end
 
   def get_messages(container)
-  def get_messages(%Context{options: %{messages: messages}}), do: messages
+
+  def get_messages(%Context{options: %{messages: messages}}) do
+    messages
+  end
 
   @doc """
   For final output
@@ -33,7 +37,6 @@ defmodule EarmarkParser.Message do
     |> get_messages()
     |> Enum.sort(fn {_, l, _}, {_, r, _} -> r >= l end)
   end
-
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/options.ex b/lib/earmark_parser/options.ex
index f3f2851..d447efe 100644
--- a/lib/earmark_parser/options.ex
+++ b/lib/earmark_parser/options.ex
@@ -32,35 +32,34 @@ defmodule EarmarkParser.Options do
             timeout: nil
 
   @type t :: %__MODULE__{
-            all: boolean(),
-            gfm: boolean(),
-            gfm_tables: boolean(),
-            breaks: boolean(),
-            footnotes: boolean(),
-            footnote_offset:  non_neg_integer(),
-            wikilinks: boolean(),
-            parse_inline: boolean(),
-
-            # allow for annotations
-            annotations: nil | binary(),
-            # additional prefies for class of code blocks
-            code_class_prefix: nil | binary(),
-
-            # Filename and initial line number of the markdown block passed in
-            # for meaningful error messages
-            file: binary(),
-            line: number(),
-            # [{:error|:warning, lnb, text},...]
-            messages: MapSet.t,
-            pure_links: boolean(),
-            sub_sup: boolean(),
-
-            # deprecated
-            pedantic: boolean(),
-            smartypants: boolean(),
-            timeout: nil | non_neg_integer()
-
-  }
+          all: boolean(),
+          gfm: boolean(),
+          gfm_tables: boolean(),
+          breaks: boolean(),
+          footnotes: boolean(),
+          footnote_offset: non_neg_integer(),
+          wikilinks: boolean(),
+          parse_inline: boolean(),
+
+          # allow for annotations
+          annotations: nil | binary(),
+          # additional prefies for class of code blocks
+          code_class_prefix: nil | binary(),
+
+          # Filename and initial line number of the markdown block passed in
+          # for meaningful error messages
+          file: binary(),
+          line: number(),
+          # [{:error|:warning, lnb, text},...]
+          messages: MapSet.t(),
+          pure_links: boolean(),
+          sub_sup: boolean(),
+
+          # deprecated
+          pedantic: boolean(),
+          smartypants: boolean(),
+          timeout: nil | non_neg_integer()
+        }
 
   @doc false
   def add_deprecations(options, messages)
@@ -69,8 +68,7 @@ defmodule EarmarkParser.Options do
     add_deprecations(
       %{options | smartypants: false},
       [
-        {:deprecated, 0,
-         "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}
+        {:deprecated, 0, "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}
         | messages
       ]
     )
@@ -80,8 +78,7 @@ defmodule EarmarkParser.Options do
     add_deprecations(
       %{options | timeout: nil},
       [
-        {:deprecated, 0,
-         "The timeout option has no effect anymore and will be removed in EarmarkParser 1.5"}
+        {:deprecated, 0, "The timeout option has no effect anymore and will be removed in EarmarkParser 1.5"}
         | messages
       ]
     )
@@ -91,14 +88,15 @@ defmodule EarmarkParser.Options do
     add_deprecations(
       %{options | pedantic: false},
       [
-        {:deprecated, 0,
-         "The pedantic option has no effect anymore and will be removed in EarmarkParser 1.5"}
+        {:deprecated, 0, "The pedantic option has no effect anymore and will be removed in EarmarkParser 1.5"}
         | messages
       ]
     )
   end
 
-  def add_deprecations(_options, messages), do: messages
+  def add_deprecations(_options, messages) do
+    messages
+  end
 
   @doc ~S"""
   Use normalize before passing it into any API function
@@ -127,18 +125,22 @@ defmodule EarmarkParser.Options do
     |> _deprecate_old_messages()
   end
 
-  def normalize(options), do: struct(__MODULE__, options) |> normalize()
+  def normalize(options) do
+    struct(__MODULE__, options) |> normalize()
+  end
 
   defp _deprecate_old_messages(options)
-  defp _deprecate_old_messages(%__MODULE__{messages: %MapSet{}} = options), do: options
+
+  defp _deprecate_old_messages(%__MODULE__{messages: %MapSet{}} = options) do
+    options
+  end
 
   defp _deprecate_old_messages(%__MODULE__{} = options) do
     %{
       options
       | messages:
           MapSet.new([
-            {:deprecated, 0,
-             "messages is an internal option that is ignored and will be removed from the API in v1.5"}
+            {:deprecated, 0, "messages is an internal option that is ignored and will be removed from the API in v1.5"}
           ])
     }
   end
@@ -149,7 +151,9 @@ defmodule EarmarkParser.Options do
     %{options | breaks: true, footnotes: true, gfm_tables: true, sub_sup: true, wikilinks: true}
   end
 
-  defp _set_all_if_applicable(options), do: options
+  defp _set_all_if_applicable(options) do
+    options
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/parser.ex b/lib/earmark_parser/parser.ex
index 51095d0..9b1e874 100644
--- a/lib/earmark_parser/parser.ex
+++ b/lib/earmark_parser/parser.ex
@@ -69,7 +69,10 @@ defmodule EarmarkParser.Parser do
   end
 
   defp _parse(input, result, options, recursive)
-  defp _parse([], result, options, _recursive), do: {result, %{}, options}
+
+  defp _parse([], result, options, _recursive) do
+    {result, %{}, options}
+  end
 
   ###################
   # setext headings #
@@ -153,7 +156,12 @@ defmodule EarmarkParser.Parser do
   # split and parse
   defp _parse(lines = [%Line.BlockQuote{lnb: lnb} | _], result, options, recursive) do
     {quote_lines, rest} = Enum.split_while(lines, &blockquote_or_text?/1)
-    lines = for line <- quote_lines, do: line.content
+
+    lines =
+      for line <- quote_lines do
+        line.content
+      end
+
     {blocks, _, _, options1} = parse(lines, %{options | line: lnb}, true)
     _parse(rest, [%Block.BlockQuote{blocks: blocks, lnb: lnb} | result], options1, recursive)
   end
@@ -204,7 +212,12 @@ defmodule EarmarkParser.Parser do
   # split and add verbatim
   defp _parse(lines = [%Line.TableLine{lnb: lnb} | _], result, options, recursive) do
     {para_lines, rest} = Enum.split_while(lines, &text?/1)
-    line_text = for line <- para_lines, do: line.line
+
+    line_text =
+      for line <- para_lines do
+        line.line
+      end
+
     _parse(rest, [%Block.Para{lines: line_text, lnb: lnb + 1} | result], options, recursive)
   end
 
@@ -224,7 +237,10 @@ defmodule EarmarkParser.Parser do
           )
       end
 
-    line_text = for line <- reversed_para_lines |> Enum.reverse(), do: line.line
+    line_text =
+      for line <- reversed_para_lines |> Enum.reverse() do
+        line.line
+      end
 
     if recursive == :list do
       _parse(rest, [%Block.Text{line: line_text, lnb: lnb} | result], options1, recursive)
@@ -265,7 +281,11 @@ defmodule EarmarkParser.Parser do
   defp _parse(list = [%Line.Indent{lnb: lnb} | _], result, options, recursive) do
     {code_lines, rest} = Enum.split_while(list, &indent_or_blank?/1)
     code_lines = remove_trailing_blank_lines(code_lines)
-    code = for line <- code_lines, do: properly_indent(line, 1)
+
+    code =
+      for line <- code_lines do
+        properly_indent(line, 1)
+      end
 
     _parse(
       [%Line.Blank{} | rest],
@@ -291,7 +311,11 @@ defmodule EarmarkParser.Parser do
       end)
 
     {rest1, options1} = _check_closing_fence(rest, lnb, delimiter, options)
-    code = for line <- code_lines, do: line.line
+
+    code =
+      for line <- code_lines do
+        line.line
+      end
 
     _parse(
       rest1,
@@ -380,7 +404,11 @@ defmodule EarmarkParser.Parser do
         {html_lines ++ [hd(rest)], tl(rest)}
       end
 
-    html = for line <- html_lines, do: line.line
+    html =
+      for line <- html_lines do
+        line.line
+      end
+
     _parse(rest, [%Block.HtmlComment{lines: html, lnb: lnb} | result], options, recursive)
   end
 
@@ -455,7 +483,9 @@ defmodule EarmarkParser.Parser do
   # Assign attributes that follow a block to that block #
   #######################################################
 
-  defp assign_attributes_to_blocks([], result), do: result
+  defp assign_attributes_to_blocks([], result) do
+    result
+  end
 
   defp assign_attributes_to_blocks([%Block.Ial{attrs: attrs}, block | rest], result) do
     assign_attributes_to_blocks(rest, [%{block | attrs: attrs} | result])
@@ -485,7 +515,9 @@ defmodule EarmarkParser.Parser do
   @not_pending {nil, 0}
   # ([#{},...]) -> {[#{}],[#{}],{'nil' | binary(),number()}}
   # @spec consolidate_para( ts ) :: { ts, ts, {nil | String.t, number} }
-  defp consolidate_para(lines), do: _consolidate_para(lines, [], @not_pending, nil)
+  defp consolidate_para(lines) do
+    _consolidate_para(lines, [], @not_pending, nil)
+  end
 
   defp _consolidate_para([], result, pending, annotation) do
     {result, [], pending, annotation}
@@ -559,13 +591,17 @@ defmodule EarmarkParser.Parser do
     Map.put(result, String.downcase(id), item)
   end
 
-  defp link_extractor(_, result), do: result
+  defp link_extractor(_, result) do
+    result
+  end
 
   ##################################
   # Visitor pattern for each block #
   ##################################
 
-  defp visit([], result, _func), do: result
+  defp visit([], result, _func) do
+    result
+  end
 
   # Structural node BlockQuote -> descend
   defp visit([item = %Block.BlockQuote{blocks: blocks} | rest], result, func) do
@@ -598,18 +634,21 @@ defmodule EarmarkParser.Parser do
   # Consume HTML, taking care of nesting. Assumes one tag per line. #
   ###################################################################
 
-  defp _html_match_to_closing(opener, rest, annotation),
-    do: _find_closing_tags([opener], rest, [opener.line], [], annotation)
+  defp _html_match_to_closing(opener, rest, annotation) do
+    _find_closing_tags([opener], rest, [opener.line], [], annotation)
+  end
 
   defp _find_closing_tags(needed, input, html_lines, text_lines, annotation)
 
   # No more open tags, happy case
-  defp _find_closing_tags([], rest, html_lines, [], annotation),
-    do: {html_lines, rest, [], annotation}
+  defp _find_closing_tags([], rest, html_lines, [], annotation) do
+    {html_lines, rest, [], annotation}
+  end
 
   # run out of input, unhappy case
-  defp _find_closing_tags(needed, [], html_lines, text_lines, annotation),
-    do: {_add_text_lines(html_lines, text_lines), [], needed, annotation}
+  defp _find_closing_tags(needed, [], html_lines, text_lines, annotation) do
+    {_add_text_lines(html_lines, text_lines), [], needed, annotation}
+  end
 
   # still more lines, still needed closing
   defp _find_closing_tags(
@@ -643,11 +682,13 @@ defmodule EarmarkParser.Parser do
     end
   end
 
-  defp _add_text_lines(html_lines, []),
-    do: html_lines
+  defp _add_text_lines(html_lines, []) do
+    html_lines
+  end
 
-  defp _add_text_lines(html_lines, text_lines),
-    do: [text_lines |> Enum.reverse() |> Enum.join("\n") | html_lines]
+  defp _add_text_lines(html_lines, text_lines) do
+    [text_lines |> Enum.reverse() |> Enum.join("\n") | html_lines]
+  end
 
   ###########
   # Helpers #
@@ -657,10 +698,17 @@ defmodule EarmarkParser.Parser do
     ctag == otag
   end
 
-  defp _closes_tag?(_, _), do: false
+  defp _closes_tag?(_, _) do
+    false
+  end
+
+  defp _opens_tag?(%Line.HtmlOpenTag{}) do
+    true
+  end
 
-  defp _opens_tag?(%Line.HtmlOpenTag{}), do: true
-  defp _opens_tag?(_), do: false
+  defp _opens_tag?(_) do
+    false
+  end
 
   defp _inline_or_text?(line, pending)
 
@@ -674,14 +722,18 @@ defmodule EarmarkParser.Parser do
     %{pending: pending, continue: true}
   end
 
-  defp _inline_or_text?(_line, @not_pending), do: %{pending: @not_pending, continue: false}
+  defp _inline_or_text?(_line, @not_pending) do
+    %{pending: @not_pending, continue: false}
+  end
 
   defp _inline_or_text?(line, pending) do
     pending = still_inline_code(line, pending)
     %{pending: pending, continue: true}
   end
 
-  defp _override_annotation(annotation, line), do: annotation || line.annotation
+  defp _override_annotation(annotation, line) do
+    annotation || line.annotation
+  end
 
   defp remove_trailing_blank_lines(lines) do
     lines
@@ -691,7 +743,10 @@ defmodule EarmarkParser.Parser do
   end
 
   def prepend_ial(context, maybeatts, lnb, result)
-  def prepend_ial(context, nil, _lnb, result), do: {context, result}
+
+  def prepend_ial(context, nil, _lnb, result) do
+    {context, result}
+  end
 
   def prepend_ial(context, ial, lnb, result) do
     {context1, attributes} = parse_attrs(context, ial, lnb)
diff --git a/lib/earmark_parser/parser/footnote_parser.ex b/lib/earmark_parser/parser/footnote_parser.ex
index 024ceef..d3da0cd 100644
--- a/lib/earmark_parser/parser/footnote_parser.ex
+++ b/lib/earmark_parser/parser/footnote_parser.ex
@@ -12,7 +12,7 @@ defmodule EarmarkParser.Parser.FootnoteParser do
 
   defp _parse_fn_def_reduce(ele_or_end, acc)
 
-  defp _parse_fn_def_reduce({:element, %Line.FnDef{content: content}=fn_def}, acc) do
+  defp _parse_fn_def_reduce({:element, %Line.FnDef{content: content} = fn_def}, acc) do
     {result1, footnotes, options1} = _complete_fn_def_block(acc, fn_def)
     {[content], result1, footnotes, options1}
   end
@@ -53,6 +53,6 @@ defmodule EarmarkParser.Parser.FootnoteParser do
 
     {[%Block.FnList{blocks: fn_blocks} | rest], footnotes1, options1}
   end
-
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/parser/link_parser.ex b/lib/earmark_parser/parser/link_parser.ex
index ac83ba5..0225df8 100644
--- a/lib/earmark_parser/parser/link_parser.ex
+++ b/lib/earmark_parser/parser/link_parser.ex
@@ -43,18 +43,28 @@ defmodule EarmarkParser.Parser.LinkParser do
     end
   end
 
-  defp p_url([{:open_paren, _} | ts], lnb), do: url(ts, {[], [], nil}, [:close_paren], lnb)
-  defp p_url(_, _), do: nil
+  defp p_url([{:open_paren, _} | ts], lnb) do
+    url(ts, {[], [], nil}, [:close_paren], lnb)
+  end
+
+  defp p_url(_, _) do
+    nil
+  end
 
   # push one level
-  defp url([{:open_paren, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), [:close_paren | needed], lnb)
+  defp url([{:open_paren, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), [:close_paren | needed], lnb)
+  end
 
   # pop last level
-  defp url([{:close_paren, _} | _], result, [:close_paren], _lnb), do: result
+  defp url([{:close_paren, _} | _], result, [:close_paren], _lnb) do
+    result
+  end
+
   # pop inner level
-  defp url([{:close_paren, text} | ts], result, [:close_paren | needed], lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:close_paren, text} | ts], result, [:close_paren | needed], lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
   # A quote on level 0 -> bailing out if there is a matching quote
   defp url(ts_all = [{:open_title, text} | ts], result, [:close_paren], lnb) do
@@ -65,26 +75,34 @@ defmodule EarmarkParser.Parser.LinkParser do
   end
 
   # All these are just added to the url
-  defp url([{:open_bracket, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:open_bracket, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
-  defp url([{:close_bracket, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:close_bracket, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
-  defp url([{:any_quote, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:any_quote, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
-  defp url([{:verbatim, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:verbatim, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
-  defp url([{:ws, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:ws, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
-  defp url([{:escaped, text} | ts], result, needed, lnb),
-    do: url(ts, add(result, text), needed, lnb)
+  defp url([{:escaped, text} | ts], result, needed, lnb) do
+    url(ts, add(result, text), needed, lnb)
+  end
 
   # That is not good, actually this is not a legal url part of a link
-  defp url(_, _, _, _), do: nil
+  defp url(_, _, _, _) do
+    nil
+  end
 
   defp bail_out_to_title(ts, result) do
     with remaining_text <- ts |> Enum.map_join(&text_of_token/1) do
@@ -99,7 +117,10 @@ defmodule EarmarkParser.Parser.LinkParser do
   end
 
   defp text_of_token(token)
-  defp text_of_token({:escaped, text}), do: "\\#{text}"
+
+  defp text_of_token({:escaped, text}) do
+    "\\#{text}"
+  end
 
   defp text_of_token({_, text}) do
     text
@@ -125,22 +146,29 @@ defmodule EarmarkParser.Parser.LinkParser do
     end
   end
 
-  defp make_result(nil, _, _, _), do: nil
+  defp make_result(nil, _, _, _) do
+    nil
+  end
 
   defp make_result({parsed, url, title}, link_text, parsed_text, link_or_img) do
     {"#{parsed_text}(#{list_to_text(parsed)})", link_text, list_to_text(url), title, link_or_img}
   end
 
-  defp add({parsed_text, url_text, nil}, text), do: {[text | parsed_text], [text | url_text], nil}
+  defp add({parsed_text, url_text, nil}, text) do
+    {[text | parsed_text], [text | url_text], nil}
+  end
 
-  defp add_title({parsed_text, url_text, _}, {parsed, inner}),
-    do: {[parsed | parsed_text], url_text, inner}
+  defp add_title({parsed_text, url_text, _}, {parsed, inner}) do
+    {[parsed | parsed_text], url_text, inner}
+  end
 
   defp make_wikilink(parsed_text, target, link_text) do
     {parsed_text, String.trim(link_text), String.trim(target), nil, :wikilink}
   end
 
-  defp list_to_text(lst), do: lst |> Enum.reverse() |> Enum.join("")
+  defp list_to_text(lst) do
+    lst |> Enum.reverse() |> Enum.join("")
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/parser/list_info.ex b/lib/earmark_parser/parser/list_info.ex
index 03c3f05..78435fb 100644
--- a/lib/earmark_parser/parser/list_info.ex
+++ b/lib/earmark_parser/parser/list_info.ex
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Parser.ListInfo do
-
   import EarmarkParser.Helpers.LookaheadHelpers, only: [opens_inline_code: 1, still_inline_code: 2]
 
   @moduledoc false
@@ -7,7 +6,7 @@ defmodule EarmarkParser.Parser.ListInfo do
   @not_pending {nil, 0}
 
   defstruct(
-    indent: 0, 
+    indent: 0,
     lines: [],
     loose?: false,
     pending: @not_pending,
@@ -15,7 +14,7 @@ defmodule EarmarkParser.Parser.ListInfo do
     width: 0
   )
 
-  def new(%EarmarkParser.Line.ListItem{initial_indent: ii, list_indent: width}=item, options) do
+  def new(%EarmarkParser.Line.ListItem{initial_indent: ii, list_indent: width} = item, options) do
     pending = opens_inline_code(item)
     %__MODULE__{indent: ii, lines: [item.content], options: options, pending: pending, width: width}
   end
@@ -24,18 +23,19 @@ defmodule EarmarkParser.Parser.ListInfo do
     prepend_line(list_info, line) |> _update_rest(pending_line, loose?)
   end
 
-  def prepend_line(%__MODULE__{lines: lines}=list_info, line) do
-    %{list_info|lines: [line|lines]}
+  def prepend_line(%__MODULE__{lines: lines} = list_info, line) do
+    %{list_info | lines: [line | lines]}
   end
 
-  defp _update_rest(%{pending: @not_pending}=list_info, line, loose?) do
+  defp _update_rest(%{pending: @not_pending} = list_info, line, loose?) do
     pending = opens_inline_code(line)
     %{list_info | pending: pending, loose?: loose?}
   end
 
-  defp _update_rest(%{pending: pending}=list_info, line, loose?) do
+  defp _update_rest(%{pending: pending} = list_info, line, loose?) do
     pending1 = still_inline_code(line, pending)
     %{list_info | pending: pending1, loose?: loose?}
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/lib/earmark_parser/parser/list_parser.ex b/lib/earmark_parser/parser/list_parser.ex
index cc129a4..cbe356f 100644
--- a/lib/earmark_parser/parser/list_parser.ex
+++ b/lib/earmark_parser/parser/list_parser.ex
@@ -12,111 +12,139 @@ defmodule EarmarkParser.Parser.ListParser do
 
   def parse_list(lines, result, options \\ %Options{}) do
     {items, rest, options1} = _parse_list_items_init(lines, [], options)
-    list                    = _make_list(items, _empty_list(items) )
-    {[list|result], rest, options1}
+    list = _make_list(items, _empty_list(items))
+    {[list | result], rest, options1}
   end
 
-  defp _parse_list_items_init([item|rest], list_items, options) do
-    options1 = %{options|line: item.lnb}
+  defp _parse_list_items_init([item | rest], list_items, options) do
+    options1 = %{options | line: item.lnb}
     _parse_list_items_start(rest, _make_and_prepend_list_item(item, list_items), new(item, options1))
   end
 
   defp _parse_list_items_spaced(input, items, list_info)
-  defp _parse_list_items_spaced(input, items, %{pending: @not_pending}=list_info) do
+
+  defp _parse_list_items_spaced(input, items, %{pending: @not_pending} = list_info) do
     _parse_list_items_spaced_np(input, items, list_info)
   end
+
   defp _parse_list_items_spaced(input, items, list_info) do
     _parse_list_items_spaced_pdg(input, items, list_info)
   end
 
-  defp _parse_list_items_spaced_np([%Line.Blank{}|rest], items, list_info) do
-    list_info1 = %{list_info|lines: [""|list_info.lines], options: %{list_info.options|line: list_info.options.line + 1}}
+  defp _parse_list_items_spaced_np([%Line.Blank{} | rest], items, list_info) do
+    list_info1 = %{
+      list_info
+      | lines: ["" | list_info.lines],
+        options: %{list_info.options | line: list_info.options.line + 1}
+    }
+
     _parse_list_items_spaced_np(rest, items, list_info1)
   end
-  defp _parse_list_items_spaced_np([%Line.Ruler{}|_]=lines, items, list_info) do
+
+  defp _parse_list_items_spaced_np([%Line.Ruler{} | _] = lines, items, list_info) do
     _finish_list_items(lines, items, false, list_info)
   end
-  defp _parse_list_items_spaced_np([%Line.ListItem{indent: ii}=item|_]=input, list_items, %{width: w}=list_info)
-    when ii < w do
-      if _starts_list?(item, list_items) do
-        _finish_list_items(input, list_items, false, list_info)
-      else
-        {items1, options1} = _finish_list_item(list_items, false, _loose(list_info))
-        _parse_list_items_init(input, items1, options1)
-      end
-  end
-  defp _parse_list_items_spaced_np([%Line.Indent{indent: ii}=item|rest], list_items, %{width: w}=list_info)
-    when ii >= w do
-      indented = _behead_spaces(item.line, w)
-      _parse_list_items_spaced(rest, list_items, update_list_info(list_info, indented, item, true))
-  end
-  defp _parse_list_items_spaced_np([%Line.ListItem{}=line|rest], items, list_info) do
+
+  defp _parse_list_items_spaced_np([%Line.ListItem{indent: ii} = item | _] = input, list_items, %{width: w} = list_info)
+       when ii < w do
+    if _starts_list?(item, list_items) do
+      _finish_list_items(input, list_items, false, list_info)
+    else
+      {items1, options1} = _finish_list_item(list_items, false, _loose(list_info))
+      _parse_list_items_init(input, items1, options1)
+    end
+  end
+
+  defp _parse_list_items_spaced_np([%Line.Indent{indent: ii} = item | rest], list_items, %{width: w} = list_info)
+       when ii >= w do
+    indented = _behead_spaces(item.line, w)
+    _parse_list_items_spaced(rest, list_items, update_list_info(list_info, indented, item, true))
+  end
+
+  defp _parse_list_items_spaced_np([%Line.ListItem{} = line | rest], items, list_info) do
     indented = _behead_spaces(line.line, list_info.width)
     _parse_list_items_start(rest, items, update_list_info(list_info, indented, line))
   end
+
   # BUG: Still do not know how much to indent here???
-  defp _parse_list_items_spaced_np([%{indent: indent, line: str_line}=line|rest], items, %{width: width}=list_info) when
-    indent >= width
-  do
+  defp _parse_list_items_spaced_np(
+         [%{indent: indent, line: str_line} = line | rest],
+         items,
+         %{width: width} = list_info
+       )
+       when indent >= width do
     _parse_list_items_spaced(rest, items, update_list_info(list_info, behead(str_line, width), line, true))
   end
+
   defp _parse_list_items_spaced_np(input, items, list_info) do
-    _finish_list_items(input ,items, false, list_info)
+    _finish_list_items(input, items, false, list_info)
   end
 
   defp _parse_list_items_spaced_pdg(input, items, list_info)
-  defp _parse_list_items_spaced_pdg([], items, %{pending: {pending, lnb}}=list_info) do
+
+  defp _parse_list_items_spaced_pdg([], items, %{pending: {pending, lnb}} = list_info) do
     options1 =
       add_message(list_info.options, {:warning, lnb, "Closing unclosed backquotes #{pending} at end of input"})
-    _finish_list_items([], items, false, %{list_info| options: options1})
+
+    _finish_list_items([], items, false, %{list_info | options: options1})
   end
-  defp _parse_list_items_spaced_pdg([line|rest], items, list_info) do
+
+  defp _parse_list_items_spaced_pdg([line | rest], items, list_info) do
     indented = _behead_spaces(line.line, list_info.width)
     _parse_list_items_spaced(rest, items, update_list_info(list_info, indented, line, true))
   end
 
-
   defp _parse_list_items_start(input, list_items, list_info)
-  defp _parse_list_items_start(input, list_items, %{pending: @not_pending}=list_info) do
+
+  defp _parse_list_items_start(input, list_items, %{pending: @not_pending} = list_info) do
     _parse_list_items_start_np(input, list_items, list_info)
   end
+
   defp _parse_list_items_start(input, list_items, list_info) do
     _parse_list_items_start_pdg(input, list_items, list_info)
   end
 
   defp _parse_list_items_start_np(input, list_items, list_info)
-  defp _parse_list_items_start_np([%Line.Blank{}|input], items, list_info) do
+
+  defp _parse_list_items_start_np([%Line.Blank{} | input], items, list_info) do
     _parse_list_items_spaced(input, items, prepend_line(list_info, ""))
   end
+
   defp _parse_list_items_start_np([], list_items, list_info) do
     _finish_list_items([], list_items, true, list_info)
   end
-  defp _parse_list_items_start_np([%Line.Ruler{}|_]=input, list_items, list_info) do
+
+  defp _parse_list_items_start_np([%Line.Ruler{} | _] = input, list_items, list_info) do
     _finish_list_items(input, list_items, true, list_info)
   end
-  defp _parse_list_items_start_np([%Line.Heading{}|_]=input, list_items, list_info) do
+
+  defp _parse_list_items_start_np([%Line.Heading{} | _] = input, list_items, list_info) do
     _finish_list_items(input, list_items, true, list_info)
   end
-  defp _parse_list_items_start_np([%Line.ListItem{indent: ii}=item|_]=input, list_items, %{width: w}=list_info)
-    when ii < w do
-      if _starts_list?(item, list_items) do
-        _finish_list_items(input, list_items, true, list_info)
-      else
-        {items1, options1} = _finish_list_item(list_items, true, list_info)
-        _parse_list_items_init(input, items1, options1)
-      end
+
+  defp _parse_list_items_start_np([%Line.ListItem{indent: ii} = item | _] = input, list_items, %{width: w} = list_info)
+       when ii < w do
+    if _starts_list?(item, list_items) do
+      _finish_list_items(input, list_items, true, list_info)
+    else
+      {items1, options1} = _finish_list_item(list_items, true, list_info)
+      _parse_list_items_init(input, items1, options1)
+    end
   end
+
   # Slurp in everything else before a first blank line
-  defp _parse_list_items_start_np([%{line: str_line}=line|rest], items, list_info) do
+  defp _parse_list_items_start_np([%{line: str_line} = line | rest], items, list_info) do
     indented = _behead_spaces(str_line, list_info.width)
     _parse_list_items_start(rest, items, update_list_info(list_info, indented, line))
   end
 
   defp _parse_list_items_start_pdg(input, items, list_info)
+
   defp _parse_list_items_start_pdg([], items, list_info) do
     _finish_list_items([], items, true, list_info)
   end
-  defp _parse_list_items_start_pdg([%{line: str_line}=line|rest], items, list_info) do
+
+  defp _parse_list_items_start_pdg([%{line: str_line} = line | rest], items, list_info) do
     indented = _behead_spaces(str_line, list_info.width)
     _parse_list_items_start(rest, items, update_list_info(list_info, indented, line))
   end
@@ -126,7 +154,7 @@ defmodule EarmarkParser.Parser.ListParser do
   end
 
   # INLINE CANDIDATE
-  defp _empty_list([%Block.ListItem{loose?: loose?, type: type}|_]) do
+  defp _empty_list([%Block.ListItem{loose?: loose?, type: type} | _]) do
     %Block.List{loose?: loose?, type: type}
   end
 
@@ -140,12 +168,14 @@ defmodule EarmarkParser.Parser.ListParser do
     end
   end
 
-  defp _finish_list_item([%Block.ListItem{}=item|items], _at_start?, list_info) do
-    {blocks, _, _, options1} = list_info.lines
-                            |> Enum.reverse
-                            |> EarmarkParser.Parser.parse(%{list_info.options|line: item.lnb}, :list)
+  defp _finish_list_item([%Block.ListItem{} = item | items], _at_start?, list_info) do
+    {blocks, _, _, options1} =
+      list_info.lines
+      |> Enum.reverse()
+      |> EarmarkParser.Parser.parse(%{list_info.options | line: item.lnb}, :list)
+
     loose1? = _already_loose?(items) || list_info.loose?
-    {[%{item | blocks: blocks, loose?: loose1?}|items], options1}
+    {[%{item | blocks: blocks, loose?: loose1?} | items], options1}
   end
 
   defp _finish_list_items(input, items, at_start?, list_info) do
@@ -154,29 +184,36 @@ defmodule EarmarkParser.Parser.ListParser do
   end
 
   defp _make_and_prepend_list_item(%Line.ListItem{bullet: bullet, lnb: lnb, type: type}, list_items) do
-    [%Block.ListItem{bullet: bullet, lnb: lnb, spaced?: false, type: type}|list_items]
+    [%Block.ListItem{bullet: bullet, lnb: lnb, spaced?: false, type: type} | list_items]
   end
 
   defp _make_list(items, list)
-  defp _make_list([%Block.ListItem{bullet: bullet, lnb: lnb}=item], %Block.List{loose?: loose?}=list) do
-    %{list | blocks: [%{item | loose?: loose?}|list.blocks],
-      bullet: bullet,
-      lnb: lnb,
-      start: _extract_start(item)}
+
+  defp _make_list([%Block.ListItem{bullet: bullet, lnb: lnb} = item], %Block.List{loose?: loose?} = list) do
+    %{list | blocks: [%{item | loose?: loose?} | list.blocks], bullet: bullet, lnb: lnb, start: _extract_start(item)}
   end
-  defp _make_list([%Block.ListItem{}=item|rest], %Block.List{loose?: loose?}=list) do
-   _make_list(rest, %{list | blocks: [%{item | loose?: loose?}|list.blocks]})
+
+  defp _make_list([%Block.ListItem{} = item | rest], %Block.List{loose?: loose?} = list) do
+    _make_list(rest, %{list | blocks: [%{item | loose?: loose?} | list.blocks]})
   end
 
   defp _already_loose?(items)
-  defp _already_loose?([]), do: false
-  defp _already_loose?([%{loose?: loose?}|_]), do: loose?
 
-  defp _loose(list_info), do: %{list_info|loose?: true}
+  defp _already_loose?([]) do
+    false
+  end
 
-  defp _starts_list?(%{bullet: bullet1}, [%Block.ListItem{bullet: bullet2}|_]) do
-    String.last(bullet1) != String.last(bullet2)
+  defp _already_loose?([%{loose?: loose?} | _]) do
+    loose?
   end
 
+  defp _loose(list_info) do
+    %{list_info | loose?: true}
+  end
+
+  defp _starts_list?(%{bullet: bullet1}, [%Block.ListItem{bullet: bullet2} | _]) do
+    String.last(bullet1) != String.last(bullet2)
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0

From c970730a49423aabfcc446906b7b6ecd417316c5 Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 14:47:47 +0100
Subject: [PATCH 6/7] Road to #164

  This commit completes reformatting of all test files
---
 .formatter.exs                                |   3 +-
 test/acceptance/ast/atx_headers_test.exs      |  27 ++-
 test/acceptance/ast/block_ial_test.exs        |  27 ++-
 test/acceptance/ast/block_quotes_test.exs     |  58 +++---
 test/acceptance/ast/comment_test.exs          |  14 +-
 test/acceptance/ast/del_test.exs              |  15 +-
 test/acceptance/ast/diverse_test.exs          |  13 +-
 test/acceptance/ast/emphasis_test.exs         |  31 ++--
 test/acceptance/ast/empty_test.exs            |   5 +-
 test/acceptance/ast/escape_test.exs           |  29 ++-
 .../ast/fenced_code_blocks_test.exs           |  19 +-
 .../ast/footnotes/error_cases_test.exs        |   1 +
 .../ast/footnotes/fn_in_lists_test.exs        |  43 +++--
 .../ast/footnotes/multiple_fn_test.exs        |  15 +-
 .../ast/footnotes/single_footnote_test.exs    |   2 -
 test/acceptance/ast/hard_line_breaks_test.exs |  29 ++-
 test/acceptance/ast/horizontal_rules_test.exs |  53 +++---
 .../ast/html/block/annotated_block_test.exs   |  17 +-
 .../ast/html/block/unannotated_block_test.exs |  12 +-
 .../html/one_line/annotated_oneline_test.exs  |  12 +-
 .../ast/html/one_line/attributes_test.exs     |  11 +-
 .../one_line/unannotated_oneline_test.exs     |   4 +-
 test/acceptance/ast/html/permissive_test.exs  |  18 +-
 test/acceptance/ast/ial_test.exs              |  35 ++--
 .../ast/indented_code_blocks_test.exs         |  27 +--
 test/acceptance/ast/inline_code_test.exs      |  42 +++--
 test/acceptance/ast/inline_ial_test.exs       |  32 ++--
 test/acceptance/ast/line_breaks_test.exs      |  48 +++--
 test/acceptance/ast/links_images/img_test.exs |  46 +++--
 .../acceptance/ast/links_images/link_test.exs |  84 +++++----
 .../ast/links_images/pure_links_test.exs      | 104 +++++++----
 .../ast/links_images/titles_test.exs          | 172 +++++++++++-------
 .../ast/links_images/wiki_links_test.exs      |   9 +-
 test/acceptance/ast/list_indent_test.exs      |  11 +-
 test/acceptance/ast/list_test.exs             |  99 +++++-----
 .../ast/lists/complex_body_test.exs           |  13 +-
 .../ast/lists/complex_head_test.exs           |  69 ++++++-
 test/acceptance/ast/lists/indent_test.exs     |  44 ++++-
 .../ast/lists/list_and_block_test.exs         |  43 +++--
 .../ast/lists/list_and_fenced_code_test.exs   |   8 +-
 .../ast/lists/list_and_inline_code_test.exs   |  28 +--
 test/acceptance/ast/lists/spaced_test.exs     |  25 ++-
 test/acceptance/ast/math_test.exs             |  92 +++++-----
 .../paragraphs/annotated_paragraphs_test.exs  |  37 ++--
 .../unannotated_paragraphs_test.exs           |  34 ++--
 test/acceptance/ast/pure_link_test.exs        |  26 +--
 test/acceptance/ast/reflink_test.exs          |  36 ++--
 test/acceptance/ast/setext_headers_test.exs   |  52 +++---
 test/acceptance/ast/sub_sup_test.exs          |  25 ++-
 test/acceptance/ast/table_test.exs            |   2 +-
 test/acceptance/ast/utf8_test.exs             |   1 +
 .../error_handling/bad_arguments_test.exs     |   3 +-
 .../i002-accept-any-struct-as-option_test.exs |   3 +-
 .../i023_missing_error_end_codeblock_test.exs |   4 +
 .../i028-side-by-side-links_test.exs          |  80 ++++++--
 .../i065-bad-lnb-ref-style_test.exs           |   2 +-
 .../regressions/i086-bad-options_test.exs     |   6 +-
 .../i098-l1-set-header-after-code_test.exs    |   2 +-
 .../i154_parser_crash_symbolic_input_test.exs |   8 +-
 .../i161_indent_code_blocks_test.exs          |  11 +-
 test/acceptance/renderer/ast_walker_test.exs  |  11 +-
 .../attr_parser_test.exs                      |  71 +++++---
 .../link_parser_test.exs                      |  13 +-
 .../pure_link_helper_test.exs                 |  19 +-
 test/earmark_parser_test.exs                  |   2 +-
 .../converter/complex_conversion_test.exs     |  10 +-
 .../converter/optional_conversion_test.exs    |   4 +-
 .../converter/single_conversion_test.exs      |  14 +-
 test/functional/scanner/deprecation_test.exs  |  19 +-
 test/functional/scanner/line_type_test.exs    | 130 ++++++++-----
 test/support/acceptance_test_case.ex          |   3 +-
 test/support/ast_helpers.ex                   |  49 +++--
 test/support/error_plugin.ex                  |  18 +-
 test/support/helpers.ex                       |  30 +--
 test/support/inline_converter_case.ex         |  14 +-
 test/support/parser.ex                        |   2 +-
 test/support/table_helpers.ex                 |   6 +-
 test/support/wip_helpers.ex                   |   3 +-
 test/unit/ast_walker_test.exs                 |   4 +-
 test/unit/convert_test.exs                    |  28 ++-
 test/unit/enum/ext_test.exs                   |   1 +
 test/unit/helpers_test.exs                    |   5 +-
 82 files changed, 1380 insertions(+), 897 deletions(-)

diff --git a/.formatter.exs b/.formatter.exs
index 119aa3d..6aebc5f 100644
--- a/.formatter.exs
+++ b/.formatter.exs
@@ -5,6 +5,7 @@
   migrate: true,
   migrate_bitstring_modifiers: true,
   migrate_charlists_as_sigils: true,
-  migrate_unless: false,
+  migrate_unless: false
 ]
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/atx_headers_test.exs b/test/acceptance/ast/atx_headers_test.exs
index 1757c9f..40babed 100644
--- a/test/acceptance/ast/atx_headers_test.exs
+++ b/test/acceptance/ast/atx_headers_test.exs
@@ -4,10 +4,9 @@ defmodule Acceptance.Ast.AtxHeadersTest do
   import EarmarkAstDsl
 
   describe "ATX headers" do
-
     test "from one to six" do
       markdown = "# foo\n## foo\n### foo\n#### foo\n##### foo\n###### foo\n"
-      ast      = (1..6) |> Enum.map(&tag("h#{&1}", "foo"))
+      ast = 1..6 |> Enum.map(&tag("h#{&1}", "foo"))
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -15,7 +14,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "from one to six with closing" do
       markdown = "# foo #\n## foo ##\n### foo ###\n#### foo #####\n##### foo #####\n###### foo ######\n"
-      ast      = (1..6) |> Enum.map(&tag("h#{&1}", "foo"))
+      ast = 1..6 |> Enum.map(&tag("h#{&1}", "foo"))
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -23,7 +22,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "from one to six with closing and trailing ws" do
       markdown = "# foo # \n## foo ## \n### foo ### \n#### foo ##### \n##### foo ##### \n###### foo ###### \n"
-      ast      = (1..6) |> Enum.map(&tag("h#{&1}", "foo"))
+      ast = 1..6 |> Enum.map(&tag("h#{&1}", "foo"))
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -31,7 +30,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "seven? kidding, right?" do
       markdown = "####### foo\n"
-      ast      = p("####### foo")
+      ast = p("####### foo")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -39,7 +38,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "sticky (better than to have no glue)" do
       markdown = "#5 bolt\n\n#foobar\n"
-      ast      = [ p("#5 bolt"), p("#foobar") ]
+      ast = [p("#5 bolt"), p("#foobar")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -47,7 +46,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "close escape" do
       markdown = "\\## foo\n"
-      ast      = p("## foo")
+      ast = p("## foo")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -55,7 +54,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "position is so important" do
       markdown = "# foo *bar* \\*baz\\*\n"
-      ast      = tag("h1", ["foo ", tag("em", "bar"), " *baz*"])
+      ast = tag("h1", ["foo ", tag("em", "bar"), " *baz*"])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -63,7 +62,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "spacy" do
       markdown = "#                  foo                     \n"
-      ast      = tag("h1", "foo")
+      ast = tag("h1", "foo")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -71,7 +70,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "code comes first" do
       markdown = "    # foo\nnext"
-      ast      = [pre_code("# foo"), p("next")]
+      ast = [pre_code("# foo"), p("next")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -79,7 +78,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "some prefer to close their headers" do
       markdown = "# foo#\n"
-      ast      = tag("h1", "foo")
+      ast = tag("h1", "foo")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -87,7 +86,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "closing headers can get creative" do
       markdown = "### foo######\n"
-      ast      = tag("h3", "foo")
+      ast = tag("h3", "foo")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -95,7 +94,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "hash can still be used in a header" do
       markdown = "# C# #\n"
-      ast      = tag("h1", "C#")
+      ast = tag("h1", "C#")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -103,7 +102,7 @@ defmodule Acceptance.Ast.AtxHeadersTest do
 
     test "closing header with hash" do
       markdown = "# C# (language)#\n"
-      ast      = tag("h1", "C# (language)")
+      ast = tag("h1", "C# (language)")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
diff --git a/test/acceptance/ast/block_ial_test.exs b/test/acceptance/ast/block_ial_test.exs
index 70ef252..9e9cb89 100644
--- a/test/acceptance/ast/block_ial_test.exs
+++ b/test/acceptance/ast/block_ial_test.exs
@@ -5,10 +5,9 @@ defmodule Acceptance.Ast.BlockIalTest do
   import EarmarkAstDsl
 
   describe "IAL" do
-
     test "Not associated" do
       markdown = "{:hello=world}"
-      ast      = p("{:hello=world}")
+      ast = p("{:hello=world}")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -16,7 +15,7 @@ defmodule Acceptance.Ast.BlockIalTest do
 
     test "Not associated means verbatim" do
       markdown = "{: hello=world  }"
-      ast      = p("{: hello=world  }")
+      ast = p("{: hello=world  }")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -24,15 +23,15 @@ defmodule Acceptance.Ast.BlockIalTest do
 
     test "Not associated and incorrect" do
       markdown = "{:hello}"
-      ast      = tag("p", "{:hello}")
-      messages = [{:warning, 1, "Illegal attributes [\"hello\"] ignored in IAL" }]
+      ast = tag("p", "{:hello}")
+      messages = [{:warning, 1, "Illegal attributes [\"hello\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
     end
 
     test "Associated" do
       markdown = "Before\n{:hello=world}"
-      ast      = tag("p", "Before", hello: "world")
+      ast = tag("p", "Before", hello: "world")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -40,7 +39,7 @@ defmodule Acceptance.Ast.BlockIalTest do
 
     test "Associated in between" do
       markdown = "Before\n{:hello=world}\nAfter"
-      ast      = [p("Before", hello: "world"), p("After")]
+      ast = [p("Before", hello: "world"), p("After")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -48,24 +47,24 @@ defmodule Acceptance.Ast.BlockIalTest do
 
     test "Associated and incorrect" do
       markdown = "Before\n{:hello}"
-      ast      = tag("p", "Before")
-      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL" }]
+      ast = tag("p", "Before")
+      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
     end
 
     test "Associated and partly incorrect" do
       markdown = "Before\n{:hello title=world}"
-      ast      = p("Before", title: "world")
-      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL" }]
+      ast = p("Before", title: "world")
+      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
     end
 
     test "Associated and partly incorrect and shortcuts" do
       markdown = "Before\n{:#hello .alpha hello title=world .beta class=\"gamma\" title='class'}"
-      ast      = p("Before", class: "gamma beta alpha", id: "hello", title: "class world")
-      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL" }]
+      ast = p("Before", class: "gamma beta alpha", id: "hello", title: "class world")
+      messages = [{:warning, 2, "Illegal attributes [\"hello\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
     end
@@ -74,7 +73,7 @@ defmodule Acceptance.Ast.BlockIalTest do
     @tag :wip
     test "In tight lists?" do
       markdown = "- Before\n{:.alpha .beta}"
-      ast      = tag("ul", tag("li", "Before", class: "beta alpha"))
+      ast = tag("ul", tag("li", "Before", class: "beta alpha"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
diff --git a/test/acceptance/ast/block_quotes_test.exs b/test/acceptance/ast/block_quotes_test.exs
index b41515e..3156556 100644
--- a/test/acceptance/ast/block_quotes_test.exs
+++ b/test/acceptance/ast/block_quotes_test.exs
@@ -8,7 +8,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
   describe "with breaks: true" do
     test "acceptance test 490 with breaks" do
       markdown = "> bar\nbaz\n> foo\n"
-      ast      = bq(p(brlist(~w[bar baz foo])))
+      ast = bq(p(brlist(~w[bar baz foo])))
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -16,7 +16,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "acceptance test 580 with breaks" do
       markdown = "1. foo\nbar"
-      ast      = tag("ol", [tag("li", brlist(~w[foo bar]))])
+      ast = tag("ol", [tag("li", brlist(~w[foo bar]))])
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -24,7 +24,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "acceptance test 581 with breaks" do
       markdown = "* a\n  b\nc"
-      ast      = tag("ul", tag("li", brlist(~w[a b c])))
+      ast = tag("ul", tag("li", brlist(~w[a b c])))
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -32,7 +32,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "acceptance test 582 with breaks" do
       markdown = "* x\n  a\n| A | B |"
-      ast      = tag("ul", tag("li", brlist(["x", "a", "| A | B |"])))
+      ast = tag("ul", tag("li", brlist(["x", "a", "| A | B |"])))
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -40,22 +40,29 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "acceptance test 583 with breaks" do
       markdown = "* x\n | A | B |"
-      ast      = tag("ul", tag("li", brlist(["x", "| A | B |"])))
+      ast = tag("ul", tag("li", brlist(["x", "| A | B |"])))
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
     end
 
     test "acceptance test 630 with breaks" do
-      markdown = "\\*not emphasized\\*\n\\[not a link](/foo)\n\\`not code\\`\n1\\. not a list\n\\* not a list\n\\# not a header\n\\[foo]: /url \"not a reference\"\n"
-      ast      = p(brlist([
-        "*not emphasized*",
-        "[not a link](/foo)",
-        "`not code`",
-        "1. not a list",
-        "* not a list",
-        "# not a header",
-        "[foo]: /url \"not a reference\""]))
+      markdown =
+        "\\*not emphasized\\*\n\\[not a link](/foo)\n\\`not code\\`\n1\\. not a list\n\\* not a list\n\\# not a header\n\\[foo]: /url \"not a reference\"\n"
+
+      ast =
+        p(
+          brlist([
+            "*not emphasized*",
+            "[not a link](/foo)",
+            "`not code`",
+            "1. not a list",
+            "* not a list",
+            "# not a header",
+            "[foo]: /url \"not a reference\""
+          ])
+        )
+
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -63,7 +70,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "more" do
       markdown = "> # Foo\n> bar\n> baz\n"
-      ast      = bq([tag("h1", "Foo"), p(brlist(~w[bar baz]))])
+      ast = bq([tag("h1", "Foo"), p(brlist(~w[bar baz]))])
       messages = []
 
       assert as_ast(markdown, breaks: true) == {:ok, [ast], messages}
@@ -73,7 +80,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
   describe "Block Quotes" do
     test "quote my block" do
       markdown = "> Foo"
-      ast      = bq(p("Foo"))
+      ast = bq(p("Foo"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -81,7 +88,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "and block my quotes" do
       markdown = "> # Foo\n> bar\n> baz\n"
-      ast      = bq([tag("h1", "Foo"), p("bar\nbaz")])
+      ast = bq([tag("h1", "Foo"), p("bar\nbaz")])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -89,7 +96,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "linient we are" do
       markdown = "> bar\nbaz\n> foo\n"
-      ast      = bq(p("bar\nbaz\nfoo"))
+      ast = bq(p("bar\nbaz\nfoo"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -97,7 +104,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "lists in blockquotes? Coming up Sir" do
       markdown = "> - foo\n- bar\n"
-      ast      = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
+      ast = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -105,7 +112,7 @@ defmodule Acceptance.Ast.BlockQuotesTest do
 
     test "indented case" do
       markdown = " > - foo\n- bar\n"
-      ast      = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
+      ast = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -115,27 +122,28 @@ defmodule Acceptance.Ast.BlockQuotesTest do
   describe "Nested blockquotes" do
     test "just two blocks" do
       markdown = ">>foo\n> bar\n"
-      ast      = bq(bq(p("foo\nbar")))
+      ast = bq(bq(p("foo\nbar")))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
-    test "attached list" do 
+    test "attached list" do
       markdown = " >- foo\n- bar\n"
-      ast      = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
+      ast = [bq(tag("ul", tag("li", "foo"))), tag("ul", tag("li", "bar"))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
-
   defp bq(content, atts \\ []) do
     tag("blockquote", content, atts)
   end
 
-  defp br, do: void_tag("br")
+  defp br do
+    void_tag("br")
+  end
 
   defp brlist(elements) do
     elements
diff --git a/test/acceptance/ast/comment_test.exs b/test/acceptance/ast/comment_test.exs
index a8920e5..1188f6b 100644
--- a/test/acceptance/ast/comment_test.exs
+++ b/test/acceptance/ast/comment_test.exs
@@ -6,7 +6,7 @@ defmodule Acceptance.Ast.CommentTest do
   describe "HTML Comments" do
     test "one line" do
       markdown = "<!-- Hello -->"
-      ast      = {:comment, [], [" Hello "], %{comment: true}}
+      ast = {:comment, [], [" Hello "], %{comment: true}}
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -14,7 +14,7 @@ defmodule Acceptance.Ast.CommentTest do
 
     test "more lines" do
       markdown = "<!-- Hello\n World-->"
-      ast      = {:comment, [], [" Hello", " World"], %{comment: true}}
+      ast = {:comment, [], [" Hello", " World"], %{comment: true}}
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -22,7 +22,7 @@ defmodule Acceptance.Ast.CommentTest do
 
     test "what about the closing" do
       markdown = "<!-- Hello\n World -->garbish"
-      ast      = {:comment, [], [" Hello", " World "], %{comment: true}}
+      ast = {:comment, [], [" Hello", " World "], %{comment: true}}
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -34,7 +34,8 @@ defmodule Acceptance.Ast.CommentTest do
       ```elixir
        World --> garbish
       """
-      ast      = {:comment, [], [" Hello", "```elixir", " World "], %{comment: true}}
+
+      ast = {:comment, [], [" Hello", "```elixir", " World "], %{comment: true}}
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -45,12 +46,13 @@ defmodule Acceptance.Ast.CommentTest do
       <!-- Hello
       ```elixir
       """
-      ast      = {:comment, [], [" Hello", "```elixir"], %{comment: true}}
+
+      ast = {:comment, [], [" Hello", "```elixir"], %{comment: true}}
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
   end
 end
-# SPDX-License-Identifier: Apache-2.0
 
+# SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/del_test.exs b/test/acceptance/ast/del_test.exs
index ada1163..5dd1b55 100644
--- a/test/acceptance/ast/del_test.exs
+++ b/test/acceptance/ast/del_test.exs
@@ -56,12 +56,23 @@ defmodule Acceptance.Ast.DelTest do
 
     test "full of tildes" do
       markdown = "~Not ~~yes~~ ~~a trap~ this one~~ what ~else~?  ~~!~~"
-      ast = [p([
-        "~Not ", tag("del", "yes"), " ", tag("del", "a trap~ this one"), " what ~else~?  ", tag("del", "!")])]
+
+      ast = [
+        p([
+          "~Not ",
+          tag("del", "yes"),
+          " ",
+          tag("del", "a trap~ this one"),
+          " what ~else~?  ",
+          tag("del", "!")
+        ])
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/diverse_test.exs b/test/acceptance/ast/diverse_test.exs
index ca4fbb6..cba6ec9 100644
--- a/test/acceptance/ast/diverse_test.exs
+++ b/test/acceptance/ast/diverse_test.exs
@@ -6,7 +6,7 @@ defmodule Acceptance.Ast.DiverseTest do
   describe "etc" do
     test "entity" do
       markdown = "`f&ouml;&ouml;`\n"
-      ast      = p(tag("code", "f&ouml;&ouml;", [class: "inline"], %{line: 1}))
+      ast = p(tag("code", "f&ouml;&ouml;", [class: "inline"], %{line: 1}))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -14,21 +14,20 @@ defmodule Acceptance.Ast.DiverseTest do
 
     test "spaec preserving" do
       markdown = "Multiple     spaces\n"
-      ast      = p("Multiple     spaces")
+      ast = p("Multiple     spaces")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
     test "syntax errors" do
-      markdown ="A\nB\n="
-      ast      = [p("A\nB"), p([])]
-      messages = [{:warning, 3, "Unexpected line =" }]
+      markdown = "A\nB\n="
+      ast = [p("A\nB"), p([])]
+      messages = [{:warning, 3, "Unexpected line ="}]
 
       assert as_ast(markdown) == {:error, ast, messages}
     end
-   end
-
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/emphasis_test.exs b/test/acceptance/ast/emphasis_test.exs
index d8a3d7b..6989953 100644
--- a/test/acceptance/ast/emphasis_test.exs
+++ b/test/acceptance/ast/emphasis_test.exs
@@ -14,7 +14,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "imporatant quotes" do
       markdown = "a*\"foo\"*\n"
-      ast      = p(["a", em("\"foo\"")])
+      ast = p(["a", em("\"foo\"")])
       messages = []
 
       assert as_ast(markdown, smartypants: false) == {:ok, [ast], messages}
@@ -22,7 +22,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "important _" do
       markdown = "_foo bar_\n"
-      ast      = p(em("foo bar"))
+      ast = p(em("foo bar"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -30,7 +30,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "dont get confused" do
       markdown = "_foo*\n"
-      ast      = p("_foo*")
+      ast = p("_foo*")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -38,7 +38,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "that should make you smile" do
       markdown = "_foo_bar_baz_\n"
-      ast      = p(em("foo_bar_baz"))
+      ast = p(em("foo_bar_baz"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -46,7 +46,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "stronger" do
       markdown = "**foo bar**\n"
-      ast      = p(strong("foo bar"))
+      ast = p(strong("foo bar"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -54,7 +54,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "stronger insisde" do
       markdown = "foo**bar**\n"
-      ast      = p(["foo", strong("bar")])
+      ast = p(["foo", strong("bar")])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -62,7 +62,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "stronger together" do
       markdown = "__foo bar__\n"
-      ast      = p(strong("foo bar"))
+      ast = p(strong("foo bar"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -70,7 +70,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "let no evil underscores divide us" do
       markdown = "**foo__bar**\n"
-      ast      = p(strong("foo__bar"))
+      ast = p(strong("foo__bar"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -78,7 +78,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "strong **and** stronger" do
       markdown = "*(**foo**)*\n"
-      ast      = p(em(["(", strong("foo"), ")"]))
+      ast = p(em(["(", strong("foo"), ")"]))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -86,7 +86,7 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "stronger **and** strong" do
       markdown = "**(*foo*)**\n"
-      ast      = p(strong(["(", em("foo"), ")"]))
+      ast = p(strong(["(", em("foo"), ")"]))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -94,14 +94,19 @@ defmodule Acceptance.Ast.EmphasisTest do
 
     test "one is not strong enough" do
       markdown = "foo*\n"
-      ast      = p("foo*")
+      ast = p("foo*")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
-    defp em(content), do: tag("em", content)
-    defp strong(content), do: tag("strong", content)
+    defp em(content) do
+      tag("em", content)
+    end
+
+    defp strong(content) do
+      tag("strong", content)
+    end
   end
 end
 
diff --git a/test/acceptance/ast/empty_test.exs b/test/acceptance/ast/empty_test.exs
index a86e8ba..4792a56 100644
--- a/test/acceptance/ast/empty_test.exs
+++ b/test/acceptance/ast/empty_test.exs
@@ -5,7 +5,7 @@ defmodule Acceptance.Ast.EmptyTest do
 
   test "empty" do
     markdown = ""
-    ast     = []
+    ast = []
     messages = []
 
     assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
@@ -13,10 +13,9 @@ defmodule Acceptance.Ast.EmptyTest do
 
   test "almost empty" do
     markdown = "  "
-    ast     = []
+    ast = []
     messages = []
 
     assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
   end
-  
 end
diff --git a/test/acceptance/ast/escape_test.exs b/test/acceptance/ast/escape_test.exs
index f5f66a2..0999681 100644
--- a/test/acceptance/ast/escape_test.exs
+++ b/test/acceptance/ast/escape_test.exs
@@ -6,15 +6,18 @@ defmodule Acceptance.Ast.EscapeTest do
   describe "Escapes" do
     test "dizzy rhs?" do
       markdown = "\\\\!\\\\\""
-      ast      = p("\\!\\\"")
-      messages = [{:deprecated, 0, "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}]
+      ast = p("\\!\\\"")
+
+      messages = [
+        {:deprecated, 0, "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}
+      ]
 
       assert as_ast(markdown, smartypants: true) == {:ok, [ast], messages}
     end
 
     test "dizzy? lhs" do
       markdown = "\\\\!\\\\\""
-      ast      = p("\\!\\\"")
+      ast = p("\\!\\\"")
       messages = []
 
       assert as_ast(markdown, smartypants: false) == {:ok, [ast], messages}
@@ -22,7 +25,7 @@ defmodule Acceptance.Ast.EscapeTest do
 
     test "obviously" do
       markdown = "\\`no code"
-      ast      = p("`no code")
+      ast = p("`no code")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -30,7 +33,7 @@ defmodule Acceptance.Ast.EscapeTest do
 
     test "less obviously - escpe the escapes" do
       markdown = "\\\\` code`"
-      ast      = p(["\\", tag("code", "code", [class: "inline"], %{line: 1})])
+      ast = p(["\\", tag("code", "code", [class: "inline"], %{line: 1})])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -38,23 +41,29 @@ defmodule Acceptance.Ast.EscapeTest do
 
     test "don't ask me" do
       markdown = "\\\\ \\"
-      ast      = p("\\ \\")
+      ast = p("\\ \\")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
     test "a plenty of nots" do
-      markdown = "\\*not emphasized\\*\n\\[not a link](/foo)\n\\`not code`\n1\\. not a list\n\\* not a list\n\\# not a header\n\\[foo]: /url \"not a reference\"\n"
-      ast      = p(["*not emphasized*\n[not a link](/foo)\n`not code`\n1. not a list\n* not a list\n# not a header\n[foo]: /url \"not a reference\""])
-      messages = [{:warning, 3, "Closing unclosed backquotes ` at end of input" }]
+      markdown =
+        "\\*not emphasized\\*\n\\[not a link](/foo)\n\\`not code`\n1\\. not a list\n\\* not a list\n\\# not a header\n\\[foo]: /url \"not a reference\"\n"
+
+      ast =
+        p([
+          "*not emphasized*\n[not a link](/foo)\n`not code`\n1. not a list\n* not a list\n# not a header\n[foo]: /url \"not a reference\""
+        ])
+
+      messages = [{:warning, 3, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown, smartypants: false) == {:error, [ast], messages}
     end
 
     test "let us escape (again)" do
       markdown = "\\\\*emphasis*\n"
-      ast      = p(["\\", tag("em", "emphasis")])
+      ast = p(["\\", tag("em", "emphasis")])
       messages = []
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
diff --git a/test/acceptance/ast/fenced_code_blocks_test.exs b/test/acceptance/ast/fenced_code_blocks_test.exs
index 4ac58f5..fd1bd25 100644
--- a/test/acceptance/ast/fenced_code_blocks_test.exs
+++ b/test/acceptance/ast/fenced_code_blocks_test.exs
@@ -4,7 +4,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
   describe "Fenced code blocks" do
     test "no lang" do
       markdown = "```\n<\n >\n```\n"
-      ast      = pre_code("<\n >")
+      ast = pre_code("<\n >")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -12,7 +12,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "still no lang" do
       markdown = "~~~\n<\n >\n~~~\n"
-      ast      = pre_code("<\n >")
+      ast = pre_code("<\n >")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -20,7 +20,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "longer with shorter inside" do
       markdown = "~~~~\n<\n~~~\nsome code\n ~~~\n >\n~~~~\n"
-      ast      = pre_code("<\n~~~\nsome code\n ~~~\n >")
+      ast = pre_code("<\n~~~\nsome code\n ~~~\n >")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -28,7 +28,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "elixir 's the name" do
       markdown = "```elixir\naaa\n~~~\n```\n"
-      ast      = tag("pre", tag("code", "aaa\n~~~", class: "elixir"))
+      ast = tag("pre", tag("code", "aaa\n~~~", class: "elixir"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -36,7 +36,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "elixir with longer fence" do
       markdown = "`````elixir\n````\n```\n````\n`````"
-      ast      = tag("pre", tag("code", "````\n```\n````", class: "elixir"))
+      ast = tag("pre", tag("code", "````\n```\n````", class: "elixir"))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -44,7 +44,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "with a code_class_prefix" do
       markdown = "```elixir\naaa\n~~~\n```\n"
-      ast      = tag("pre", tag("code", "aaa\n~~~", class: "elixir lang-elixir"))
+      ast = tag("pre", tag("code", "aaa\n~~~", class: "elixir lang-elixir"))
       messages = []
 
       assert as_ast(markdown, code_class_prefix: "lang-") == {:ok, [ast], messages}
@@ -52,7 +52,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "with more code_class_preficis" do
       markdown = "```elixir\naaa\n~~~\n```\n"
-      ast      = tag("pre", tag("code", "aaa\n~~~", class: "elixir lang-elixir syntax-elixir"))
+      ast = tag("pre", tag("code", "aaa\n~~~", class: "elixir lang-elixir syntax-elixir"))
       messages = []
 
       assert as_ast(markdown, code_class_prefix: "lang- syntax-") == {:ok, [ast], messages}
@@ -60,7 +60,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "look mam, more lines" do
       markdown = "   ```\naaa\nb\n  ```\n"
-      ast      = pre_code("aaa\nb")
+      ast = pre_code("aaa\nb")
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -77,6 +77,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
        c
       - d
       """
+
       ast = [
         ul([
           li("a"),
@@ -101,6 +102,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
           c
       - d
       """
+
       ast = [
         ul([
           li([
@@ -118,6 +120,7 @@ defmodule Acceptance.Ast.FencedCodeBlocksTest do
 
     test "fenced with tag" do
       markdown = "```\n\"<nav>\n  <ul></ul>\n</nav>\"\n```\n\n## Header\n\nbar"
+
       ast = [
         {"pre", [], [{"code", [], ["\"<nav>\n  <ul></ul>\n</nav>\""], %{}}], %{}},
         {"h2", [], ["Header"], %{}},
diff --git a/test/acceptance/ast/footnotes/error_cases_test.exs b/test/acceptance/ast/footnotes/error_cases_test.exs
index 7a18913..9b90e6a 100644
--- a/test/acceptance/ast/footnotes/error_cases_test.exs
+++ b/test/acceptance/ast/footnotes/error_cases_test.exs
@@ -35,4 +35,5 @@ defmodule Acceptance.Ast.Footnotes.ErrorCasesTest do
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/footnotes/fn_in_lists_test.exs b/test/acceptance/ast/footnotes/fn_in_lists_test.exs
index 0cc4598..8696b1e 100644
--- a/test/acceptance/ast/footnotes/fn_in_lists_test.exs
+++ b/test/acceptance/ast/footnotes/fn_in_lists_test.exs
@@ -15,12 +15,13 @@ defmodule Test.Acceptance.Ast.Footnotes.FnInListsTest do
 
       ast = [
         ul(
-          (li([
-          "A line with",
-          footnote(1),
-          " two references",
-          footnote(2)
-        ]))),
+          li([
+            "A line with",
+            footnote(1),
+            " two references",
+            footnote(2)
+          ])
+        ),
         footnotes([
           footnote_def(1, p(["Footnote ", tag("strong", "one")])),
           footnote_def(2, [
@@ -61,20 +62,22 @@ defmodule Test.Acceptance.Ast.Footnotes.FnInListsTest do
       """
 
       ast = [
-        (ul(li(tags("p",[
-          "N.B.",
-          ["A line with one reference",
-          footnote(2)]
-        ])))),
-
+        ul(
+          li(
+            tags("p", [
+              "N.B.",
+              ["A line with one reference", footnote(2)]
+            ])
+          )
+        ),
         footnotes(
-        footnote_def(
-        2,
-        tag("ul", [
-          tag("li", "Footnote 2.1"),
-          tag("li", "Footnote 2.2")
-        ])
-        )
+          footnote_def(
+            2,
+            tag("ul", [
+              tag("li", "Footnote 2.1"),
+              tag("li", "Footnote 2.2")
+            ])
+          )
         )
       ]
 
@@ -82,6 +85,6 @@ defmodule Test.Acceptance.Ast.Footnotes.FnInListsTest do
       assert_asts_are_equal(result_ast, ast)
     end
   end
-
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/footnotes/multiple_fn_test.exs b/test/acceptance/ast/footnotes/multiple_fn_test.exs
index 5112210..ca98bcc 100644
--- a/test/acceptance/ast/footnotes/multiple_fn_test.exs
+++ b/test/acceptance/ast/footnotes/multiple_fn_test.exs
@@ -50,20 +50,19 @@ defmodule Test.Acceptance.Ast.Footnotes.MultipleFnTest do
           footnote(2)
         ]),
         footnotes(
-        footnote_def(
-        2,
-        tag("ul", [
-          tag("li", "Footnote 2.1"),
-          tag("li", "Footnote 2.2")
-        ])
-        )
+          footnote_def(
+            2,
+            tag("ul", [
+              tag("li", "Footnote 2.1"),
+              tag("li", "Footnote 2.2")
+            ])
+          )
         )
       ]
 
       {:ok, result_ast, []} = as_ast(markdown, footnotes: true)
       assert_asts_are_equal(result_ast, ast)
     end
-
   end
 
   describe "three footnotes" do
diff --git a/test/acceptance/ast/footnotes/single_footnote_test.exs b/test/acceptance/ast/footnotes/single_footnote_test.exs
index af9562a..3811039 100644
--- a/test/acceptance/ast/footnotes/single_footnote_test.exs
+++ b/test/acceptance/ast/footnotes/single_footnote_test.exs
@@ -56,7 +56,6 @@ defmodule Acceptance.Ast.Footnotes.SingleFootnoteTest do
         ])
       ]
 
-
       {:ok, result_ast, []} = as_ast(markdown, footnotes: true)
       assert_asts_are_equal(result_ast, ast)
     end
@@ -69,7 +68,6 @@ defmodule Acceptance.Ast.Footnotes.SingleFootnoteTest do
         p("[^1]: bar baz\ngoo")
       ]
 
-
       {:ok, result_ast, []} = as_ast(markdown, footnotes: true)
       assert_asts_are_equal(result_ast, ast)
     end
diff --git a/test/acceptance/ast/hard_line_breaks_test.exs b/test/acceptance/ast/hard_line_breaks_test.exs
index 58ec407..d2fcc39 100644
--- a/test/acceptance/ast/hard_line_breaks_test.exs
+++ b/test/acceptance/ast/hard_line_breaks_test.exs
@@ -5,8 +5,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
   describe "gfm" do
     test "hard line breaks are enabled" do
       markdown = "line 1\nline 2\\\nline 3"
-      html     = "<p>line 1\nline 2<br />line 3</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2<br />line 3</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,8 +14,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
 
     test "hard line breaks are enabled only inside paras" do
       markdown = "line 1\nline 2\\\n\nline 3"
-      html     = "<p>line 1\nline 2\\</p>\n<p>line 3</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\</p>\n<p>line 3</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -23,8 +23,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
 
     test "hard line breaks are not enabled at the end" do
       markdown = "line 1\nline 2\\\n"
-      html     = "<p>line 1\nline 2\\</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -34,8 +34,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
   describe "no gfm" do
     test "hard line breaks are not enabled" do
       markdown = "line 1\nline 2\\\nline 3"
-      html     = "<p>line 1\nline 2\\\nline 3</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\\nline 3</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, gfm: false) == {:ok, ast, messages}
@@ -43,8 +43,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
 
     test "hard line breaks are not enabled alternate gfm value" do
       markdown = "line 1\nline 2\\\nline 3"
-      html     = "<p>line 1\nline 2\\\nline 3</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\\nline 3</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, gfm: nil) == {:ok, ast, messages}
@@ -52,8 +52,8 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
 
     test "hard line breaks are enabled only inside paras" do
       markdown = "line 1\nline 2\\\n\nline 3"
-      html     = "<p>line 1\nline 2\\</p>\n<p>line 3</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\</p>\n<p>line 3</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, gfm: false) == {:ok, ast, messages}
@@ -61,14 +61,13 @@ defmodule Acceptance.Ast.HardLineBreaksTest do
 
     test "hard line breaks are not enabled at the end" do
       markdown = "line 1\nline 2\\\n"
-      html     = "<p>line 1\nline 2\\</p>\n"
-      ast      = parse_html(html)
+      html = "<p>line 1\nline 2\\</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, gfm: false) == {:ok, ast, messages}
     end
   end
-
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/horizontal_rules_test.exs b/test/acceptance/ast/horizontal_rules_test.exs
index 6c4c059..c8701e1 100644
--- a/test/acceptance/ast/horizontal_rules_test.exs
+++ b/test/acceptance/ast/horizontal_rules_test.exs
@@ -4,11 +4,10 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
   import EarmarkAstDsl
 
   describe "Horizontal rules" do
-
     test "thick, thin & medium" do
       markdown = "***\n---\n___\n"
-      html     = "<hr class=\"thick\"/>\n<hr class=\"thin\"/>\n<hr class=\"medium\"/>\n"
-      ast      = parse_html(html)
+      html = "<hr class=\"thick\"/>\n<hr class=\"thin\"/>\n<hr class=\"medium\"/>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,8 +15,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "not a rule" do
       markdown = "+++\n"
-      html     = "<p>+++</p>\n"
-      ast      = parse_html(html)
+      html = "<p>+++</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -25,8 +24,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "a dash is just text" do
       markdown = "-\nTest"
-      html     = "<p>-\nTest</p>"
-      ast      = parse_html(html)
+      html = "<p>-\nTest</p>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -34,8 +33,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "two dashes are just text" do
       markdown = "--\nTest"
-      html     = "<p>--\nTest</p>"
-      ast      = parse_html(html)
+      html = "<p>--\nTest</p>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -43,8 +42,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "not in code" do
       markdown = "    ***\n    \n     a"
-      html     = "<pre><code>***\n\n a</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>***\n\n a</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -52,8 +51,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "not in code, second line" do
       markdown = "Foo\n    ***\n"
-      html     = "<p>Foo</p>\n<pre><code>***</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<p>Foo</p>\n<pre><code>***</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -61,8 +60,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "medium, long" do
       markdown = "_____________________________________\n"
-      html     = "<hr class=\"medium\"/>\n"
-      ast      = parse_html(html)
+      html = "<hr class=\"medium\"/>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -70,7 +69,7 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "emmed, so to speak" do
       markdown = " *-*\n"
-      ast      = [p([" ", tag("em", "-")])]
+      ast = [p([" ", tag("em", "-")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -79,7 +78,7 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
     @tag :wip
     test "subindex" do
       markdown = "This is H~2~O, only water"
-      ast      = [p(["This is H", tag("sub", "2"), "O, only water"])]
+      ast = [p(["This is H", tag("sub", "2"), "O, only water"])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -88,7 +87,7 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
     @tag :wip
     test "superindex" do
       markdown = "we get O(n^2^)"
-      ast      = [p(["we get O(n", tag("sup", "2"), ")"])]
+      ast = [p(["we get O(n", tag("sup", "2"), ")"])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -96,8 +95,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "in lists" do
       markdown = "- foo\n***\n- bar\n"
-      html     = "<ul>\n<li>foo</li>\n</ul>\n<hr class=\"thick\"/>\n<ul>\n<li>bar</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>foo</li>\n</ul>\n<hr class=\"thick\"/>\n<ul>\n<li>bar</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -105,8 +104,8 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
 
     test "setext rules over rules (why am I soo witty?)" do
       markdown = "Foo\n---\nbar\n"
-      html     = "<h2>Foo</h2>\n<p>bar</p>\n"
-      ast      = parse_html(html)
+      html = "<h2>Foo</h2>\n<p>bar</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -115,7 +114,7 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
     test "in lists, thick this time (why am I soo good to you?)" do
       markdown = "* Foo\n* * *\n* Bar\n"
       html = "<ul>\n<li>Foo</li>\n</ul>\n<hr class=\"thick\"/>\n<ul>\n<li>Bar</li>\n</ul>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -124,12 +123,14 @@ defmodule Acceptance.Ast.HorizontalRulesTest do
   describe "Horizontal Rules and IAL" do
     test "add a class and an id" do
       markdown = "***\n{: .custom}\n---\n{: .klass #id42}\n___\n{: hello=world}\n"
-      html     = "<hr class=\"custom thick\" />\n<hr class=\"klass thin\" id=\"id42\" />\n<hr class=\"medium\" hello=\"world\" />\n"
-      ast      = parse_html(html)
+
+      html =
+        "<hr class=\"custom thick\" />\n<hr class=\"klass thin\" id=\"id42\" />\n<hr class=\"medium\" hello=\"world\" />\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
-
     end
   end
 end
diff --git a/test/acceptance/ast/html/block/annotated_block_test.exs b/test/acceptance/ast/html/block/annotated_block_test.exs
index 116d14d..e9b07e7 100644
--- a/test/acceptance/ast/html/block/annotated_block_test.exs
+++ b/test/acceptance/ast/html/block/annotated_block_test.exs
@@ -20,6 +20,7 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
 
       assert as_ast(markdown, annotations: ~r{\*:}) == {:ok, ast, messages}
     end
+
     test "tables are just tables again (or was that mountains?)" do
       markdown =
         "<table> *: my_table\n  <tr>\n    <td>\n           hi\n    </td>\n  </tr>\n</table>\n\nokay.\n"
@@ -57,6 +58,7 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
 
       assert as_ast(markdown, annotations: @annotations) == {:ok, ast, messages}
     end
+
     test "we are leaving html alone" do
       markdown = "<div>\n*Emphasized* text.\n</div>*: one line"
       ast = [vtag_annotated("div", "*Emphasized* text.", "*: one line")]
@@ -94,10 +96,12 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
     test "area" do
       markdown =
         "<area shape=\"rect\" coords=\"0,0,1,1\" href=\"xxx\" alt=\"yyy\">\n**emphasized** text"
+
       ast = [
         vtag("area", nil, shape: "rect", coords: "0,0,1,1", href: "xxx", alt: "yyy"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown, annotations: @annotations) == {:ok, ast, messages}
@@ -105,10 +109,12 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
 
     test "we are outside the void now (lucky us)" do
       markdown = "<br>\n**emphasized** text"
+
       ast = [
         vtag("br"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown, annotations: @annotations) == {:ok, ast, messages}
@@ -132,10 +138,12 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
 
     test "not everybody knows this one (hint: take a break)" do
       markdown = "<wbr>\n**emphasized** text"
+
       ast = [
         vtag("wbr"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown, annotations: @annotations) == {:ok, ast, messages}
@@ -177,11 +185,14 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
 
     test "self closing block elements close para, atts and spaces do not matter" do
       markdown = "alpha\n<div class=\"first\"   />beta\ngamma"
+
       ast = [
         p("alpha"),
         vtag("div", nil, class: "first"),
         "beta",
-        p("gamma")]
+        p("gamma")
+      ]
+
       messages = []
 
       assert as_ast(markdown, annotations: @annotations) == {:ok, ast, messages}
@@ -278,6 +289,7 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
     test "...nor is this" do
       markdown = "<div>\nline\n<hello></div>"
       ast = [vtag("div", ["line", "<hello></div>"])]
+
       messages = [
         {:warning, 1, "Failed to find closing <div>"},
         {:warning, 3, "Failed to find closing <hello>"}
@@ -318,7 +330,8 @@ defmodule Acceptance.Ast.Html.Block.AnnotatedBlockTest do
       <span>text</span> // second
       </div> // third
       """
-      ast = [ vtag_annotated("div", "<span>text</span> ", "// first") ]
+
+      ast = [vtag_annotated("div", "<span>text</span> ", "// first")]
       messages = []
 
       assert as_ast(markdown, annotations: "//") == {:ok, ast, messages}
diff --git a/test/acceptance/ast/html/block/unannotated_block_test.exs b/test/acceptance/ast/html/block/unannotated_block_test.exs
index 0437122..5778af3 100644
--- a/test/acceptance/ast/html/block/unannotated_block_test.exs
+++ b/test/acceptance/ast/html/block/unannotated_block_test.exs
@@ -64,10 +64,12 @@ defmodule Acceptance.Ast.Html.Block.UnannotatedBlockTest do
     test "area" do
       markdown =
         "<area shape=\"rect\" coords=\"0,0,1,1\" href=\"xxx\" alt=\"yyy\">\n**emphasized** text"
+
       ast = [
         vtag("area", nil, shape: "rect", coords: "0,0,1,1", href: "xxx", alt: "yyy"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -75,10 +77,12 @@ defmodule Acceptance.Ast.Html.Block.UnannotatedBlockTest do
 
     test "we are outside the void now (lucky us)" do
       markdown = "<br>\n**emphasized** text"
+
       ast = [
         vtag("br"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -102,10 +106,12 @@ defmodule Acceptance.Ast.Html.Block.UnannotatedBlockTest do
 
     test "not everybody knows this one (hint: take a break)" do
       markdown = "<wbr>\n**emphasized** text"
+
       ast = [
         vtag("wbr"),
         p([tag("strong", "emphasized"), " text"])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -147,11 +153,14 @@ defmodule Acceptance.Ast.Html.Block.UnannotatedBlockTest do
 
     test "self closing block elements close para, atts and spaces do not matter" do
       markdown = "alpha\n<div class=\"first\"   />beta\ngamma"
+
       ast = [
         p("alpha"),
         vtag("div", nil, class: "first"),
         "beta",
-        p("gamma")]
+        p("gamma")
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -248,6 +257,7 @@ defmodule Acceptance.Ast.Html.Block.UnannotatedBlockTest do
     test "...nor is this" do
       markdown = "<div>\nline\n<hello></div>"
       ast = [vtag("div", ["line", "<hello></div>"])]
+
       messages = [
         {:warning, 1, "Failed to find closing <div>"},
         {:warning, 3, "Failed to find closing <hello>"}
diff --git a/test/acceptance/ast/html/one_line/annotated_oneline_test.exs b/test/acceptance/ast/html/one_line/annotated_oneline_test.exs
index 4b8ac60..9dc40cc 100644
--- a/test/acceptance/ast/html/one_line/annotated_oneline_test.exs
+++ b/test/acceptance/ast/html/one_line/annotated_oneline_test.exs
@@ -6,14 +6,15 @@ defmodule Acceptance.Ast.Html.Oneline.AnnotatedOnelineTest do
   describe "oneline tags" do
     test "really simple -- non-regression" do
       markdown = "<h1>Headline</h1>"
-      ast      = [vtag("h1", "Headline")]
+      ast = [vtag("h1", "Headline")]
       messages = []
 
       assert as_ast(markdown, annotations: "//") == {:ok, ast, messages}
     end
+
     test "really simple" do
       markdown = "<h1>Headline</h1> :- main"
-      ast      = [vtag_annotated("h1", "Headline", ":- main")]
+      ast = [vtag_annotated("h1", "Headline", ":- main")]
       messages = []
 
       assert as_ast(markdown, annotations: ":-") == {:ok, ast, messages}
@@ -21,19 +22,18 @@ defmodule Acceptance.Ast.Html.Oneline.AnnotatedOnelineTest do
 
     test "a little bit more complicated -- non-regression" do
       markdown = ~s{<p align="center"><img src="image.svg"/></p>}
-      ast      = [vtag("p", ["<img src=\"image.svg\"/>"], align: "center")]
+      ast = [vtag("p", ["<img src=\"image.svg\"/>"], align: "center")]
       messages = []
 
       assert as_ast(markdown, annotations: "%%%") == {:ok, ast, messages}
     end
+
     test "a little bit more complicated" do
       markdown = ~s{<p align="center"><img src="image.svg"/></p> %%% 42}
-      ast      = [vtag_annotated("p", ["<img src=\"image.svg\"/>"], "%%% 42", align: "center")]
+      ast = [vtag_annotated("p", ["<img src=\"image.svg\"/>"], "%%% 42", align: "center")]
       messages = []
 
       assert as_ast(markdown, annotations: "%%%") == {:ok, ast, messages}
     end
   end
-
 end
-
diff --git a/test/acceptance/ast/html/one_line/attributes_test.exs b/test/acceptance/ast/html/one_line/attributes_test.exs
index b6ab43c..7ae60fe 100644
--- a/test/acceptance/ast/html/one_line/attributes_test.exs
+++ b/test/acceptance/ast/html/one_line/attributes_test.exs
@@ -6,7 +6,7 @@ defmodule Acceptance.Ast.Html.Oneline.AttributesTest do
   describe "strict tags syntax (non regression)" do
     test "really simple" do
       markdown = ~s{<p class="one" data-x="1" />}
-      ast      = [vtag("p", [], class: "one", "data-x": 1)]
+      ast = [vtag("p", [], class: "one", "data-x": 1)]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,7 +16,7 @@ defmodule Acceptance.Ast.Html.Oneline.AttributesTest do
   describe "spaces around =" do
     test "still quite simple" do
       markdown = ~s{<p class ="one" data-x = "1" />}
-      ast      = [vtag("p", [], class: "one", "data-x": 1)]
+      ast = [vtag("p", [], class: "one", "data-x": 1)]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -26,7 +26,7 @@ defmodule Acceptance.Ast.Html.Oneline.AttributesTest do
   describe "unquoted attribute values" do
     test "no special characters inside the value" do
       markdown = ~s{<p class=one data-x=1 />}
-      ast      = [vtag("p", [], class: "one", "data-x": 1)]
+      ast = [vtag("p", [], class: "one", "data-x": 1)]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -34,7 +34,7 @@ defmodule Acceptance.Ast.Html.Oneline.AttributesTest do
 
     test "and accepts spaces around the =" do
       markdown = ~s{<p class = one data-x= 1 />}
-      ast      = [vtag("p", [], class: "one", "data-x": 1)]
+      ast = [vtag("p", [], class: "one", "data-x": 1)]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -60,11 +60,12 @@ defmodule Acceptance.Ast.Html.Oneline.AttributesTest do
   describe "valueless attributes" do
     test "gets its name as a value" do
       markdown = ~s{<p class  data-x />}
-      ast      = [vtag("p", [], class: "class", "data-x": "data-x")]
+      ast = [vtag("p", [], class: "class", "data-x": "data-x")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/html/one_line/unannotated_oneline_test.exs b/test/acceptance/ast/html/one_line/unannotated_oneline_test.exs
index 891281e..f1b902a 100644
--- a/test/acceptance/ast/html/one_line/unannotated_oneline_test.exs
+++ b/test/acceptance/ast/html/one_line/unannotated_oneline_test.exs
@@ -6,7 +6,7 @@ defmodule Acceptance.Ast.Html.Oneline.UnannotatedOnelineTest do
   describe "oneline tags" do
     test "really simple" do
       markdown = "<h1>Headline</h1>"
-      ast      = [vtag("h1", "Headline")]
+      ast = [vtag("h1", "Headline")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,7 +14,7 @@ defmodule Acceptance.Ast.Html.Oneline.UnannotatedOnelineTest do
 
     test "a little bit more complicated" do
       markdown = ~s{<p align="center"><img src="image.svg"/></p>}
-      ast      = [vtag("p", ["<img src=\"image.svg\"/>"], align: "center")]
+      ast = [vtag("p", ["<img src=\"image.svg\"/>"], align: "center")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
diff --git a/test/acceptance/ast/html/permissive_test.exs b/test/acceptance/ast/html/permissive_test.exs
index 23f9d38..801a496 100644
--- a/test/acceptance/ast/html/permissive_test.exs
+++ b/test/acceptance/ast/html/permissive_test.exs
@@ -1,13 +1,13 @@
 defmodule Acceptance.Ast.Html.PermissiveTest do
   use ExUnit.Case, async: true
   import Support.Helpers, only: [as_ast: 1]
-  
+
   @verbatim %{verbatim: true}
 
   describe "some nesting" do
     test "simple case" do
       markdown = "<div>\ncontent\n </div>"
-      ast      = [{"div", [], ["content"], @verbatim}]
+      ast = [{"div", [], ["content"], @verbatim}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -15,8 +15,7 @@ defmodule Acceptance.Ast.Html.PermissiveTest do
 
     test "more nesting" do
       markdown = "<div>\n<section>\n<span>content</span>\n</section>\n</div>"
-      ast      = [{"div", [],
-          ["<section>", "<span>content</span>", "</section>"], @verbatim}]
+      ast = [{"div", [], ["<section>", "<span>content</span>", "</section>"], @verbatim}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -25,11 +24,13 @@ defmodule Acceptance.Ast.Html.PermissiveTest do
 
   describe "arbitrary tags" do
     # Needs a fix with issue [#326](https://github.com/pragdave/earmark/issues/326)
-    test "mixture of tags (was regtest #103)" do 
+    test "mixture of tags (was regtest #103)" do
       markdown = "<x>a\n<y></y>\n<y>\n<z>\n</z>\n<z>\n</x>"
-      ast      = [{"x", ~c"", ["a", "<y></y>", "<y>", "<z>", "</z>", "<z>"], @verbatim}]
-      messages = Enum.zip([1, 3, 6], ~w[x y z])
-                 |> Enum.map(fn {lnb, tag} -> {:warning, lnb, "Failed to find closing <#{tag}>"} end)
+      ast = [{"x", ~c"", ["a", "<y></y>", "<y>", "<z>", "</z>", "<z>"], @verbatim}]
+
+      messages =
+        Enum.zip([1, 3, 6], ~w[x y z])
+        |> Enum.map(fn {lnb, tag} -> {:warning, lnb, "Failed to find closing <#{tag}>"} end)
 
       assert as_ast(markdown) == {:error, ast, messages}
     end
@@ -37,4 +38,3 @@ defmodule Acceptance.Ast.Html.PermissiveTest do
 end
 
 # SPDX-License-Identifier: Apache-2.0
-
diff --git a/test/acceptance/ast/ial_test.exs b/test/acceptance/ast/ial_test.exs
index e30f081..f5c9a67 100644
--- a/test/acceptance/ast/ial_test.exs
+++ b/test/acceptance/ast/ial_test.exs
@@ -7,7 +7,7 @@ defmodule Acceptance.Ast.IalTest do
     test "link with simple ial" do
       markdown = "[link](url){: .classy}"
       html = "<p><a class=\"classy\" href=\"url\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,7 +16,7 @@ defmodule Acceptance.Ast.IalTest do
     test "code with simple ial" do
       markdown = "`some code`{: .classy}"
       html = "<p><code class=\"inline classy\">some code</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
 
       [{"p", [], [{"code", [{"class", "inline classy"}], ["some code"], %{line: 1}}], %{}}]
 
@@ -28,7 +28,7 @@ defmodule Acceptance.Ast.IalTest do
     test "blockquote and headers with simple ial" do
       markdown = "> ### some code {: .classy}"
       html = "<blockquote><h3 class=\"classy\">some code</h3></blockquote>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -37,7 +37,7 @@ defmodule Acceptance.Ast.IalTest do
     test "img with simple ial" do
       markdown = "![link](url){:#thatsme}"
       html = "<p><img alt=\"link\" id=\"thatsme\" src=\"url\" /></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -72,7 +72,7 @@ defmodule Acceptance.Ast.IalTest do
     test "not attached" do
       markdown = "[link](url) {:lang=fr}"
       html = "<p><a href=\"url\" lang=\"fr\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -80,7 +80,7 @@ defmodule Acceptance.Ast.IalTest do
 
     test "missing element for ial (was regtest #99)" do
       markdown = "{.hello}"
-      ast      = [p(markdown)]
+      ast = [p(markdown)]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -90,7 +90,7 @@ defmodule Acceptance.Ast.IalTest do
   describe "IAL multiple values" do
     test "text" do
       markdown = "text with IAL\n{:.class1 .class2}"
-      ast      = [{"p", [{"class", "class2 class1"}], ["text with IAL"], %{}}] 
+      ast = [{"p", [{"class", "class2 class1"}], ["text with IAL"], %{}}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -98,7 +98,7 @@ defmodule Acceptance.Ast.IalTest do
 
     test "block quotes" do
       markdown = "> bq with IAL\n{:.class1 .class2}"
-      ast      = [{"blockquote", [{"class", "class2 class1"}], [{"p", [], ["bq with IAL"], %{}}], %{}}] 
+      ast = [{"blockquote", [{"class", "class2 class1"}], [{"p", [], ["bq with IAL"], %{}}], %{}}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -106,7 +106,7 @@ defmodule Acceptance.Ast.IalTest do
 
     test "list item ignores IAL" do
       markdown = "- li with IAL\n{:.class1 .class2}"
-      ast      = [{"ul", [], [ {"li", [], ["li with IAL"], %{}}], %{}}]
+      ast = [{"ul", [], [{"li", [], ["li with IAL"], %{}}], %{}}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -114,7 +114,7 @@ defmodule Acceptance.Ast.IalTest do
 
     test "setext header" do
       markdown = "Headline\n=========\n{:.alpha .beta}"
-      ast      = [{"h1", [{"class", "beta alpha"}], ["Headline"], %{}}]
+      ast = [{"h1", [{"class", "beta alpha"}], ["Headline"], %{}}]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -125,7 +125,7 @@ defmodule Acceptance.Ast.IalTest do
     test "illegal format line one" do
       markdown = "[link](url){:incorrect}"
       html = "<p><a href=\"url\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = [{:warning, 1, "Illegal attributes [\"incorrect\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
@@ -134,27 +134,28 @@ defmodule Acceptance.Ast.IalTest do
     test "illegal format line two" do
       markdown = "a line\n[link](url) {:incorrect x=y}"
       html = "<p>a line\n<a href=\"url\" x=\"y\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = [{:warning, 2, "Illegal attributes [\"incorrect\"] ignored in IAL"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
     end
-
   end
 
   describe "just text" do
     test "nothing to ial with" do
       markdown = "{:error, {IncompatibleUnitError, message}}"
-      ast      = p("}")
+      ast = p("}")
+
       messages =
-      [{:warning, 1, "Illegal attributes [\"message\", \"{IncompatibleUnitError,\", \"error,\"] ignored in IAL"}]
+        [{:warning, 1, "Illegal attributes [\"message\", \"{IncompatibleUnitError,\", \"error,\"] ignored in IAL"}]
 
-      assert as_ast(markdown) == {:error, [ast], messages }
+      assert as_ast(markdown) == {:error, [ast], messages}
     end
 
     test "nothing to ial with (inside list)" do
       markdown = "* {:error, {IncompatibleUnitError, message}}"
-      ast      = tag("ul", tag("li", "}"))
+      ast = tag("ul", tag("li", "}"))
+
       messages =
         [{:warning, 1, "Illegal attributes [\"message\", \"{IncompatibleUnitError,\", \"error,\"] ignored in IAL"}]
 
diff --git a/test/acceptance/ast/indented_code_blocks_test.exs b/test/acceptance/ast/indented_code_blocks_test.exs
index 605ca5a..e749641 100644
--- a/test/acceptance/ast/indented_code_blocks_test.exs
+++ b/test/acceptance/ast/indented_code_blocks_test.exs
@@ -5,8 +5,8 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
   describe "Indented code blocks" do
     test "simple (but easy?)" do
       markdown = "    a simple\n      indented code block\n"
-      html     = "<pre><code>a simple\n  indented code block</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>a simple\n  indented code block</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,8 +14,8 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
 
     test "code is soo verbatim" do
       markdown = "    <a/>\n    *hi*\n\n    - one\n"
-      html     = "<pre><code>&lt;a/&gt;\n*hi*\n\n- one</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>&lt;a/&gt;\n*hi*\n\n- one</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -23,8 +23,8 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
 
     test "chunky bacon (RIP: Why)" do
       markdown = "    chunk1\n\n    chunk2\n  \n \n \n    chunk3\n"
-      html     = "<pre><code>chunk1\n\nchunk2\n\n\n\nchunk3</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>chunk1\n\nchunk2\n\n\n\nchunk3</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -32,8 +32,8 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
 
     test "foo and bar (now you are surprised!)" do
       markdown = "    foo\nbar\n"
-      html     = "<pre><code>foo</code></pre>\n<p>bar</p>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>foo</code></pre>\n<p>bar</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -42,19 +42,20 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
     test "not the alpha, not the omega (gamma maybe?)" do
       markdown = "\n    \n    foo\n    \n\n"
       html = "<pre><code>foo</code></pre>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-    test "2nd line less indented (was regtest #43)" do 
-      markdown =  
+    test "2nd line less indented (was regtest #43)" do
+      markdown =
         """
                  alpha
              beta
         """
+
       html = ~s[<pre><code>     alpha\n beta</code></pre>\n]
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -65,7 +66,7 @@ defmodule Acceptance.Ast.IndentedCodeBlocksTest do
     test "just an example" do
       markdown = "\n    wunderbar\n{: lang=\"de:at\"}\n"
       html = "<pre lang=\"de:at\"><code>wunderbar</code></pre>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
diff --git a/test/acceptance/ast/inline_code_test.exs b/test/acceptance/ast/inline_code_test.exs
index c493084..2df66ee 100644
--- a/test/acceptance/ast/inline_code_test.exs
+++ b/test/acceptance/ast/inline_code_test.exs
@@ -7,7 +7,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "plain simple" do
       markdown = "`foo`\n"
       html = "<p><code class=\"inline\">foo</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,7 +16,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "plain simple, right?" do
       markdown = "`hi`lo`\n"
       html = "<p><code class=\"inline\">hi</code>lo`</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = [{:warning, 1, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
@@ -25,7 +25,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "this time you got it right" do
       markdown = "`a\nb`c\n"
       html = "<p><code class=\"inline\">a b</code>c</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -34,7 +34,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "and again!!!" do
       markdown = "+ ``a `\n`\n b``c"
       html = "<ul>\n<li><code class=\"inline\">a ` ` b</code>c</li>\n</ul>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -45,7 +45,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "a lone escaped backslash" do
       markdown = "`\\\\`"
       html = "<p><code class=\"inline\">\\\\</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -54,7 +54,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "with company" do
       markdown = "`hello \\\\ world`"
       html = "<p><code class=\"inline\">hello \\\\ world</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -63,25 +63,25 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "unescaped escape" do
       markdown = "`\\`"
       html = "<p><code class=\"inline\">\\</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
-  
-    test "backtix cannot be escaped" do 
+
+    test "backtix cannot be escaped" do
       markdown = "`` \\` ``"
       html = "<p><code class=\"inline\">\\`</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-    test "unless at the beginning" do 
+    test "unless at the beginning" do
       markdown = "\\``code\\`"
       html = "<p>`<code class=\"inline\">code\\</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -92,7 +92,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "squashing" do
       markdown = "`alpha   beta`"
       html = "<p><code class=\"inline\">alpha beta</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -101,7 +101,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "remove at start" do
       markdown = "`  alpha beta`"
       html = "<p><code class=\"inline\">alpha beta</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -110,7 +110,7 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "remove and squash" do
       markdown = "`  alpha   beta `"
       html = "<p><code class=\"inline\">alpha beta</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -119,16 +119,16 @@ defmodule Acceptance.Ast.InlineCodeTest do
     test "remove and squash newlines too" do
       markdown = "`\n  alpha  \n\n beta `"
       html = "<p><code class=\"inline\">alpha beta</code></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-    test "inline code inside lists (was regtest #48)" do 
+    test "inline code inside lists (was regtest #48)" do
       markdown = " * `a\n * b`"
-      html     = ~s[<ul>\n<li><code class="inline">a * b</code>\n</li>\n</ul>\n]
-      ast      = parse_html(html)
+      html = ~s[<ul>\n<li><code class="inline">a * b</code>\n</li>\n</ul>\n]
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -141,9 +141,11 @@ defmodule Acceptance.Ast.InlineCodeTest do
       ` Single Opens
       ` Single Closes ``Double reopens
       """
+
       ast = [
-        p([tag("code", "Single Opens", [class: "inline"], %{line: 1}),  " Single Closes ``Double reopens"])
+        p([tag("code", "Single Opens", [class: "inline"], %{line: 1}), " Single Closes ``Double reopens"])
       ]
+
       messages = [{:warning, 2, "Closing unclosed backquotes `` at end of input"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
diff --git a/test/acceptance/ast/inline_ial_test.exs b/test/acceptance/ast/inline_ial_test.exs
index 2e1689e..67770d9 100644
--- a/test/acceptance/ast/inline_ial_test.exs
+++ b/test/acceptance/ast/inline_ial_test.exs
@@ -5,15 +5,19 @@ defmodule Test.Acceptance.Ast.InlineIalTest do
     data = [
       {"# A Header{:.classy}", [{"h1", [{"class", "classy"}], ["A Header"], %{}}]},
       {"###### Another Header{:.classy}", [{"h6", [{"class", "classy"}], ["Another Header"], %{}}]},
-      {"> # Bq Header{:.classy-again}", [{"blockquote", [], [{"h1", [{"class", "classy-again"}], ["Bq Header"], %{}}], %{}}]},
-      {"- # Bq in a list{:.class42 title=xxx}", [{"ul", [], [{"li", [], [{"h1", [{"class", "class42"}, {"title", "xxx"}], ["Bq in a list"], %{}}], %{}}], %{}}]},
-      {"`42|>inspect()`{:.elixir}", [{"p", [], [{"code", [{"class", "inline elixir"}], ["42|>inspect()"], %{line: 1}}], %{}}]}
+      {"> # Bq Header{:.classy-again}",
+       [{"blockquote", [], [{"h1", [{"class", "classy-again"}], ["Bq Header"], %{}}], %{}}]},
+      {"- # Bq in a list{:.class42 title=xxx}",
+       [{"ul", [], [{"li", [], [{"h1", [{"class", "class42"}, {"title", "xxx"}], ["Bq in a list"], %{}}], %{}}], %{}}]},
+      {"`42|>inspect()`{:.elixir}",
+       [{"p", [], [{"code", [{"class", "inline elixir"}], ["42|>inspect()"], %{line: 1}}], %{}}]}
     ]
+
     data
-    |> Enum.with_index
-    |> Enum.each( fn {{markdown, expected}, nb} ->
-      tag = "inline_ial_#{nb}" |> String.to_atom
-      name = "for #{inspect markdown} (#{nb})"
+    |> Enum.with_index()
+    |> Enum.each(fn {{markdown, expected}, nb} ->
+      tag = "inline_ial_#{nb}" |> String.to_atom()
+      name = "for #{inspect(markdown)} (#{nb})"
       {:ok, ast, []} = EarmarkParser.as_ast(markdown)
 
       @tag tag
@@ -26,15 +30,17 @@ defmodule Test.Acceptance.Ast.InlineIalTest do
   describe "inline IAL disabled →" do
     data = [
       {"######## Not Yet Another Header{:.classy}", [{"p", [], ["######## Not Yet Another Header{:.classy}"], %{}}]},
-      {["> code {:.not-classy}", "> still code"], [{"blockquote", [], [{"p", [], ["code {:.not-classy}\nstill code"], %{}}], %{}}]},
+      {["> code {:.not-classy}", "> still code"],
+       [{"blockquote", [], [{"p", [], ["code {:.not-classy}\nstill code"], %{}}], %{}}]},
       {"-- {:.hello}", [{"p", [], ["-- {:.hello}"], %{}}]},
-      {"--- {:.hello}", [{"p", [], ["--- {:.hello}"], %{}}]},
+      {"--- {:.hello}", [{"p", [], ["--- {:.hello}"], %{}}]}
     ]
+
     data
-    |> Enum.with_index
-    |> Enum.each( fn {{markdown, expected}, nb} ->
-      tag = "not_inline_ial_#{nb}" |> String.to_atom
-      name = "for #{inspect markdown} (#{nb})"
+    |> Enum.with_index()
+    |> Enum.each(fn {{markdown, expected}, nb} ->
+      tag = "not_inline_ial_#{nb}" |> String.to_atom()
+      name = "for #{inspect(markdown)} (#{nb})"
       {:ok, ast, []} = EarmarkParser.as_ast(markdown)
 
       @tag tag
diff --git a/test/acceptance/ast/line_breaks_test.exs b/test/acceptance/ast/line_breaks_test.exs
index 3cde20a..8049528 100644
--- a/test/acceptance/ast/line_breaks_test.exs
+++ b/test/acceptance/ast/line_breaks_test.exs
@@ -6,77 +6,85 @@ defmodule Acceptance.Ast.LineBreaksTest do
   describe "Forced Line Breaks" do
     test "with two spaces" do
       markdown = "The  \nquick"
-      html     = "<p>The<br />quick</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The<br />quick</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "or more spaces" do
       markdown = "The   \nquick"
-      html     = "<p>The<br />quick</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The<br />quick</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "or in some lines" do
       markdown = "The   \nquick  \nbrown"
-      html     = "<p>The<br />quick<br />brown</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The<br />quick<br />brown</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "and in list items" do
       markdown = "* The  \nquick"
-      html     = "<ul>\n<li>The<br />quick</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>The<br />quick</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "only one line" do
       markdown = "* The lonely  "
-      ast      = [
+
+      ast = [
         ul(li("The lonely  "))
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
-
   describe "No Forced Line Breaks" do
     test "with only one space" do
       markdown = "The \nquick"
-      html     = "<p>The \nquick</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The \nquick</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "or whitespace lines" do
       markdown = "The\n  \nquick"
-      html     = "<p>The</p>\n<p>quick</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The</p>\n<p>quick</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "or inside the line" do
       markdown = "The  quick\nbrown"
-      html     = "<p>The  quick\nbrown</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The  quick\nbrown</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "or at the end of input" do
       markdown = "The\nquick  "
-      html     = "<p>The\nquick  </p>\n"
-      ast      = parse_html(html)
+      html = "<p>The\nquick  </p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -84,8 +92,8 @@ defmodule Acceptance.Ast.LineBreaksTest do
 
     test "or in code blocks" do
       markdown = "```\nThe \nquick\n```"
-      html     = "<pre><code>The \nquick</code></pre>\n"
-      ast      = parse_html(html)
+      html = "<pre><code>The \nquick</code></pre>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
diff --git a/test/acceptance/ast/links_images/img_test.exs b/test/acceptance/ast/links_images/img_test.exs
index d80208f..1e51c9e 100644
--- a/test/acceptance/ast/links_images/img_test.exs
+++ b/test/acceptance/ast/links_images/img_test.exs
@@ -5,11 +5,10 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
   import EarmarkAstDsl
 
   describe "Image reference definitions" do
-
     test "img with title" do
       markdown = "[foo]: /url \"title\"\n\n![foo]\n"
       html = "<p><img src=\"/url\" alt=\"foo\" title=\"title\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -18,17 +17,16 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "url encoding is **not** our job" do
       markdown = "[foo]: /url?é=42 \"title\"\n\n![foo]\n"
       html = "<p><img src=\"/url?é=42\" alt=\"foo\" title=\"title\" /></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-
     test "this ain't no img (and no link)" do
       markdown = "[foo]: /url \"title\"\n\n![bar]\n"
       html = "<p>![bar]</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -36,7 +34,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
 
     test "missed case" do
       markdown = "![text](pre[\\()"
-      ast = [ p([tag("img", [], src: "pre[(", alt: "text"), ")" ]) ]
+      ast = [p([tag("img", [], src: "pre[(", alt: "text"), ")"])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -44,11 +42,10 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
   end
 
   describe "Link and Image imbrication" do
-
     test "as with this img" do
       markdown = "![[text](inner)](outer)"
       html = "<p><img src=\"outer\" alt=\"[text](inner)\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -57,7 +54,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "again escapes do not escape us" do
       markdown = "![\\[text\\](inner)](outer)"
       html = "<p><img src=\"outer\" alt=\"[text](inner)\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -66,7 +63,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "headaches ahead (and behind us)" do
       markdown = "[![moon](moon.jpg)](/uri)\n"
       html = "<p><a href=\"/uri\"><img src=\"moon.jpg\" alt=\"moon\"/></a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -75,18 +72,17 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "lost in space" do
       markdown = "![![moon](moon.jpg)](sun.jpg)\n"
       html = "<p><img src=\"sun.jpg\" alt=\"![moon](moon.jpg)\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
   describe "Images" do
-
     test "title" do
       markdown = "![foo](/url \"title\")\n"
       html = "<p><img src=\"/url\" alt=\"foo\" title=\"title\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -95,7 +91,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "ti tle (why not)" do
       markdown = "![foo](/url \"ti tle\")\n"
       html = "<p><img src=\"/url\" alt=\"foo\" title=\"ti tle\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -104,7 +100,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "titles become strange" do
       markdown = "![foo](/url \"ti() tle\")\n"
       html = "<p><img src=\"/url\" alt=\"foo\" title=\"ti() tle\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -113,7 +109,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "as does everything else" do
       markdown = "![f[]oo](/url \"ti() tle\")\n"
       html = "<p><img src=\"/url\" alt=\"f[]oo\" title=\"ti() tle\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -122,7 +118,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "alt goes crazy" do
       markdown = "![foo[([])]](/url 'title')\n"
       html = "<p><img src=\"/url\" alt=\"foo[([])]\" title=\"title\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -130,7 +126,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
 
     test "alt goes crazy, with deprecation warnings" do
       markdown = "\n![foo[([])]](/url 'title\")\n"
-      ast        = [p(void_tag("img", src: "/url 'title\"", alt: "foo[([])]"))]
+      ast = [p(void_tag("img", src: "/url 'title\"", alt: "foo[([])]"))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -139,7 +135,7 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
     test "url escapes of course" do
       markdown = "![foo](/url no title)\n"
       html = "<p><img src=\"/url no title\" alt=\"foo\"/></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -149,11 +145,13 @@ defmodule Acceptance.Ast.LinkImages.ImgTest do
       file = File.read!("test/fixtures/sample.png")
       markdown = "![](data:image/png;base64,#{Base.encode64(file)})"
 
-      assert {:ok, [
-        {"p", [], [
-            {"img", [{"src", "data:image/png;base64," <> _}, {"alt", ""}], [], %{}}
-          ], %{}}
-        ], []} = as_ast(markdown)
+      assert {:ok,
+              [
+                {"p", [],
+                 [
+                   {"img", [{"src", "data:image/png;base64," <> _}, {"alt", ""}], [], %{}}
+                 ], %{}}
+              ], []} = as_ast(markdown)
     end
   end
 end
diff --git a/test/acceptance/ast/links_images/link_test.exs b/test/acceptance/ast/links_images/link_test.exs
index 0d774de..3f9cd60 100644
--- a/test/acceptance/ast/links_images/link_test.exs
+++ b/test/acceptance/ast/links_images/link_test.exs
@@ -7,17 +7,16 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "link with title" do
       markdown = "[foo]: /url \"title\"\n\n[foo]\n"
       html = "<p><a href=\"/url\" title=\"title\">foo</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-
     test "link with utf8 title" do
       markdown = "[foo]: /url \"Überschrift\"\n\n[foo]\n"
       html = "<p><a href=\"/url\" title=\"Überschrift\">foo</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -26,7 +25,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "this ain't no link" do
       markdown = "[foo]: /url \"title\"\n\n[bar]\n"
       html = "<p>[bar]</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -35,7 +34,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "strange syntaxes exist in Markdown" do
       markdown = "[foo]\n\n[foo]: url\n"
       html = "<p><a href=\"url\" title=\"\">foo</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -44,7 +43,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "sometimes strange text is just strange text" do
       markdown = "[foo]: /url \"title\" ok\n"
       html = "<p>[foo]: /url &quot;title&quot; ok</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, smartypants: false) == {:ok, ast, messages}
@@ -61,7 +60,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
       markdown = "# [Foo]\n[foo]: /url\n> bar\n"
       lhs = "<h1><a href=\"/url\" title=\"\">Foo</a></h1>"
       rhs = "<blockquote><p>bar</p>\n</blockquote>\n"
-      ast  = parse_html(lhs) ++ parse_html(rhs)
+      ast = parse_html(lhs) ++ parse_html(rhs)
 
       messages = []
 
@@ -73,7 +72,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "empty (remains such)" do
       markdown = ""
       html = ""
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -82,7 +81,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "inner is a link, not outer" do
       markdown = "[[text](inner)]outer"
       html = "<p>[<a href=\"inner\">text</a>]outer</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -91,7 +90,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "unless your outer is syntactically a link of course" do
       markdown = "[[text](inner)](outer)"
       html = "<p><a href=\"outer\">[text](inner)</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -100,20 +99,18 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "escaping does not change that" do
       markdown = "[\\[text\\](inner\\)](outer)"
       html = "<p><a href=\"outer\">[text](inner)</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
-
   end
 
   describe "Links" do
-
     test "no title" do
       markdown = "[link](/uri))\n"
       html = "<p><a href=\"/uri\">link</a>)</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -122,7 +119,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "let's go nowhere" do
       markdown = "[link]()\n"
       html = "<p><a href=\"\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -131,14 +128,14 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "nowhere in a bottle" do
       markdown = "[link](())\n"
       html = "<p><a href=\"()\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
     test "minimal case" do
       markdown = "([]()"
-      html     = "<p>(<a href=\"\"></a></p>\n"
+      html = "<p>(<a href=\"\"></a></p>\n"
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -146,7 +143,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "minimal case, ) as suffix" do
       markdown = "([]())"
-      html     = "<p>(<a href=\"\"></a>)</p>\n"
+      html = "<p>(<a href=\"\"></a>)</p>\n"
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -154,7 +151,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "normal case" do
       markdown = "([text](link))"
-      html     = "<p>(<a href=\"link\">text</a>)</p>\n"
+      html = "<p>(<a href=\"link\">text</a>)</p>\n"
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -162,7 +159,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "link with nested elements" do
       markdown = "[_foo_ bar](link)"
-      html     = "<p><a href=\"link\"><em>foo</em> bar</a></p>\n"
+      html = "<p><a href=\"link\"><em>foo</em> bar</a></p>\n"
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -170,7 +167,10 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "illegal ulrs are not EarmarkParser's responsibility (was regtest #51)" do
       markdown = "[<<>>/1](http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#<<>>/1)"
-      html     = ~s[<p><a href="http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#<<>>/1">&lt;&lt;&gt;&gt;/1</a></p>]
+
+      html =
+        ~s[<p><a href="http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#<<>>/1">&lt;&lt;&gt;&gt;/1</a></p>]
+
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -178,7 +178,10 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "escapes in link's name (was regtest #51)" do
       markdown = "[&expr/1](http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#&expr/1)"
-      html     = ~s{<p><a href="http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#&expr/1">&amp;expr/1</a></p>}
+
+      html =
+        ~s{<p><a href="http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.htm#&expr/1">&amp;expr/1</a></p>}
+
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -186,19 +189,18 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "ws between links" do
       markdown = "[link](/uri \"title\") [link](/uri \"title\")"
-      html     = "<p>\n<a href=\"/uri\" title=\"title\">link</a>&#x20;<a href=\"/uri\" title=\"title\">link</a></p>\n"
+      html = "<p>\n<a href=\"/uri\" title=\"title\">link</a>&#x20;<a href=\"/uri\" title=\"title\">link</a></p>\n"
       ast = parse_html(html)
       messages = []
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
-
   describe "Autolinks" do
     test "that was easy" do
       markdown = "<http://foo.bar.baz>\n"
       html = "<p><a href=\"http://foo.bar.baz\">http://foo.bar.baz</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -207,7 +209,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "now uri encoding here" do
       markdown = "<http://foo.bar.baz?url=é>\n"
       html = "<p><a href=\"http://foo.bar.baz?url=%C3%A9\">http://foo.bar.baz?url=é</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -225,7 +227,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "as was this" do
       markdown = "<irc://foo.bar:2233/baz>\n"
       html = "<p><a href=\"irc://foo.bar:2233/baz\">irc://foo.bar:2233/baz</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -234,7 +236,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "good ol' mail" do
       markdown = "<mailto:foo@bar.baz>\n"
       html = "<p><a href=\"mailto:foo@bar.baz\">foo@bar.baz</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -243,7 +245,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "we know what mail is" do
       markdown = "<foo@bar.example.com>\n"
       html = "<p><a href=\"mailto:foo@bar.example.com\">foo@bar.example.com</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -252,7 +254,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
     test "not really a link" do
       markdown = "<>\n"
       html = "<p>&lt;&gt;</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -262,8 +264,8 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
   describe "some special chars inside links" do
     test "parentheses inside the url (was regtest #70)" do
       markdown = ~s{[Wikipedia article on PATH](https://en.wikipedia.org/wiki/PATH_(variable))}
-      html     = ~s{<p><a href="https://en.wikipedia.org/wiki/PATH_(variable)">Wikipedia article on PATH</a></p>\n}
-      ast      = parse_html(html)
+      html = ~s{<p><a href="https://en.wikipedia.org/wiki/PATH_(variable)">Wikipedia article on PATH</a></p>\n}
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -271,8 +273,8 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "quotes in text (was regtest #72)" do
       markdown = ~s{["EarmarkParser"](https://github.com/pragdave/earmark/)}
-      html     = ~s{<p><a href="https://github.com/pragdave/earmark/">"EarmarkParser"</a></p>\n}
-      ast      = parse_html(html)
+      html = ~s{<p><a href="https://github.com/pragdave/earmark/">"EarmarkParser"</a></p>\n}
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -290,7 +292,7 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
   describe "Escapes in text (was regtest #198)" do
     test "escaped backticks" do
       markdown = "[hello \\`code\\`](http://some.where)"
-      ast      = [p(tag("a", "hello `code`", href: "http://some.where"))]
+      ast = [p(tag("a", "hello `code`", href: "http://some.where"))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -298,8 +300,8 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "escaped stars" do
       markdown = "[hello \\*world\\*](http://some.where)"
-      html     = ~s{<p><a href="http://some.where">hello *world*</a></p>\n}
-      ast      = parse_html(html)
+      html = ~s{<p><a href="http://some.where">hello *world*</a></p>\n}
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -307,15 +309,17 @@ defmodule Acceptance.Ast.LinkImages.LinkTest do
 
     test "although brackets do not need escapes, we still have to render them correctly" do
       markdown = "[hello \\[world\\]](http://some.where)"
-      html     = ~s{<p><a href="http://some.where">hello [world]</a></p>\n}
-      ast      = parse_html(html)
+      html = ~s{<p><a href="http://some.where">hello [world]</a></p>\n}
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
-  defp a(content, atts), do: tag("a", content, atts)
+  defp a(content, atts) do
+    tag("a", content, atts)
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/links_images/pure_links_test.exs b/test/acceptance/ast/links_images/pure_links_test.exs
index fe70c36..9f142c0 100644
--- a/test/acceptance/ast/links_images/pure_links_test.exs
+++ b/test/acceptance/ast/links_images/pure_links_test.exs
@@ -7,7 +7,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
     test "issue deprecation warning suppressed" do
       markdown = "https://github.com/pragdave/earmark"
       html = "<p>https://github.com/pragdave/earmark</p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, pure_links: false) == {:ok, ast, messages}
@@ -17,8 +17,11 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
   describe "enabled pure links" do
     test "two in a row" do
       markdown = "https://github.com/pragdave/earmark https://github.com/RobertDober/extractly"
-      html = "<p><a href=\"https://github.com/pragdave/earmark\">https://github.com/pragdave/earmark</a>&#x20;<a href=\"https://github.com/RobertDober/extractly\">https://github.com/RobertDober/extractly</a></p>\n"
-      ast      = parse_html(html)
+
+      html =
+        "<p><a href=\"https://github.com/pragdave/earmark\">https://github.com/pragdave/earmark</a>&#x20;<a href=\"https://github.com/RobertDober/extractly\">https://github.com/RobertDober/extractly</a></p>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -26,8 +29,11 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "more text" do
       markdown = "Header http://wikipedia.org in between <http://hex.pm> Trailer"
-      html = "<p>Header <a href=\"http://wikipedia.org\">http://wikipedia.org</a> in between <a href=\"http://hex.pm\">http://hex.pm</a> Trailer</p>\n"
-      ast      = parse_html(html)
+
+      html =
+        "<p>Header <a href=\"http://wikipedia.org\">http://wikipedia.org</a> in between <a href=\"http://hex.pm\">http://hex.pm</a> Trailer</p>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -35,8 +41,11 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "more links" do
       markdown = "[Erlang](https://erlang.org) & https://elixirforum.com"
-      html = "<p><a href=\"https://erlang.org\">Erlang</a> &amp; <a href=\"https://elixirforum.com\">https://elixirforum.com</a></p>\n"
-      ast      = parse_html(html)
+
+      html =
+        "<p><a href=\"https://erlang.org\">Erlang</a> &amp; <a href=\"https://elixirforum.com\">https://elixirforum.com</a></p>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -45,7 +54,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
     test "be aware of the double up" do
       markdown = "[https://erlang.org](https://erlang.org)"
       html = "<p><a href=\"https://erlang.org\">https://erlang.org</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -53,8 +62,11 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "correct mix" do
       markdown = "[https://erlang.org](https://erlang.org) https://elixir.lang"
-      html = "<p><a href=\"https://erlang.org\">https://erlang.org</a>&#x20;<a href=\"https://elixir.lang\">https://elixir.lang</a></p>\n"
-      ast      = parse_html(html)
+
+      html =
+        "<p><a href=\"https://erlang.org\">https://erlang.org</a>&#x20;<a href=\"https://elixir.lang\">https://elixir.lang</a></p>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -63,8 +75,10 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
     test "leading whitespace is preserved" do
       markdown = "**Test**     https://www.google.com"
       # This needs to be `&#x20;` instead of ` ` because Floki strips out blank text nodes
-      html = "<p><strong>Test</strong>&#x20;&#x20;&#x20;&#x20;&#x20;<a href=\"https://www.google.com\">https://www.google.com</a></p>\n"
-      ast      = parse_html(html)
+      html =
+        "<p><strong>Test</strong>&#x20;&#x20;&#x20;&#x20;&#x20;<a href=\"https://www.google.com\">https://www.google.com</a></p>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -74,7 +88,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
   describe "parenthesis (was: regression #342)" do
     test "simplest error case" do
       markdown = "http://my.org/robert(is_best)"
-      ast      = p(tag("a", ["http://my.org/robert(is_best)"],[{"href", "http://my.org/robert(is_best)"}]))
+      ast = p(tag("a", ["http://my.org/robert(is_best)"], [{"href", "http://my.org/robert(is_best)"}]))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -82,7 +96,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "imbrication" do
       markdown = "(http://my.org/robert(is_best)"
-      ast      = p(["(", tag("a", ["http://my.org/robert(is_best)"],[{"href", "http://my.org/robert(is_best)"}])])
+      ast = p(["(", tag("a", ["http://my.org/robert(is_best)"], [{"href", "http://my.org/robert(is_best)"}])])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -90,7 +104,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "enough imbrication" do
       markdown = "(http://my.org/robert(is_best))"
-      ast      = p(["(", tag("a", ["http://my.org/robert(is_best)"],[{"href", "http://my.org/robert(is_best)"}]), ")"])
+      ast = p(["(", tag("a", ["http://my.org/robert(is_best)"], [{"href", "http://my.org/robert(is_best)"}]), ")"])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -98,7 +112,10 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "most imbricated" do
       markdown = "((http://my.org/robert(c'estça)))"
-      ast      = p(["((", tag("a", ["http://my.org/robert(c'estça)"],[{"href", "http://my.org/robert(c'est%C3%A7a)"}]), "))"])
+
+      ast =
+        p(["((", tag("a", ["http://my.org/robert(c'estça)"], [{"href", "http://my.org/robert(c'est%C3%A7a)"}]), "))"])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -106,7 +123,10 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "recoding is cool" do
       markdown = "((http://github.com(c'est%C3%A7a)))"
-      ast      = p(["((", tag("a", ["http://github.com(c'est%C3%A7a)"], [{"href", "http://github.com(c'est%C3%A7a)"}]), "))"])
+
+      ast =
+        p(["((", tag("a", ["http://github.com(c'est%C3%A7a)"], [{"href", "http://github.com(c'est%C3%A7a)"}]), "))"])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -114,7 +134,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "trailing parens are not part of it, at least not all" do
       markdown = "(https://a.link.com))"
-      ast      = p(["(", tag("a",  "https://a.link.com", href:  "https://a.link.com"), "))"])
+      ast = p(["(", tag("a", "https://a.link.com", href: "https://a.link.com"), "))"])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -122,7 +142,14 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "closing parens can match opening parens at the end" do
       markdown = "(http://www.google.com/search?q=business)"
-      ast      = p(["(", tag("a", "http://www.google.com/search?q=business", href: "http://www.google.com/search?q=business"), ")"])
+
+      ast =
+        p([
+          "(",
+          tag("a", "http://www.google.com/search?q=business", href: "http://www.google.com/search?q=business"),
+          ")"
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -130,30 +157,41 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "opening parens w/o closing parens do not match" do
       markdown = "(http://www.google.com/search?q=business"
-      ast      = p(["(", tag("a", "http://www.google.com/search?q=business", href: "http://www.google.com/search?q=business")])
+
+      ast =
+        p(["(", tag("a", "http://www.google.com/search?q=business", href: "http://www.google.com/search?q=business")])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
-
   end
 
   describe "more acceptable characters (was: regression #350)" do
     test "a Github link" do
       markdown = "https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}"
       # Cannot use Floki (c.f. https://github.com/philss/floki/issues/370)
-      ast      = tag("a",
-      ["https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}"],
-      [{"href", "https://mydomain.org/user_or_team/repo_name/blob/master/%25%7Bpath%7D#L%25%7Bline%7D"}])
-      |> p()
+      ast =
+        tag(
+          "a",
+          ["https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}"],
+          [{"href", "https://mydomain.org/user_or_team/repo_name/blob/master/%25%7Bpath%7D#L%25%7Bline%7D"}]
+        )
+        |> p()
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
+
     test "a recursive link" do
-      markdown = "https://babelmark.github.io/?text=*+List+item%0A%0A++Text%0A%0A++++*+List+item%0A%0A++Text%0A%0A++++++https%3A%2F%2Fmydomain.org%2Fuser_or_team%2Frepo_name%2Fblob%2Fmaster%2F%25%7Bpath%7D%23L%25%7Bline%7D%0"
-      href = "https://babelmark.github.io/?text=*+List+item%0A%0A++Text%0A%0A++++*+List+item%0A%0A++Text%0A%0A++++++https%3A%2F%2Fmydomain.org%2Fuser_or_team%2Frepo_name%2Fblob%2Fmaster%2F%25%7Bpath%7D%23L%25%7Bline%7D%250"
-      ast      = tag("a", markdown, href: href) |> p()
+      markdown =
+        "https://babelmark.github.io/?text=*+List+item%0A%0A++Text%0A%0A++++*+List+item%0A%0A++Text%0A%0A++++++https%3A%2F%2Fmydomain.org%2Fuser_or_team%2Frepo_name%2Fblob%2Fmaster%2F%25%7Bpath%7D%23L%25%7Bline%7D%0"
+
+      href =
+        "https://babelmark.github.io/?text=*+List+item%0A%0A++Text%0A%0A++++*+List+item%0A%0A++Text%0A%0A++++++https%3A%2F%2Fmydomain.org%2Fuser_or_team%2Frepo_name%2Fblob%2Fmaster%2F%25%7Bpath%7D%23L%25%7Bline%7D%250"
+
+      ast = tag("a", markdown, href: href) |> p()
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -163,7 +201,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
   describe "multiple params (was: regression #044)" do
     test "one query param" do
       markdown = "https://example.com?foo=1"
-      ast      = p(tag("a", markdown, [{"href", markdown}]))
+      ast = p(tag("a", markdown, [{"href", markdown}]))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -171,7 +209,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
 
     test "two query params" do
       markdown = "https://example.com?foo=1&bar=2"
-      ast      = p(tag("a", markdown, [{"href", markdown}]))
+      ast = p(tag("a", markdown, [{"href", markdown}]))
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -181,7 +219,7 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
   describe "matching parenthesis" do
     test "match trailing closing parenthesis with the opening parenthesis in the link" do
       markdown = "(http://github.com/(foo)"
-      ast      = p(["(", tag("a", ["http://github.com/(foo)"], [{"href", "http://github.com/(foo)"}])])
+      ast = p(["(", tag("a", ["http://github.com/(foo)"], [{"href", "http://github.com/(foo)"}])])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -191,12 +229,12 @@ defmodule Acceptance.Ast.LinksImages.PureLinksTest do
   describe "unicode characters" do
     test "support non alphanumeric unicode characters" do
       markdown = "http://github.com?foo=😀"
-      ast      = p([tag("a", ["http://github.com?foo=😀"], [{"href", "http://github.com?foo=#{URI.encode("😀")}"}])])
+      ast = p([tag("a", ["http://github.com?foo=😀"], [{"href", "http://github.com?foo=#{URI.encode("😀")}"}])])
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/links_images/titles_test.exs b/test/acceptance/ast/links_images/titles_test.exs
index 056fc9c..a005497 100644
--- a/test/acceptance/ast/links_images/titles_test.exs
+++ b/test/acceptance/ast/links_images/titles_test.exs
@@ -5,11 +5,15 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
   describe "Links with titles" do
     test "two titled links" do
       mark_tmp = "[link](/uri \"title\")"
-      markdown = "#{ mark_tmp } #{ mark_tmp }\n"
-      ast      = p([
-        tag("a", "link", href: "/uri", title: "title"),
-        " ",
-        tag("a", "link", href: "/uri", title: "title") ])
+      markdown = "#{mark_tmp} #{mark_tmp}\n"
+
+      ast =
+        p([
+          tag("a", "link", href: "/uri", title: "title"),
+          " ",
+          tag("a", "link", href: "/uri", title: "title")
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -18,7 +22,7 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
     test "titled link" do
       markdown = "[link](/uri \"title\")\n"
       html = "<p><a href=\"/uri\" title=\"title\">link</a></p>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -26,10 +30,14 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "titled, followed by untitled" do
       markdown = "[a](a 't') [b](b)"
-      ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b")])
+
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b")
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -37,12 +45,16 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "titled, followed by untitled and titled" do
       markdown = "[a](a 't') [b](b) [c](c 't')"
-      ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b"),
-        " ",
-        tag("a", "c", href: "c", title: "t")])
+
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b"),
+          " ",
+          tag("a", "c", href: "c", title: "t")
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -50,56 +62,71 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "titled, followed by two untitled" do
       markdown = "[a](a 't') [b](b) [c](c)"
-      ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b"),
-        " ",
-        tag("a", "c", href: "c")])
-       messages = []
 
-       assert as_ast(markdown) == {:ok, [ast], messages}
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b"),
+          " ",
+          tag("a", "c", href: "c")
+        ])
+
+      messages = []
+
+      assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
     test "titled, followed by 2 untitled, (quotes interspersed)" do
       markdown = "[a](a 't') [b](b) 'xxx' [c](c)"
-      ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b"),
-        " 'xxx' ",
-        tag("a", "c", href: "c")])
-       messages = []
 
-       assert as_ast(markdown) == {:ok, [ast], messages}
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b"),
+          " 'xxx' ",
+          tag("a", "c", href: "c")
+        ])
+
+      messages = []
+
+      assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
     test "titled, followed by 2 untitled, (quotes interspersed, and escape)" do
       markdown = "[a](a 't') [b](b) 'xxx' [\\c](c)"
-      ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b"),
-        " 'xxx' ",
-        tag("a", "\\c", href: "c")])
-       messages = []
 
-       assert as_ast(markdown) == {:ok, [ast], messages}
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b"),
+          " 'xxx' ",
+          tag("a", "\\c", href: "c")
+        ])
+
+      messages = []
+
+      assert as_ast(markdown) == {:ok, [ast], messages}
     end
 
     test "titled, followed by 2 untitled, (quotes inside parens interspersed)" do
       markdown = "[a](a 't') [b](b) ('xxx') [c](c)"
-       ast      = p([
-        tag("a", "a", href: "a", title: "t"),
-        " ",
-        tag("a", "b", href: "b"),
-        " ('xxx') ",
-        tag("a", "c", href: "c")])
-       messages = []
 
-       assert as_ast(markdown) == {:ok, [ast], messages}
-    end
+      ast =
+        p([
+          tag("a", "a", href: "a", title: "t"),
+          " ",
+          tag("a", "b", href: "b"),
+          " ('xxx') ",
+          tag("a", "c", href: "c")
+        ])
 
+      messages = []
+
+      assert as_ast(markdown) == {:ok, [ast], messages}
+    end
 
     test "titled link, with deprecated quote mismatch" do
       markdown = "[link](/uri \"title')\n"
@@ -113,10 +140,14 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
   describe "Images, and links with titles" do
     test "two titled images, different quotes" do
       markdown = ~s{![a](a 't') ![b](b "u")}
-      ast      = p([
-        void_tag("img", src: "a", alt: "a", title: "t"),
-        " ",
-        void_tag("img", src: "b", alt: "b", title: "u")])
+
+      ast =
+        p([
+          void_tag("img", src: "a", alt: "a", title: "t"),
+          " ",
+          void_tag("img", src: "b", alt: "b", title: "u")
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -124,10 +155,14 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "two titled images, same quotes" do
       markdown = ~s{![a](a "t") ![b](b "u")}
-      ast      = p([
-        void_tag("img", src: "a", alt: "a", title: "t"),
-        " ",
-        void_tag("img", src: "b", alt: "b", title: "u")])
+
+      ast =
+        p([
+          void_tag("img", src: "a", alt: "a", title: "t"),
+          " ",
+          void_tag("img", src: "b", alt: "b", title: "u")
+        ])
+
       messages = []
 
       assert as_ast(markdown) == {:ok, [ast], messages}
@@ -136,16 +171,16 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
     test "image and link, same quotes" do
       markdown = ~s{![a](a "t") hello [b](b "u")}
       html = ~s{<p><img src="a" alt="a" title="t"/> hello <a href="b" title="u">b</a></p>\n}
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
-    end 
+    end
 
     test "link and untitled image, and image, same quotes" do
       markdown = ~s{[a](a 't')![between](between)![b](b 'u')}
       html = ~s{<p><a href="a" title="t">a</a><img src="between" alt="between"/><img src="b" alt="b" title="u"/></p>\n}
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -155,8 +190,8 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
   describe "titleoids after link (was regtest # 244)" do
     test "title must not come from outside -- double / double" do
       markdown = "The [Foo](/dash \"foo\") page (in \"bar\")\n"
-      html     = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in \"bar\")</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in \"bar\")</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -164,8 +199,8 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "title must not come from outside -- double / single" do
       markdown = "The [Foo](/dash \"foo\") page (in 'bar')\n"
-      html     = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in 'bar')</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in 'bar')</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -173,8 +208,8 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "title must not come from outside -- single / double" do
       markdown = "The [Foo](/dash 'foo') page (in \"bar\")\n"
-      html     = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in \"bar\")</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in \"bar\")</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -182,12 +217,13 @@ defmodule Acceptance.Ast.LinksImages.TitlesTest do
 
     test "title must not come from outside -- single / single " do
       markdown = "The [Foo](/dash 'foo') page (in 'bar')\n"
-      html     = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in 'bar')</p>\n"
-      ast      = parse_html(html)
+      html = "<p>The <a href=\"/dash\" title=\"foo\">Foo</a> page (in 'bar')</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/links_images/wiki_links_test.exs b/test/acceptance/ast/links_images/wiki_links_test.exs
index ebf733d..a08514d 100644
--- a/test/acceptance/ast/links_images/wiki_links_test.exs
+++ b/test/acceptance/ast/links_images/wiki_links_test.exs
@@ -8,7 +8,7 @@ defmodule Acceptance.Ast.LinkImages.WikiLinksTest do
   describe "Wiki links" do
     test "basic wiki-style link" do
       markdown = "[[page]]"
-      ast      = [p(a("page", [href: "page"], @wikilink))]
+      ast = [p(a("page", [href: "page"], @wikilink))]
       messages = []
 
       assert as_ast(markdown, wikilinks: true) == {:ok, ast, messages}
@@ -16,7 +16,7 @@ defmodule Acceptance.Ast.LinkImages.WikiLinksTest do
 
     test "wikilink parsing is optional" do
       markdown = "[[page]]"
-      ast      = [p("[[page]]")]
+      ast = [p("[[page]]")]
       messages = []
 
       assert as_ast(markdown, wikilinks: false) == {:ok, ast, messages}
@@ -24,7 +24,7 @@ defmodule Acceptance.Ast.LinkImages.WikiLinksTest do
 
     test "misleading non-wiki link" do
       markdown = "[[page]](actual_link)"
-      ast      = [p(a("[page]", href: "actual_link"))]
+      ast = [p(a("[page]", href: "actual_link"))]
       messages = []
 
       assert as_ast(markdown, wikilinks: true) == {:ok, ast, messages}
@@ -32,7 +32,7 @@ defmodule Acceptance.Ast.LinkImages.WikiLinksTest do
 
     test "illegal urls are not Earmark's responsibility" do
       markdown = "[[A long & complex title]]"
-      ast      = [p(a("A long & complex title", [href: "A long & complex title"], @wikilink))]
+      ast = [p(a("A long & complex title", [href: "A long & complex title"], @wikilink))]
       messages = []
 
       assert as_ast(markdown, wikilinks: true) == {:ok, ast, messages}
@@ -65,4 +65,5 @@ defmodule Acceptance.Ast.LinkImages.WikiLinksTest do
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/list_indent_test.exs b/test/acceptance/ast/list_indent_test.exs
index 9b8ddb2..b9b86ea 100644
--- a/test/acceptance/ast/list_indent_test.exs
+++ b/test/acceptance/ast/list_indent_test.exs
@@ -6,7 +6,6 @@ defmodule Acceptance.Ast.ListIndentTest do
   import EarmarkAstDsl
 
   describe "different levels of indent" do
-
     test "ordered two levels, indented by two" do
       markdown = "1. One\n  2. two"
       ast = [ol(["One", "two"])]
@@ -20,6 +19,7 @@ defmodule Acceptance.Ast.ListIndentTest do
         - two
         - three
       """
+
       ast = [ol("One"), ul(["two", "three"])]
 
       assert ast_from_md(markdown) == ast
@@ -31,6 +31,7 @@ defmodule Acceptance.Ast.ListIndentTest do
           - two
           - three
       """
+
       ast = [ol(li(["One", ul(["two", "three"])]))]
 
       assert ast_from_md(markdown) == ast
@@ -38,8 +39,8 @@ defmodule Acceptance.Ast.ListIndentTest do
 
     test "2 level correct pop up" do
       markdown = "- 1\n  - 1.1\n    - 1.1.1\n  - 1.2"
-      html     = "<ul> <li>1<ul> <li>1.1<ul> <li>1.1.1</li> </ul> </li> <li>1.2</li> </ul> </li> </ul>"
-      ast      = parse_html(html)
+      html = "<ul> <li>1<ul> <li>1.1<ul> <li>1.1.1</li> </ul> </li> <li>1.2</li> </ul> </li> </ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -47,8 +48,8 @@ defmodule Acceptance.Ast.ListIndentTest do
 
     test "4 level correct pop up" do
       markdown = "- 1\n    - 1.1\n        - 1.1.1\n    - 1.2"
-      html     = "<ul>\n<li>1<ul>\n<li>1.1<ul>\n<li>1.1.1</li>\n</ul>\n</li>\n<li>1.2</li>\n</ul>\n</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>1<ul>\n<li>1.1<ul>\n<li>1.1.1</li>\n</ul>\n</li>\n<li>1.2</li>\n</ul>\n</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
diff --git a/test/acceptance/ast/list_test.exs b/test/acceptance/ast/list_test.exs
index 2768aae..f19137a 100644
--- a/test/acceptance/ast/list_test.exs
+++ b/test/acceptance/ast/list_test.exs
@@ -6,8 +6,8 @@ defmodule Acceptance.Ast.ListTest do
   describe "List items" do
     test "Unnumbered" do
       markdown = "* one\n* two"
-      html     = "<ul><li>one</li><li>two</li></ul>"
-      ast      = parse_html(html)
+      html = "<ul><li>one</li><li>two</li></ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -15,8 +15,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "Unnumbered Indented" do
       markdown = "  * one\n  * two"
-      html     = "<ul><li>one</li><li>two</li></ul>"
-      ast      = parse_html(html)
+      html = "<ul><li>one</li><li>two</li></ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -24,8 +24,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "Unnumbered Indent taken into account" do
       markdown = "   * one\n     one.one\n   * two"
-      html     = "<ul><li>one\none.one</li><li>two</li></ul>"
-      ast      = parse_html(html)
+      html = "<ul><li>one\none.one</li><li>two</li></ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -33,8 +33,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "Unnumbered two paras (removed from func tests)" do
       markdown = "* one\n\n    indent1\n"
-      html     = "<ul><li><p>one</p><p>  indent1</p></li></ul>"
-      ast      = parse_html(html)
+      html = "<ul><li><p>one</p><p>  indent1</p></li></ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -43,8 +43,8 @@ defmodule Acceptance.Ast.ListTest do
     # Not GFM conformant, >3 goes into the head of the item
     test "Indented items, by 4 (removed from func tests)" do
       markdown = "1. one\n    - two\n        - three"
-      html     = "<ol><li>one<ul><li>two<ul><li>three</li></ul></li></ul></li></ol>"
-      ast      = parse_html(html)
+      html = "<ol><li>one<ul><li>two<ul><li>three</li></ul></li></ul></li></ol>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -52,9 +52,11 @@ defmodule Acceptance.Ast.ListTest do
 
     test "Numbered" do
       markdown = "1.  A paragraph\n    with two lines.\n\n        indented code\n\n    > A block quote.\n"
-      ast      = [
+
+      ast = [
         ol(li([p(" A paragraph\nwith two lines."), pre_code("indented code"), blockquote("A block quote.")]))
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -62,7 +64,7 @@ defmodule Acceptance.Ast.ListTest do
 
     test "More numbers" do
       markdown = "1.  space one\n\n1. space two"
-      ast      = [ol([p(" space one"), p("space two")])]
+      ast = [ol([p(" space one"), p("space two")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -70,8 +72,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "can't count" do
       markdown = "- one\n\n two\n"
-      html     = "<ul><li>one</li></ul><p> two</p>"
-      ast      = parse_html(html)
+      html = "<ul><li>one</li></ul><p> two</p>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -79,8 +81,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "still not" do
       markdown = "- one\n- two"
-      html     = "<ul><li>one</li><li>two</li></ul>"
-      ast      = parse_html(html)
+      html = "<ul><li>one</li><li>two</li></ul>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -88,8 +90,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "the second one is not one" do
       markdown = "1. one\n1. two"
-      html     = "<ol><li>one</li><li>two</li></ol>"
-      ast      = parse_html(html)
+      html = "<ol><li>one</li><li>two</li></ol>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -98,7 +100,7 @@ defmodule Acceptance.Ast.ListTest do
     test "where shall we start" do
       markdown = "2. one\n3. two"
       html = "<ol start=\"2\"><li>one</li><li>two</li></ol>"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -114,8 +116,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "one?" do
       markdown = "2. one"
-      html     = "<ol start=\"2\"><li>one</li></ol>"
-      ast      = parse_html(html)
+      html = "<ol start=\"2\"><li>one</li></ol>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -123,8 +125,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "count or no count?" do
       markdown = "-one\n\n2.two\n"
-      html     = "<p>-one</p>\n<p>2.two</p>\n"
-      ast      = parse_html(html)
+      html = "<p>-one</p>\n<p>2.two</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -132,8 +134,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "list or no list?" do
       markdown = "-1. not ok\n"
-      html     = "<p>-1. not ok</p>"
-      ast      = parse_html(html)
+      html = "<p>-1. not ok</p>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -141,8 +143,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "no count or count?" do
       markdown = "1. foo\nbar"
-      html     = "<ol><li>foo\nbar</li></ol>"
-      ast      = parse_html(html)
+      html = "<ol><li>foo\nbar</li></ol>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -150,8 +152,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "where does it end?" do
       markdown = "* a\n    b\nc"
-      html     = "<ul>\n<li>a\n  b\nc</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>a\n  b\nc</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -159,8 +161,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "tables in lists? Maybe not" do
       markdown = "* x\n    a\n| A | B |"
-      html     = "<ul>\n<li>x\n  a\n| A | B |</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>x\n  a\n| A | B |</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -168,8 +170,8 @@ defmodule Acceptance.Ast.ListTest do
 
     test "nice try, but naah" do
       markdown = "* x\n | A | B |"
-      html     = "<ul>\n<li>x\n| A | B |</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>x\n| A | B |</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -179,27 +181,30 @@ defmodule Acceptance.Ast.ListTest do
   describe "list after para" do
     test "indented (was regtest #13)" do
       markdown = """
-    Para
+        Para
+
+        1. l1
 
-    1. l1
+        2. l2
+      """
 
-    2. l2
-  """
-      html     = """
-                     <p>  Para</p>
-                     <ol>
-                     <li><p>l1</p>
-                     </li>
-                     <li><p>l2</p>
-                     </li>
-                     </ol>
-                  """
-      ast      = parse_html(html)
+      html = """
+         <p>  Para</p>
+         <ol>
+         <li><p>l1</p>
+         </li>
+         <li><p>l2</p>
+         </li>
+         </ol>
+      """
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
+
   # describe "Inline code" do
   #   @tag :wip
   #   test "preserves spaces" do
diff --git a/test/acceptance/ast/lists/complex_body_test.exs b/test/acceptance/ast/lists/complex_body_test.exs
index 198f309..829f2ac 100644
--- a/test/acceptance/ast/lists/complex_body_test.exs
+++ b/test/acceptance/ast/lists/complex_body_test.exs
@@ -2,7 +2,6 @@ defmodule Test.Acceptance.Ast.Lists.ComplexBodyTest do
   use Support.AcceptanceTestCase
   import Support.AstHelpers, only: [ast_from_md: 1, ast_with_errors: 1]
 
-
   describe "Ending Bodies" do
     test "blank lines have no impact anymore" do
       markdown = """
@@ -11,9 +10,11 @@ defmodule Test.Acceptance.Ast.Lists.ComplexBodyTest do
 
         World
       """
+
       expected = [ul(li(tags("p", ["Hello", "World"])))]
       assert ast_from_md(markdown) == expected
     end
+
     test "blank lines and negative indent" do
       markdown = """
       * Hello
@@ -21,6 +22,7 @@ defmodule Test.Acceptance.Ast.Lists.ComplexBodyTest do
 
       World
       """
+
       expected = [ul("Hello"), p("World")]
       assert ast_from_md(markdown) == expected
     end
@@ -33,7 +35,9 @@ defmodule Test.Acceptance.Ast.Lists.ComplexBodyTest do
 
         ` World
       """
-      expected = {[ul(li(tags("p", ["Hello", "` World"])))] ,[{:warning, 3, "Closing unclosed backquotes ` at end of input"}]}
+
+      expected =
+        {[ul(li(tags("p", ["Hello", "` World"])))], [{:warning, 3, "Closing unclosed backquotes ` at end of input"}]}
 
       assert ast_with_errors(markdown) == expected
     end
@@ -44,12 +48,15 @@ defmodule Test.Acceptance.Ast.Lists.ComplexBodyTest do
       * Again
         ` World
       """
+
       expected = {
         [ul(["Hello", "Again\n` World"])],
-        [{:warning, 3, "Closing unclosed backquotes ` at end of input"}]}
+        [{:warning, 3, "Closing unclosed backquotes ` at end of input"}]
+      }
 
       assert ast_with_errors(markdown) == expected
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/lists/complex_head_test.exs b/test/acceptance/ast/lists/complex_head_test.exs
index 8739abf..6304dd6 100644
--- a/test/acceptance/ast/lists/complex_head_test.exs
+++ b/test/acceptance/ast/lists/complex_head_test.exs
@@ -8,27 +8,33 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       * First
                 Second
       """
+
       expected = [ul(li(["First", pre_code("    Second")]))]
       assert ast_from_md(markdown) == expected
     end
+
     test "before end of list" do
       markdown = """
       * Primo
                 Secondo
       # Ciao
       """
+
       expected = [ul(li(["Primo", pre_code("    Secondo")])), tag("h1", "Ciao")]
       assert ast_from_md(markdown) == expected
     end
+
     test "before and of list item" do
       markdown = """
       * первый
                 второй
       * Привет
       """
+
       expected = [ul([li(["первый", pre_code("    второй")]), li("Привет")])]
       assert ast_from_md(markdown) == expected
     end
+
     test "before body" do
       markdown = """
       * uma
@@ -36,6 +42,7 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
 
         Olá
       """
+
       expected = [ul(li([p("uma\n   duas"), p("Olá")]))]
       assert ast_from_md(markdown) == expected
     end
@@ -46,14 +53,17 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       markdown = """
       * > σπουδαίος
       """
+
       expected = [ul(blockquote("σπουδαίος"))]
       assert ast_from_md(markdown) == expected
     end
+
     test "blockquote in the middle" do
       markdown = """
       * banale
         > important
       """
+
       expected = [ul(li(["banale", blockquote("important")]))]
       assert ast_from_md(markdown) == expected
     end
@@ -66,6 +76,7 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
 
       Text
       """
+
       expected = [ul(["Rien à voir, circulez"]), p("Text")]
       assert ast_from_md(markdown) == expected
     end
@@ -78,19 +89,23 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
             > b
         > c
       """
+
       expected = [ul(li(["a", pre_code("> b"), blockquote("c")]))]
 
       assert ast_from_md(markdown) == expected
     end
+
     test "parse headlines in headers if they are indented _correctly_" do
       markdown = """
       - a
             # b
         # c
       """
+
       expected = [ul(li(["a", pre_code("# b"), tag("h1", "c")]))]
       assert ast_from_md(markdown) == expected
     end
+
     test "blocks with negative indent stop the list/item, but text does not" do
       markdown = """
       - a
@@ -98,10 +113,14 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       c
        > d
       """
+
       expected = [
-        ul(li(["a", blockquote("b\nc\nd")]))]
+        ul(li(["a", blockquote("b\nc\nd")]))
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "headline with negative indent stop the list/item definitely, but we need to align correctly" do
       markdown = """
       - a
@@ -109,10 +128,14 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       c
        # d
       """
+
       expected = [
-        ul(li(["a\n  ## b\nc", tag("h1", "d")]))]
+        ul(li(["a\n  ## b\nc", tag("h1", "d")]))
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "headline with negative indent stop the list/item definitely, if aligned correctly" do
       markdown = """
       - a
@@ -120,64 +143,87 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       c
       # d
       """
+
       expected = [
-        ul("a\n  ## b\nc"), tag("h1", "d")]
+        ul("a\n  ## b\nc"),
+        tag("h1", "d")
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "negatively indexed outside of a block element is still part of the item" do
       markdown = """
       - a
       c
       """
+
       expected = [
-        ul(li("a\nc"))]
+        ul(li("a\nc"))
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "negatively indexed outside of a block element is not part of the item after a header" do
       markdown = """
       - a
         # b
       c
       """
+
       expected = [
-        ul(li(["a", tag("h1", "b"), "c"]))]
+        ul(li(["a", tag("h1", "b"), "c"]))
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "negatively indexed outside of a block element is not part of the item after text" do
       markdown = """
       - a
         # b
       c
       """
+
       expected = [
-        ul(li(["a", tag("h1", "b"), "c"]))]
+        ul(li(["a", tag("h1", "b"), "c"]))
+      ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "negatively indexed outside of a block element is again part of the item after an indented header" do
       markdown = """
       - a
             # b
       c
       """
+
       expected = [ul(li(["a", pre_code("# b"), "c"]))]
       assert ast_from_md(markdown) == expected
     end
+
     test "block element negatively indexed ends the list" do
       markdown = """
       - a
       > b
       """
-      expected = [ ul(li(["a", blockquote("b")]))]
+
+      expected = [ul(li(["a", blockquote("b")]))]
       assert ast_from_md(markdown) == expected
     end
+
     test "header element negatively indexed ends the list" do
       markdown = """
       - a
       # b
       """
-      expected = [ ul("a"), tag("h1", "b")]
+
+      expected = [ul("a"), tag("h1", "b")]
       assert ast_from_md(markdown) == expected
     end
+
     test "code element negatively indexed ends the list, but not for us" do
       markdown = """
       - a
@@ -185,7 +231,8 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       b
       ```
       """
-      expected = [ ul(li(["a", pre_code("b")])) ]
+
+      expected = [ul(li(["a", pre_code("b")]))]
       assert ast_from_md(markdown) == expected
     end
   end
@@ -195,9 +242,11 @@ defmodule Test.Acceptance.Ast.Lists.ComplexHeadTest do
       markdown = """
       - a `
       """
-      expected = {[ul("a `")],[{:warning, 1, "Closing unclosed backquotes ` at end of input"}]}
+
+      expected = {[ul("a `")], [{:warning, 1, "Closing unclosed backquotes ` at end of input"}]}
       assert ast_with_errors(markdown) == expected
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/lists/indent_test.exs b/test/acceptance/ast/lists/indent_test.exs
index 2f19c39..a15f825 100644
--- a/test/acceptance/ast/lists/indent_test.exs
+++ b/test/acceptance/ast/lists/indent_test.exs
@@ -11,12 +11,14 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         Text2
       """
+
       expected = [
-        ul(
-          li([p("One"), p("Text1"), ul("Inner"), p("Text2")]))
+        ul(li([p("One"), p("Text1"), ul("Inner"), p("Text2")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "simple imbrication, spaced" do
       markdown = """
       * One
@@ -27,10 +29,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         Text2
       """
+
       expected = [
-        ul(
-          li([p("One"), p("Text1"), ul("Inner"), p("Text2")]))
+        ul(li([p("One"), p("Text1"), ul("Inner"), p("Text2")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -46,6 +49,7 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}
       """
+
       expected = [
         ul(
           li([
@@ -53,11 +57,19 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
             p("Text1"),
             ul(
               li([
-                "Inner"])),
+                "Inner"
+              ])
+            ),
             p("Text2"),
-            p(a("https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}",
-              href: "https://mydomain.org/user_or_team/repo_name/blob/master/%25%7Bpath%7D#L%25%7Bline%7D"))
-            ]))]
+            p(
+              a("https://mydomain.org/user_or_team/repo_name/blob/master/%{path}#L%{line}",
+                href: "https://mydomain.org/user_or_team/repo_name/blob/master/%25%7Bpath%7D#L%25%7Bline%7D"
+              )
+            )
+          ])
+        )
+      ]
+
       # IO.inspect as_ast(markdown)
       assert ast_from_md(markdown) == expected
     end
@@ -72,9 +84,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         Still Outer
       """
+
       expected = [
         ul(li([p("Outer"), p("Outer Content"), ul("Inner"), p("Still Outer")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -86,9 +100,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         Outer Para
       """
+
       expected = [
         ul(li([p("Outer"), ul("Inner"), p("Outer Para")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -99,9 +115,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
         Outer Para
       """
+
       expected = [
         ul(li([p("Outer"), ul("Inner"), p("Outer Para")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -112,9 +130,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
             - 1.1.1
         - 1.2
       """
+
       ast = [
         ul(li(["1", ul([li(["1.1", ul(li("1.1.1"))]), li("1.2")])]))
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -126,9 +146,11 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
 
       - Two
       """
+
       expected = [
         ul([li(p("One")), li(p("Two"))])
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -137,22 +159,28 @@ defmodule Test.Acceptance.Ast.Lists.IndentTest do
       - One
       - Two
       """
+
       expected = [
         ul([li("One"), li("Two")])
       ]
+
       assert ast_from_md(markdown) == expected
     end
+
     test "debugging" do
       markdown = """
       * Head
 
         Content
       """
+
       expected = [
         ul(li([p("Head"), p("Content")]))
       ]
+
       assert ast_from_md(markdown) == expected
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/lists/list_and_block_test.exs b/test/acceptance/ast/lists/list_and_block_test.exs
index 613f006..57a0d07 100644
--- a/test/acceptance/ast/lists/list_and_block_test.exs
+++ b/test/acceptance/ast/lists/list_and_block_test.exs
@@ -5,8 +5,9 @@ defmodule Acceptance.Ast.Lists.ListAndBlockTest do
     # Incorrect behavior needs to be fixed with #249 or #304
     test "two spaces" do
       markdown = "- a\n  > b"
-      html     = "<ul>\n<li>a<blockquote><p>b</p>\n</blockquote></li>\n</ul>\n"
-      ast      = parse_html(html) # |> IO.inspect(label: :ast)
+      html = "<ul>\n<li>a<blockquote><p>b</p>\n</blockquote></li>\n</ul>\n"
+      # |> IO.inspect(label: :ast)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,8 +15,8 @@ defmodule Acceptance.Ast.Lists.ListAndBlockTest do
 
     test "four spaces" do
       markdown = "- c\n    > d"
-      html     = "<ul>\n<li>c<blockquote><p>d</p>\n</blockquote>\n</li>\n</ul>\n"
-      ast      = parse_html(html)
+      html = "<ul>\n<li>c<blockquote><p>d</p>\n</blockquote>\n</li>\n</ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -38,16 +39,24 @@ defmodule Acceptance.Ast.Lists.ListAndBlockTest do
             https://mydomain.org/user_or_team/repo_name/blob/master/path
 
       """
-      ast = tag("ul", tag("li", [
-        p("List item1"),
-        p("Text1"),
-        tag("pre", tag("code", ["* List item2"])),
-        p("Text2"),
-        tag("pre", tag("code", " https://mydomain.org/user_or_team/repo_name/blob/master/path"))]))
+
+      ast =
+        tag(
+          "ul",
+          tag("li", [
+            p("List item1"),
+            p("Text1"),
+            tag("pre", tag("code", ["* List item2"])),
+            p("Text2"),
+            tag("pre", tag("code", " https://mydomain.org/user_or_team/repo_name/blob/master/path"))
+          ])
+        )
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "Regression #349/counter example" do
       markdown = """
       * List item1
@@ -61,14 +70,22 @@ defmodule Acceptance.Ast.Lists.ListAndBlockTest do
             https://mydomain.org/user_or_team/repo_name/blob/master/path
 
       """
+
       ast = [
         ul(
-          li([p("List item1"), p("Text1"), ul(li("List item2")), p("Text"),
-            pre_code("https://mydomain.org/user_or_team/repo_name/blob/master/path")]))]
+          li([
+            p("List item1"),
+            p("Text1"),
+            ul(li("List item2")),
+            p("Text"),
+            pre_code("https://mydomain.org/user_or_team/repo_name/blob/master/path")
+          ])
+        )
+      ]
 
       assert ast_from_md(markdown) == ast
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/lists/list_and_fenced_code_test.exs b/test/acceptance/ast/lists/list_and_fenced_code_test.exs
index 202a2d5..81639d6 100644
--- a/test/acceptance/ast/lists/list_and_fenced_code_test.exs
+++ b/test/acceptance/ast/lists/list_and_fenced_code_test.exs
@@ -18,13 +18,14 @@ defmodule Acceptance.Ast.Lists.ListAndencedCodeTest do
             innerer
           ```
       """
+
       level2_list =
         ul(li([p("Inner List"), pre_code("  innerer")]))
+
       ast = [
         code("  before", class: "elixir"),
-        ul(li([p("Header 1"),
-          code("   inner", class: "erlang"),
-          level2_list]))]
+        ul(li([p("Header 1"), code("   inner", class: "erlang"), level2_list]))
+      ]
 
       assert ast_from_md(markdown) == ast
     end
@@ -35,4 +36,5 @@ defmodule Acceptance.Ast.Lists.ListAndencedCodeTest do
     tag("pre", [tag("code", content, class: class)])
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/lists/list_and_inline_code_test.exs b/test/acceptance/ast/lists/list_and_inline_code_test.exs
index fc93248..32e884e 100644
--- a/test/acceptance/ast/lists/list_and_inline_code_test.exs
+++ b/test/acceptance/ast/lists/list_and_inline_code_test.exs
@@ -8,7 +8,8 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
       `Hello
       * World
       """
-      ast      = ul(tag("li", "And\n`Hello\n* World"))
+
+      ast = ul(tag("li", "And\n`Hello\n* World"))
       messages = [{:warning, 2, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
@@ -16,7 +17,7 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
 
     test "link with title" do
       markdown = ~s(* And\n* `Hello\n* World)
-      ast      = tag("ul", [tag("li", "And"), tag("li","`Hello\n* World")])
+      ast = tag("ul", [tag("li", "And"), tag("li", "`Hello\n* World")])
       messages = [{:warning, 2, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
@@ -24,7 +25,7 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
 
     test "error in spaced part" do
       markdown = ~s(* And\n  `Hello\n   * World)
-      ast      = tag("ul", tag("li", "And\n`Hello\n * World"))
+      ast = tag("ul", tag("li", "And\n`Hello\n * World"))
       messages = [{:warning, 2, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
@@ -37,7 +38,8 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
         `Hello
          * World
       """
-      ast      = ul(li(tags("p",["And",  "`Hello\n * World"])))
+
+      ast = ul(li(tags("p", ["And", "`Hello\n * World"])))
       messages = [{:warning, 3, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, [ast], messages}
@@ -51,7 +53,8 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
         `Hello
          * World
       """
-      ast      = [p("Prefix1"), tag("ul", tag("li", ["And\nPrefix2\n`Hello\n * World"]))]
+
+      ast = [p("Prefix1"), tag("ul", tag("li", ["And\nPrefix2\n`Hello\n * World"]))]
       messages = [{:warning, 4, "Closing unclosed backquotes ` at end of input"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
@@ -61,8 +64,8 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
   describe "indentation of code (was regtest #85)" do
     test "losing some indent" do
       markdown = "1. one\n\n    ```elixir\n    defmodule```\n"
-      html     = "<ol>\n<li><p>one</p>\n<pre><code class=\"elixir\"> defmodule```</code></pre>\n</li>\n</ol>\n"
-      ast      = parse_html(html)
+      html = "<ol>\n<li><p>one</p>\n<pre><code class=\"elixir\"> defmodule```</code></pre>\n</li>\n</ol>\n"
+      ast = parse_html(html)
       messages = [{:error, 3, "Fenced Code Block opened with ``` not closed at end of input"}]
 
       assert as_ast(markdown) == {:error, ast, messages}
@@ -70,19 +73,22 @@ defmodule Acceptance.Ast.Lists.ListAndInlineCodeTest do
 
     test "less aligned fence is not part of the inline code block" do
       markdown = "1. one\n\n    ~~~elixir\n    defmodule\n  ~~~"
-      ast      = [tag("ol", tag("li", [p("one"), tag("pre", tag("code", " defmodule", class: "elixir"))])), pre_code("")]
-      messages = [{:error, 3, "Fenced Code Block opened with ~~~ not closed at end of input"}, {:error, 5, "Fenced Code Block opened with ~~~ not closed at end of input"}]
+      ast = [tag("ol", tag("li", [p("one"), tag("pre", tag("code", " defmodule", class: "elixir"))])), pre_code("")]
+
+      messages = [
+        {:error, 3, "Fenced Code Block opened with ~~~ not closed at end of input"},
+        {:error, 5, "Fenced Code Block opened with ~~~ not closed at end of input"}
+      ]
 
       assert as_ast(markdown) == {:error, ast, messages}
     end
 
     test "more aligned fence is part of the inline code block" do
       markdown = "  1. one\n    ~~~elixir\n    defmodule\n        ~~~"
-      ast      = [tag("ol", tag("li", ["one", tag("pre", tag("code", ["defmodule"], [{"class", "elixir"}]))]))]
+      ast = [tag("ol", tag("li", ["one", tag("pre", tag("code", ["defmodule"], [{"class", "elixir"}]))]))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
-
   end
 end
diff --git a/test/acceptance/ast/lists/spaced_test.exs b/test/acceptance/ast/lists/spaced_test.exs
index cdc8dab..da45b99 100644
--- a/test/acceptance/ast/lists/spaced_test.exs
+++ b/test/acceptance/ast/lists/spaced_test.exs
@@ -8,10 +8,14 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
       This is `
       pending`
     """
+
     ast = [
-      ul(li([
-        p("Item 1"),
-        p(["This is ", inline_code("pending", [], %{line: 3})])]))
+      ul(
+        li([
+          p("Item 1"),
+          p(["This is ", inline_code("pending", [], %{line: 3})])
+        ])
+      )
     ]
 
     assert ast_from_md(markdown) == ast
@@ -24,10 +28,14 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
       This is `
       pending`
     """
+
     ast = [
-      ul(li([
-        p("Item 1"),
-        p(["This is ", inline_code("pending", [], %{line: 3})])]))
+      ul(
+        li([
+          p("Item 1"),
+          p(["This is ", inline_code("pending", [], %{line: 3})])
+        ])
+      )
     ]
 
     assert ast_from_md(markdown) == ast
@@ -40,6 +48,7 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
 
         Line 1
       """
+
       ast = [
         ul(li([p("Item 1"), p("Line 1")]))
       ]
@@ -54,6 +63,7 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
         `Line
         1`
       """
+
       ast = [
         ul(li([p("Item 1"), p(inline_code("Line 1", [], %{line: 3}))]))
       ]
@@ -69,6 +79,7 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
        Beta
     -------
     """
+
     ast = [
       ol(li(tags("p", ["Alpha", "Beta"]))),
       void_tag("hr", class: "thin")
@@ -84,6 +95,7 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
        Beta
     - Gamma
     """
+
     ast = [
       ol(li(tags("p", ["Alpha", "Beta"]))),
       ul(li("Gamma"))
@@ -98,4 +110,5 @@ defmodule Acceptance.Ast.Lists.SpacedPendingTest do
     {tag, attrs, content, Map.merge(meta, new_meta)}
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/math_test.exs b/test/acceptance/ast/math_test.exs
index 4907b3a..319091e 100644
--- a/test/acceptance/ast/math_test.exs
+++ b/test/acceptance/ast/math_test.exs
@@ -4,8 +4,8 @@ defmodule Acceptance.Ast.MathTest do
 
   test "ignored when :math is disabled" do
     markdown = "foo $x = 1$ bar $$x = 1$$"
-    html     = "<p>foo $x = 1$ bar $$x = 1$$</p>\n"
-    ast      = parse_html(html)
+    html = "<p>foo $x = 1$ bar $$x = 1$$</p>\n"
+    ast = parse_html(html)
     messages = []
 
     assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,8 +14,8 @@ defmodule Acceptance.Ast.MathTest do
   describe "math inline" do
     test "base case" do
       markdown = "foo $x = 1$"
-      html     = "<p>foo <code class=\"math-inline\">x = 1</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-inline\">x = 1</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -23,8 +23,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "with surrounding characters" do
       markdown = "foo$x = 1$bar"
-      html     = "<p>foo<code class=\"math-inline\">x = 1</code>bar</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo<code class=\"math-inline\">x = 1</code>bar</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -32,8 +32,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignored when where are spaces" do
       markdown = "foo $ x = 1$ bar $x = 1 $ baz $ x = 1 $"
-      html     = "<p>foo $ x = 1$ bar $x = 1 $ baz $ x = 1 $</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo $ x = 1$ bar $x = 1 $ baz $ x = 1 $</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -41,8 +41,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "accepts inner newline" do
       markdown = "foo $x\ny$"
-      html     = "<p>foo <code class=\"math-inline\">x\ny</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-inline\">x\ny</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -50,8 +50,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignored when the first dollar is escaped" do
       markdown = "foo \\$x = 1$"
-      html     = "<p>foo $x = 1$</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo $x = 1$</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -59,8 +59,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "keeps escaped inner dollar" do
       markdown = "foo $x \\$ y$"
-      html     = "<p>foo <code class=\"math-inline\">x \\$ y</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-inline\">x \\$ y</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -68,8 +68,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "keeps backslash" do
       markdown = "foo $\\frac{1}{2}$"
-      html     = "<p>foo <code class=\"math-inline\">\\frac{1}{2}</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-inline\">\\frac{1}{2}</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -77,8 +77,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignores inner markdown syntax" do
       markdown = "foo $x *y* x$"
-      html     = "<p>foo <code class=\"math-inline\">x *y* x</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-inline\">x *y* x</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -86,8 +86,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignores empty content" do
       markdown = "foo $$"
-      html     = "<p>foo $$</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo $$</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -95,8 +95,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "inside list" do
       markdown = "* $x = 1$"
-      html     = "<ul><li><code class=\"math-inline\">x = 1</code></li></ul>\n"
-      ast      = parse_html(html)
+      html = "<ul><li><code class=\"math-inline\">x = 1</code></li></ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -106,8 +106,8 @@ defmodule Acceptance.Ast.MathTest do
   describe "math display" do
     test "base case" do
       markdown = "foo $$x = 1$$"
-      html     = "<p>foo <code class=\"math-display\">x = 1</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">x = 1</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -115,8 +115,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "with surrounding characters" do
       markdown = "foo$$x = 1$$bar"
-      html     = "<p>foo<code class=\"math-display\">x = 1</code>bar</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo<code class=\"math-display\">x = 1</code>bar</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -124,8 +124,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "accepts spaces on delimiter boundaries" do
       markdown = "foo $$ x = 1 $$"
-      html     = "<p>foo <code class=\"math-display\">x = 1</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">x = 1</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -133,8 +133,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "accepts inner newlines" do
       markdown = "foo $$\nx\ny\n$$"
-      html     = "<p>foo <code class=\"math-display\">x\ny</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">x\ny</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -142,8 +142,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignored when the first dollars are escaped" do
       markdown = "foo \\$\\$x = 1$$"
-      html     = "<p>foo $$x = 1$$</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo $$x = 1$$</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -151,8 +151,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "keeps escaped inner dollar" do
       markdown = "foo $$x \\$ y$$"
-      html     = "<p>foo <code class=\"math-display\">x \\$ y</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">x \\$ y</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -160,8 +160,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "keeps backslash" do
       markdown = "foo $$\\frac{1}{2}$$"
-      html     = "<p>foo <code class=\"math-display\">\\frac{1}{2}</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">\\frac{1}{2}</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -169,8 +169,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignores inner markdown syntax" do
       markdown = "foo $$x *y* x$$"
-      html     = "<p>foo <code class=\"math-display\">x *y* x</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo <code class=\"math-display\">x *y* x</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -178,8 +178,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignores empty content" do
       markdown = "foo $$$$"
-      html     = "<p>foo $$$$</p>\n"
-      ast      = parse_html(html)
+      html = "<p>foo $$$$</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -187,8 +187,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "inside list" do
       markdown = "* $$x = 1$$"
-      html     = "<ul><li><code class=\"math-display\">x = 1</code></li></ul>\n"
-      ast      = parse_html(html)
+      html = "<ul><li><code class=\"math-display\">x = 1</code></li></ul>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -196,8 +196,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "standalone paragraph" do
       markdown = "$$\nx = 1\n$$"
-      html     = "<p><code class=\"math-display\">x = 1</code></p>\n"
-      ast      = parse_html(html)
+      html = "<p><code class=\"math-display\">x = 1</code></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
@@ -205,8 +205,8 @@ defmodule Acceptance.Ast.MathTest do
 
     test "ignored when there is an empty line (separate paragraphs)" do
       markdown = "$$x\n\ny$$"
-      html     = "<p>$$x</p><p>y$$</p>\n"
-      ast      = parse_html(html)
+      html = "<p>$$x</p><p>y$$</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, math: true) == {:ok, ast, messages}
diff --git a/test/acceptance/ast/paragraphs/annotated_paragraphs_test.exs b/test/acceptance/ast/paragraphs/annotated_paragraphs_test.exs
index 1d58db1..81165f4 100644
--- a/test/acceptance/ast/paragraphs/annotated_paragraphs_test.exs
+++ b/test/acceptance/ast/paragraphs/annotated_paragraphs_test.exs
@@ -8,15 +8,16 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
   describe "Paragraphs" do
     test "a para -- non-regression" do
       markdown = "aaa\n\nbbb\n"
-      html     = "<p>aaa</p>\n<p>bbb</p>\n"
-      ast      = parse_html(html)
+      html = "<p>aaa</p>\n<p>bbb</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown, annotations: @annotation) == {:ok, ast, messages}
     end
+
     test "a para" do
       markdown = "aaa-- a\n\nbbb-- b\n"
-      ast      = [p_annotated("aaa", "-- a"), p_annotated("bbb", "-- b")]
+      ast = [p_annotated("aaa", "-- a"), p_annotated("bbb", "-- b")]
       messages = []
 
       assert as_ast(markdown, annotations: @annotation) == {:ok, ast, messages}
@@ -24,8 +25,8 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "and another one" do
       markdown = "aaa\n\n\nbbb\n"
-      html     = "<p>aaa</p>\n<p>bbb</p>\n"
-      ast      = parse_html(html)
+      html = "<p>aaa</p>\n<p>bbb</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
@@ -33,8 +34,8 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "strong" do
       markdown = "**inside**"
-      html     = "<p><strong>inside</strong></p>"
-      ast      = parse_html(html)
+      html = "<p><strong>inside</strong></p>"
+      ast = parse_html(html)
       messages = []
 
       assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
@@ -42,8 +43,8 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "striketrhough" do
       markdown = "~~or maybe not?~~"
-      html     = "<p><del>or maybe not?</del></p>\n"
-      ast      = parse_html(html)
+      html = "<p><del>or maybe not?</del></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -51,7 +52,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "keeps paragraph source as AST content when :parse_inline is false" do
       markdown = "this *should* stay [unchanged]()"
-      ast      = [p([markdown])]
+      ast = [p([markdown])]
       messages = []
 
       assert as_ast(markdown, parse_inline: false) == {:ok, ast, messages}
@@ -61,7 +62,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
   describe "WS Separation (issue #10)" do
     test "simplest case" do
       markdown = "_primo_ _secondo_"
-      ast      = [ p([tag("em", "primo"), " ", tag("em", "secondo")])]
+      ast = [p([tag("em", "primo"), " ", tag("em", "secondo")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -69,7 +70,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "what about two links" do
       markdown = "[link one](aaa) [link two](bbb)"
-      ast      = [ p([tag("a", "link one", href: "aaa"), " ", tag("a", "link two", href: "bbb")])]
+      ast = [p([tag("a", "link one", href: "aaa"), " ", tag("a", "link two", href: "bbb")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -77,7 +78,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "before a link" do
       markdown = "hi [link](http://example.com)"
-      ast      = [p(["hi ", tag("a", "link", href: "http://example.com")])]
+      ast = [p(["hi ", tag("a", "link", href: "http://example.com")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -85,7 +86,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
 
     test "still before a link" do
       markdown = "**hi** [link](http://example.com)"
-      ast      = [p([tag("strong", "hi"), " ", tag("a", "link", href: "http://example.com")])]
+      ast = [p([tag("strong", "hi"), " ", tag("a", "link", href: "http://example.com")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -94,7 +95,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
     test "after an image" do
       markdown = "![look](http://an_image) hello"
       messages = []
-      ast      = [p([void_tag("img", src: "http://an_image", alt: "look"), " hello"])]
+      ast = [p([void_tag("img", src: "http://an_image", alt: "look"), " hello"])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -102,7 +103,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
     test "still after an image" do
       markdown = "![look](http://an_image) _hello_"
       messages = []
-      ast      = [p([void_tag("img", src: "http://an_image", alt: "look"), " ", tag("em", "hello")])]
+      ast = [p([void_tag("img", src: "http://an_image", alt: "look"), " ", tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -110,7 +111,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
     test "still after a link" do
       markdown = "[look](http://a_link) _hello_"
       messages = []
-      ast      = [p([tag("a", "look", href: "http://a_link"), " ", tag("em", "hello")])]
+      ast = [p([tag("a", "look", href: "http://a_link"), " ", tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -118,7 +119,7 @@ defmodule Acceptance.Ast.Paragraphs.AnnotatedParagraphsTest do
     test "there must not be one" do
       markdown = "[look](http://a_link)_hello_"
       messages = []
-      ast      = [p([tag("a", "look", href: "http://a_link"), tag("em", "hello")])]
+      ast = [p([tag("a", "look", href: "http://a_link"), tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
diff --git a/test/acceptance/ast/paragraphs/unannotated_paragraphs_test.exs b/test/acceptance/ast/paragraphs/unannotated_paragraphs_test.exs
index 5e2c6a7..24e4eca 100644
--- a/test/acceptance/ast/paragraphs/unannotated_paragraphs_test.exs
+++ b/test/acceptance/ast/paragraphs/unannotated_paragraphs_test.exs
@@ -7,8 +7,8 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
   describe "Paragraphs" do
     test "a para" do
       markdown = "aaa\n\nbbb\n"
-      html     = "<p>aaa</p>\n<p>bbb</p>\n"
-      ast      = parse_html(html)
+      html = "<p>aaa</p>\n<p>bbb</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,8 +16,8 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "and another one" do
       markdown = "aaa\n\n\nbbb\n"
-      html     = "<p>aaa</p>\n<p>bbb</p>\n"
-      ast      = parse_html(html)
+      html = "<p>aaa</p>\n<p>bbb</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
@@ -25,8 +25,8 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "strong" do
       markdown = "**inside**"
-      html     = "<p><strong>inside</strong></p>"
-      ast      = parse_html(html)
+      html = "<p><strong>inside</strong></p>"
+      ast = parse_html(html)
       messages = []
 
       assert EarmarkParser.as_ast(markdown) == {:ok, ast, messages}
@@ -34,8 +34,8 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "striketrhough" do
       markdown = "~~or maybe not?~~"
-      html     = "<p><del>or maybe not?</del></p>\n"
-      ast      = parse_html(html)
+      html = "<p><del>or maybe not?</del></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -43,7 +43,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "keeps paragraph source as AST content when :parse_inline is false" do
       markdown = "this *should* stay [unchanged]()"
-      ast      = [p([markdown])]
+      ast = [p([markdown])]
       messages = []
 
       assert as_ast(markdown, parse_inline: false) == {:ok, ast, messages}
@@ -53,7 +53,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
   describe "WS Separation (issue #10)" do
     test "simplest case" do
       markdown = "_primo_ _secondo_"
-      ast      = [ p([tag("em", "primo"), " ", tag("em", "secondo")])]
+      ast = [p([tag("em", "primo"), " ", tag("em", "secondo")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -61,7 +61,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "what about two links" do
       markdown = "[link one](aaa) [link two](bbb)"
-      ast      = [ p([tag("a", "link one", href: "aaa"), " ", tag("a", "link two", href: "bbb")])]
+      ast = [p([tag("a", "link one", href: "aaa"), " ", tag("a", "link two", href: "bbb")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -69,7 +69,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "before a link" do
       markdown = "hi [link](http://example.com)"
-      ast      = [p(["hi ", tag("a", "link", href: "http://example.com")])]
+      ast = [p(["hi ", tag("a", "link", href: "http://example.com")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -77,7 +77,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
 
     test "still before a link" do
       markdown = "**hi** [link](http://example.com)"
-      ast      = [p([tag("strong", "hi"), " ", tag("a", "link", href: "http://example.com")])]
+      ast = [p([tag("strong", "hi"), " ", tag("a", "link", href: "http://example.com")])]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -86,7 +86,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
     test "after an image" do
       markdown = "![look](http://an_image) hello"
       messages = []
-      ast      = [p([void_tag("img", src: "http://an_image", alt: "look"), " hello"])]
+      ast = [p([void_tag("img", src: "http://an_image", alt: "look"), " hello"])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -94,7 +94,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
     test "still after an image" do
       markdown = "![look](http://an_image) _hello_"
       messages = []
-      ast      = [p([void_tag("img", src: "http://an_image", alt: "look"), " ", tag("em", "hello")])]
+      ast = [p([void_tag("img", src: "http://an_image", alt: "look"), " ", tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -102,7 +102,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
     test "still after a link" do
       markdown = "[look](http://a_link) _hello_"
       messages = []
-      ast      = [p([tag("a", "look", href: "http://a_link"), " ", tag("em", "hello")])]
+      ast = [p([tag("a", "look", href: "http://a_link"), " ", tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
@@ -110,7 +110,7 @@ defmodule Acceptance.Ast.Paragraphs.UnannotatedParagraphsTest do
     test "there must not be one" do
       markdown = "[look](http://a_link)_hello_"
       messages = []
-      ast      = [p([tag("a", "look", href: "http://a_link"), tag("em", "hello")])]
+      ast = [p([tag("a", "look", href: "http://a_link"), tag("em", "hello")])]
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
diff --git a/test/acceptance/ast/pure_link_test.exs b/test/acceptance/ast/pure_link_test.exs
index 2cd455b..2a3a295 100644
--- a/test/acceptance/ast/pure_link_test.exs
+++ b/test/acceptance/ast/pure_link_test.exs
@@ -1,21 +1,21 @@
 defmodule Test.Acceptance.Ast.PureLinkTest do
   use Support.AcceptanceTestCase
 
-    test "closing parens can match opening parens at the end" do
-      link     = "http://www.google.com/search?q=business"
-      markdown = "(#{link})"
-      ast = p(["(", a(link, href: link), ")"])
+  test "closing parens can match opening parens at the end" do
+    link = "http://www.google.com/search?q=business"
+    markdown = "(#{link})"
+    ast = p(["(", a(link, href: link), ")"])
 
-      result   = as_ast(markdown)
-      assert result == {:ok, [ast], []}
-    end
+    result = as_ast(markdown)
+    assert result == {:ok, [ast], []}
+  end
 
-    test "not a link" do
-      ast = p("(")
-
-      result = as_ast("(")
-      assert result == {:ok, [ast], []}
-    end
+  test "not a link" do
+    ast = p("(")
 
+    result = as_ast("(")
+    assert result == {:ok, [ast], []}
+  end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/reflink_test.exs b/test/acceptance/ast/reflink_test.exs
index 497fbf8..cc99d93 100644
--- a/test/acceptance/ast/reflink_test.exs
+++ b/test/acceptance/ast/reflink_test.exs
@@ -5,8 +5,8 @@ defmodule Acceptance.Ast.ReflinkTest do
   describe "undefined reflinks" do
     test "simple case" do
       markdown = "[text] [reference]\n[reference1]: some_url"
-      html     = "<p>[text] [reference]</p>\n"
-      ast      = parse_html(html)
+      html = "<p>[text] [reference]</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,8 +14,8 @@ defmodule Acceptance.Ast.ReflinkTest do
 
     test "an image, one would assume..." do
       markdown = "![text] [reference]\n[reference1]: some_url"
-      html     = "<p>![text] [reference]</p>\n"
-      ast      = parse_html(html)
+      html = "<p>![text] [reference]</p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -25,8 +25,8 @@ defmodule Acceptance.Ast.ReflinkTest do
   describe "defined reflinks" do
     test "empty case" do
       markdown = "[] [reference]\n[reference]: some_url"
-      html     = "<p><a href=\"some_url\" title=\"\"></a></p>\n"
-      ast      = parse_html(html)
+      html = "<p><a href=\"some_url\" title=\"\"></a></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -42,8 +42,8 @@ defmodule Acceptance.Ast.ReflinkTest do
 
     test "simple case" do
       markdown = "[text] [reference]\n[reference]: some_url"
-      html     = "<p><a href=\"some_url\" title=\"\">text</a></p>\n"
-      ast      = parse_html(html)
+      html = "<p><a href=\"some_url\" title=\"\">text</a></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -55,7 +55,8 @@ defmodule Acceptance.Ast.ReflinkTest do
 
       [reference]: some_url
       """
-      ast      = [ul(li(a("text", href: "some_url", title: "")))]
+
+      ast = [ul(li(a("text", href: "some_url", title: "")))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -66,15 +67,17 @@ defmodule Acceptance.Ast.ReflinkTest do
       - [text] [reference]
       [reference]: some_url
       """
-      ast      = [ul(li(a("text", href: "some_url", title: "")))]
+
+      ast = [ul(li(a("text", href: "some_url", title: "")))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "not so simple case" do
       markdown = "[[]]]text] [reference]\n[reference]: some_url"
-      html     = "<p><a href=\"some_url\" title=\"\">[]]]text</a></p>\n"
-      ast      = parse_html(html)
+      html = "<p><a href=\"some_url\" title=\"\">[]]]text</a></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -82,8 +85,8 @@ defmodule Acceptance.Ast.ReflinkTest do
 
     test "titled case" do
       markdown = "[text] [reference]\n[reference]: some_url 'a title'"
-      html     = "<p><a href=\"some_url\" title=\"a title\">text</a></p>\n"
-      ast      = parse_html(html)
+      html = "<p><a href=\"some_url\" title=\"a title\">text</a></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -91,12 +94,13 @@ defmodule Acceptance.Ast.ReflinkTest do
 
     test "image with title" do
       markdown = "![text] [reference]\n[reference]: some_url 'a title'"
-      html     = "<p><img src=\"some_url\" alt=\"text\" title=\"a title\" /></p>\n"
-      ast      = parse_html(html)
+      html = "<p><img src=\"some_url\" alt=\"text\" title=\"a title\" /></p>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/setext_headers_test.exs b/test/acceptance/ast/setext_headers_test.exs
index 920f53f..ca1c9e2 100644
--- a/test/acceptance/ast/setext_headers_test.exs
+++ b/test/acceptance/ast/setext_headers_test.exs
@@ -4,11 +4,10 @@ defmodule Acceptance.Ast.SetextHeadersTest do
   import Support.Helpers, only: [as_ast: 1, parse_html: 1]
 
   describe "Base cases" do
-
     test "Level one" do
       markdown = "foo\n==="
-      html     = "<h1>foo</h1>\n"
-      ast      = parse_html(html)
+      html = "<h1>foo</h1>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -16,8 +15,8 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
     test "Level two" do
       markdown = "foo\n---"
-      html     = "<h2>foo</h2>\n"
-      ast      = parse_html(html)
+      html = "<h2>foo</h2>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -26,20 +25,18 @@ defmodule Acceptance.Ast.SetextHeadersTest do
     test "narrow escape" do
       markdown = "Foo\\\n----\n"
       html = "<h2>Foo\\</h2>\n"
-      ast      = parse_html(html)
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
-
   end
 
   describe "Combinations" do
-
     test "levels one and two" do
       markdown = "Foo *bar*\n=========\n\nFoo *bar*\n---------\n"
-      html     = "<h1>Foo <em>bar</em></h1>\n<h2>Foo <em>bar</em></h2>\n"
-      ast      = parse_html(html)
+      html = "<h1>Foo <em>bar</em></h1>\n<h2>Foo <em>bar</em></h2>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -47,14 +44,14 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
     test "and levels two and one" do
       markdown = "Foo\n-------------------------\n\nFoo\n=\n"
-      html     = "<h2>Foo</h2>\n<h1>Foo</h1>\n"
-      ast      = parse_html(html)
+      html = "<h2>Foo</h2>\n<h1>Foo</h1>\n"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
-
   end
+
   # There is no consensus on this one, I prefer to not define the behavior of this unless
   # there is a real use case
   # c.f. http://johnmacfarlane.net/babelmark2/?text=%60Foo%0A----%0A%60%0A%0A%3Ca+title%3D%22a+lot%0A---%0Aof+dashes%22%2F%3E%0A
@@ -62,11 +59,10 @@ defmodule Acceptance.Ast.SetextHeadersTest do
   #    markdown = "`Foo\n----\n`\n\n<a title=\"a lot\n---\nof dashes\"/>\n"
   #
   describe "Setext headers with some context" do
-
     test "h1 after an unordered list" do
       markdown = "* foo\n\nbar\n==="
-      html     = "<ul><li>foo</li></ul><h1>bar</h1>"
-      ast      = parse_html(html)
+      html = "<ul><li>foo</li></ul><h1>bar</h1>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -74,8 +70,8 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
     test "h2 after an unordered list" do
       markdown = "* foo\n\nbar\n---"
-      html     = "<ul><li>foo</li></ul><h2>bar</h2>"
-      ast      = parse_html(html)
+      html = "<ul><li>foo</li></ul><h2>bar</h2>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -83,8 +79,8 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
     test "h1 after an ordered list and pending text" do
       markdown = "1. foo\n\nbar\n===\ntext"
-      html     = "<ol><li>foo</li></ol><h1>bar</h1><p>text</p>"
-      ast      = parse_html(html)
+      html = "<ol><li>foo</li></ol><h1>bar</h1><p>text</p>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -92,8 +88,8 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
     test "h2 between two lists" do
       markdown = "* foo\n\nbar\n---\n\n1. baz"
-      html     = "<ul><li>foo</li></ul><h2>bar</h2><ol><li>baz</li></ol>"
-      ast      = parse_html(html)
+      html = "<ul><li>foo</li></ul><h2>bar</h2><ol><li>baz</li></ol>"
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -110,7 +106,8 @@ defmodule Acceptance.Ast.SetextHeadersTest do
 
       * baz
       """
-      ast      = [ol("foo"), tag("h2", "bar"), ul("baz")]
+
+      ast = [ol("foo"), tag("h2", "bar"), ul("baz")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -118,17 +115,18 @@ defmodule Acceptance.Ast.SetextHeadersTest do
   end
 
   describe "after a table" do
-
     test "h2 after a table" do
       markdown = "|a|b|\n|d|e|\nbar\n---"
-      html     = "<table><tbody><tr>\n<td style=\"text-align: left;\">a</td><td style=\"text-align: left;\">b</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">d</td><td style=\"text-align: left;\">e</td>\n</tr>\n</tbody>\n</table>\n<h2>bar</h2>\n"
-      ast      = parse_html(html)
+
+      html =
+        "<table><tbody><tr>\n<td style=\"text-align: left;\">a</td><td style=\"text-align: left;\">b</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">d</td><td style=\"text-align: left;\">e</td>\n</tr>\n</tbody>\n</table>\n<h2>bar</h2>\n"
+
+      ast = parse_html(html)
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
-
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/sub_sup_test.exs b/test/acceptance/ast/sub_sup_test.exs
index 4452245..8578f41 100644
--- a/test/acceptance/ast/sub_sup_test.exs
+++ b/test/acceptance/ast/sub_sup_test.exs
@@ -6,7 +6,7 @@ defmodule Acceptance.Ast.SubSupTest do
   describe "without option set" do
     test "sub" do
       markdown = "This is H~2~O, only water"
-      ast      = [p("This is H~2~O, only water")]
+      ast = [p("This is H~2~O, only water")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -14,7 +14,7 @@ defmodule Acceptance.Ast.SubSupTest do
 
     test "super" do
       markdown = "we get O(n^2^)"
-      ast      = [p("we get O(n^2^)")]
+      ast = [p("we get O(n^2^)")]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -24,7 +24,7 @@ defmodule Acceptance.Ast.SubSupTest do
   describe "with option set" do
     test "sub" do
       markdown = "This is H~2~O, only water"
-      ast      = [p(["This is H", tag("sub", "2"), "O, only water"])]
+      ast = [p(["This is H", tag("sub", "2"), "O, only water"])]
       messages = []
 
       assert as_ast(markdown, sub_sup: true) == {:ok, ast, messages}
@@ -32,7 +32,7 @@ defmodule Acceptance.Ast.SubSupTest do
 
     test "super" do
       markdown = "we get O(n^2^)"
-      ast      = [p(["we get O(n", tag("sup", "2"), ")"])]
+      ast = [p(["we get O(n", tag("sup", "2"), ")"])]
       messages = []
 
       assert as_ast(markdown, sub_sup: true) == {:ok, ast, messages}
@@ -42,21 +42,23 @@ defmodule Acceptance.Ast.SubSupTest do
   describe "regression with all" do
     test "with all" do
       markdown = "n^2^"
-      ast      = [p(["n", tag("sup", "2")])]
+      ast = [p(["n", tag("sup", "2")])]
       messages = []
 
       assert as_ast(markdown, all: true) == {:ok, ast, messages}
     end
+
     test "with sub_sup" do
       markdown = "n^2^"
-      ast      = [p(["n", tag("sup", "2")])]
+      ast = [p(["n", tag("sup", "2")])]
       messages = []
 
       assert as_ast(markdown, all: true) == {:ok, ast, messages}
     end
+
     test "with sub_sup and all" do
       markdown = "n^2^"
-      ast      = [p(["n", tag("sup", "2")])]
+      ast = [p(["n", tag("sup", "2")])]
       messages = []
 
       assert as_ast(markdown, sub_sup: true, all: true) == {:ok, ast, messages}
@@ -66,25 +68,28 @@ defmodule Acceptance.Ast.SubSupTest do
   describe "works with sub" do
     test "with all" do
       markdown = "n~2~"
-      ast      = [p(["n", tag("sub", "2")])]
+      ast = [p(["n", tag("sub", "2")])]
       messages = []
 
       assert as_ast(markdown, all: true) == {:ok, ast, messages}
     end
+
     test "with sub_sub" do
       markdown = "n~2~"
-      ast      = [p(["n", tag("sub", "2")])]
+      ast = [p(["n", tag("sub", "2")])]
       messages = []
 
       assert as_ast(markdown, all: true) == {:ok, ast, messages}
     end
+
     test "with sub_sub and all" do
       markdown = "n~2~"
-      ast      = [p(["n", tag("sub", "2")])]
+      ast = [p(["n", tag("sub", "2")])]
       messages = []
 
       assert as_ast(markdown, sub_sup: true, all: true) == {:ok, ast, messages}
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/ast/table_test.exs b/test/acceptance/ast/table_test.exs
index 6172421..12f39a3 100644
--- a/test/acceptance/ast/table_test.exs
+++ b/test/acceptance/ast/table_test.exs
@@ -30,6 +30,7 @@ defmodule Acceptance.Ast.TableTest do
           tbody([td("c"), td("d")])
         ])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -83,7 +84,6 @@ defmodule Acceptance.Ast.TableTest do
       assert as_ast(markdown) == {:ok, ast, messages}
     end
 
-
     test "table with header inside context" do
       markdown = "before\n\n|alpha|beta|\n|-|-:|\n|1|2|\nafter"
 
diff --git a/test/acceptance/ast/utf8_test.exs b/test/acceptance/ast/utf8_test.exs
index 9e3c56a..71a1992 100644
--- a/test/acceptance/ast/utf8_test.exs
+++ b/test/acceptance/ast/utf8_test.exs
@@ -12,4 +12,5 @@ defmodule Acceptance.Ast.Utf8Test do
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/error_handling/bad_arguments_test.exs b/test/acceptance/error_handling/bad_arguments_test.exs
index 2a83e13..cb4d7c2 100644
--- a/test/acceptance/error_handling/bad_arguments_test.exs
+++ b/test/acceptance/error_handling/bad_arguments_test.exs
@@ -5,7 +5,7 @@ defmodule Acceptance.ErrorHandling.BadArgumentsTest do
 
   describe "monary as_ast" do
     test "raise Argument error for keyword input" do
-      assert_raise(ArgumentError, "line number 1 {:hello, \"world\"} is not a binary", fn -> as_ast([hello: "world"]) end)
+      assert_raise(ArgumentError, "line number 1 {:hello, \"world\"} is not a binary", fn -> as_ast(hello: "world") end)
     end
 
     test "raise ArgumentError for a map" do
@@ -29,4 +29,5 @@ defmodule Acceptance.ErrorHandling.BadArgumentsTest do
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i002-accept-any-struct-as-option_test.exs b/test/acceptance/regressions/i002-accept-any-struct-as-option_test.exs
index 8fc5dd5..5f0b30f 100644
--- a/test/acceptance/regressions/i002-accept-any-struct-as-option_test.exs
+++ b/test/acceptance/regressions/i002-accept-any-struct-as-option_test.exs
@@ -2,7 +2,8 @@ defmodule Acceptance.Regressions.I002AcceptAnyStructAsOptionTest do
   use ExUnit.Case
 
   import EarmarkParser, only: [as_ast: 2]
-defmodule MyStruct do
+
+  defmodule MyStruct do
     defstruct pure_links: false
   end
 
diff --git a/test/acceptance/regressions/i023_missing_error_end_codeblock_test.exs b/test/acceptance/regressions/i023_missing_error_end_codeblock_test.exs
index 625a9a8..546a9e0 100644
--- a/test/acceptance/regressions/i023_missing_error_end_codeblock_test.exs
+++ b/test/acceptance/regressions/i023_missing_error_end_codeblock_test.exs
@@ -8,17 +8,20 @@ defmodule Test.Acceptance.Regressions.I023MissingErrorEndCodeblockTest do
         content
       ````
       """
+
       ast = [pre_code("  content\n````")]
       expected = {:error, ast, [{:error, 1, "Fenced Code Block opened with ``` not closed at end of input"}]}
 
       assert as_ast(markdown) == expected
     end
+
     test "no error message" do
       markdown = """
       ```
         content
       ```
       """
+
       ast = [pre_code("  content")]
       expected = {:ok, ast, []}
 
@@ -26,4 +29,5 @@ defmodule Test.Acceptance.Regressions.I023MissingErrorEndCodeblockTest do
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i028-side-by-side-links_test.exs b/test/acceptance/regressions/i028-side-by-side-links_test.exs
index f8c403c..909a496 100644
--- a/test/acceptance/regressions/i028-side-by-side-links_test.exs
+++ b/test/acceptance/regressions/i028-side-by-side-links_test.exs
@@ -12,11 +12,13 @@ defmodule Test.Acceptance.Regressions.I028Test do
 
       [href]: some_url
       """
-      ast      = [ p(img([src: "some_url", alt: "img", title: ""])) ]
+
+      ast = [p(img(src: "some_url", alt: "img", title: ""))]
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "side by side" do
       markdown = """
       ![Crate][crate_img][crate]
@@ -24,13 +26,19 @@ defmodule Test.Acceptance.Regressions.I028Test do
       [crate_img]:   https://img.shields.io/crates/v/calm_io.svg "Crate Version Display"
       [crate]:       https://crates.io/crates/calm_io "Crate Link"
       """
-      ast      = [ p(
-                   [img(src:  "https://img.shields.io/crates/v/calm_io.svg", alt: "Crate", title: "Crate Version Display"),
-                    a(["crate", href:  "https://crates.io/crates/calm_io", title:  "Crate Link"])]) ]
+
+      ast = [
+        p([
+          img(src: "https://img.shields.io/crates/v/calm_io.svg", alt: "Crate", title: "Crate Version Display"),
+          a(["crate", href: "https://crates.io/crates/calm_io", title: "Crate Link"])
+        ])
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "two side by side" do
       markdown = """
       ![Crate][crate_img][crate]
@@ -41,18 +49,22 @@ defmodule Test.Acceptance.Regressions.I028Test do
       [second_img]:  image_url "ImgTitle"
       [second_link]: link_url "LinkTitle"
       """
-      ast      = [ p(
-                   [
-                     img(src:  "https://img.shields.io/crates/v/calm_io.svg", alt: "Crate", title: "Crate Version Display"),
-                     a(["crate", href:  "https://crates.io/crates/calm_io", title:  "Crate Link"]), "\n",
-                     img(src:  "image_url", alt: "Second", title: "ImgTitle"),
-                     a(["second_link", href:  "link_url", title:  "LinkTitle"]),
-
-                  ]) ]
+
+      ast = [
+        p([
+          img(src: "https://img.shields.io/crates/v/calm_io.svg", alt: "Crate", title: "Crate Version Display"),
+          a(["crate", href: "https://crates.io/crates/calm_io", title: "Crate Link"]),
+          "\n",
+          img(src: "image_url", alt: "Second", title: "ImgTitle"),
+          a(["second_link", href: "link_url", title: "LinkTitle"])
+        ])
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "image as link content" do
       markdown = """
       [![Crate][crate_img]][crate]
@@ -60,9 +72,11 @@ defmodule Test.Acceptance.Regressions.I028Test do
       [crate]:       crate_url "Link"
       [crate_img]:   crate_image_url "Image"
       """
+
       ast = [
-        p( a([img(src: "crate_image_url", alt: "Crate", title: "Image"), href: "crate_url", title: "Link"]) )
+        p(a([img(src: "crate_image_url", alt: "Crate", title: "Image"), href: "crate_url", title: "Link"]))
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -76,18 +90,36 @@ defmodule Test.Acceptance.Regressions.I028Test do
 
       [href]: some_url
       """
-      ast = [{"p", [], [{"img", [{"src", "some_url"}, {"alt", "img"}, {"title", ""}], [], %{}}, {"a", [{"href", "url"}], ["world"], %{}}], %{}}]
+
+      ast = [
+        {"p", [],
+         [
+           {"img", [{"src", "some_url"}, {"alt", "img"}, {"title", ""}], [], %{}},
+           {"a", [{"href", "url"}], ["world"], %{}}
+         ], %{}}
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "simple image link with suffix and space" do
       markdown = """
       ![img][href] [world](url)
 
       [href]: some_url
       """
-      ast = [{"p", [], [{"img", [{"src", "some_url"}, {"alt", "img"}, {"title", ""}], [], %{}}, " ", {"a", [{"href", "url"}], ["world"], %{}}], %{}}]
+
+      ast = [
+        {"p", [],
+         [
+           {"img", [{"src", "some_url"}, {"alt", "img"}, {"title", ""}], [], %{}},
+           " ",
+           {"a", [{"href", "url"}], ["world"], %{}}
+         ], %{}}
+      ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
@@ -102,32 +134,42 @@ defmodule Test.Acceptance.Regressions.I028Test do
       [lnk1]:       lnk1_url "Link1"
       [img1]:       img1_url "Image1"
       """
+
       ast = [
         p([
-          a([img(src: "img1_url", alt: "Img1", title: "Image1"), href: "lnk1_url", title: "Link1"]),
+          a([img(src: "img1_url", alt: "Img1", title: "Image1"), href: "lnk1_url", title: "Link1"])
         ])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
+
     test "simple rendering of a reflink" do
       markdown = """
       [**strong**][lnk1]
 
       [lnk1]:       lnk1_url "Link1"
       """
+
       ast = [
         p([
-          a([{"strong", [], ["strong"], %{}}, href: "lnk1_url", title: "Link1"]),
+          a([{"strong", [], ["strong"], %{}}, href: "lnk1_url", title: "Link1"])
         ])
       ]
+
       messages = []
 
       assert as_ast(markdown) == {:ok, ast, messages}
     end
   end
 
-  defp a([content|atts]), do: tag("a", [content], atts)
-  defp img(atts), do: tag("img", [], atts)
+  defp a([content | atts]) do
+    tag("a", [content], atts)
+  end
+
+  defp img(atts) do
+    tag("img", [], atts)
+  end
 end
diff --git a/test/acceptance/regressions/i065-bad-lnb-ref-style_test.exs b/test/acceptance/regressions/i065-bad-lnb-ref-style_test.exs
index 909f69b..ba8ee07 100644
--- a/test/acceptance/regressions/i065-bad-lnb-ref-style_test.exs
+++ b/test/acceptance/regressions/i065-bad-lnb-ref-style_test.exs
@@ -1,5 +1,4 @@
 defmodule Test.Acceptance.Regressions.I065BadLnbRefStyleTest do
-
   use ExUnit.Case
 
   @min_case """
@@ -57,4 +56,5 @@ defmodule Test.Acceptance.Regressions.I065BadLnbRefStyleTest do
     assert message == {:warning, 3, "Closing unclosed backquotes ` at end of input"}
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i086-bad-options_test.exs b/test/acceptance/regressions/i086-bad-options_test.exs
index 50dd68d..fdda98a 100644
--- a/test/acceptance/regressions/i086-bad-options_test.exs
+++ b/test/acceptance/regressions/i086-bad-options_test.exs
@@ -4,7 +4,10 @@ defmodule Test.Acceptance.Regressions.I086BadOptionsTest do
   describe "can pass a bad option" do
     test "bad option is corrected and get deprecation" do
       ast = [{"p", [], ["some text"], %{}}]
-      messages = [{:deprecated, 0, "messages is an internal option that is ignored and will be removed from the API in v1.5"}]
+
+      messages = [
+        {:deprecated, 0, "messages is an internal option that is ignored and will be removed from the API in v1.5"}
+      ]
 
       assert EarmarkParser.as_ast("some text", messages: []) == {:ok, ast, messages}
     end
@@ -14,4 +17,5 @@ defmodule Test.Acceptance.Regressions.I086BadOptionsTest do
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i098-l1-set-header-after-code_test.exs b/test/acceptance/regressions/i098-l1-set-header-after-code_test.exs
index ab6cd08..cc61a12 100644
--- a/test/acceptance/regressions/i098-l1-set-header-after-code_test.exs
+++ b/test/acceptance/regressions/i098-l1-set-header-after-code_test.exs
@@ -42,6 +42,6 @@ defmodule Test.Acceptance.Regressions.I098L1SetHeaderAfterCodeTest do
 
     assert as_ast(@h2_case) == {:ok, ast, messages}
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i154_parser_crash_symbolic_input_test.exs b/test/acceptance/regressions/i154_parser_crash_symbolic_input_test.exs
index 2ef4937..d063ca5 100644
--- a/test/acceptance/regressions/i154_parser_crash_symbolic_input_test.exs
+++ b/test/acceptance/regressions/i154_parser_crash_symbolic_input_test.exs
@@ -5,19 +5,19 @@ defmodule Test.Acceptance.Regressions.I154pArserCrashSymbolicInputTest do
   import EarmarkAstDsl
 
   test "this should not crash" do
-    ast = [ p("[{:}") ]
+    ast = [p("[{:}")]
     messages = []
     assert as_ast("\\[{:}") == {:ok, ast, messages}
   end
 
   test "this does not crash" do
-    ast = [ p("[{:") ]
+    ast = [p("[{:")]
     messages = []
     assert as_ast("\\[{:") == {:ok, ast, messages}
   end
 
   test "nor does this" do
-    ast = [ p("[{:}") ]
+    ast = [p("[{:}")]
     messages = []
     assert as_ast("[{:}") == {:ok, ast, messages}
   end
@@ -26,7 +26,7 @@ defmodule Test.Acceptance.Regressions.I154pArserCrashSymbolicInputTest do
     ast = [{"p", [], [{"em", [], ["a"], %{}}], %{}}]
     messages = []
     assert as_ast("*a*{:}") == {:ok, ast, messages}
-    
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/regressions/i161_indent_code_blocks_test.exs b/test/acceptance/regressions/i161_indent_code_blocks_test.exs
index f8a5829..684ae88 100644
--- a/test/acceptance/regressions/i161_indent_code_blocks_test.exs
+++ b/test/acceptance/regressions/i161_indent_code_blocks_test.exs
@@ -10,13 +10,16 @@ defmodule Test.Acceptance.Regressions.I161IndentCodeBlocksTest do
          def foo
          ```
       """
+
       expected = [
         ol(
           li([
             p("Test"),
             tag("pre", tag("code", "def foo", class: "elixir"))
-          ]))
+          ])
+        )
       ]
+
       assert ast_from_md(markdown) == expected
     end
 
@@ -29,15 +32,19 @@ defmodule Test.Acceptance.Regressions.I161IndentCodeBlocksTest do
           def foo
           ```
       """
+
       expected = [
         ol(
           li([
             p("Test"),
             tag("pre", tag("code", "def foo", class: "elixir"))
-          ]))
+          ])
+        )
       ]
+
       assert ast_from_md(markdown) == expected
     end
   end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/acceptance/renderer/ast_walker_test.exs b/test/acceptance/renderer/ast_walker_test.exs
index 6ff37d1..6b81dd5 100644
--- a/test/acceptance/renderer/ast_walker_test.exs
+++ b/test/acceptance/renderer/ast_walker_test.exs
@@ -9,6 +9,7 @@ defmodule Acceptance.Renderer.AstWalkerTest do
 
       assert walk_ast(ast, &replace_empty/1) == expected
     end
+
     test "can descend" do
       ast = [tags("p", ["alpha", "empty"])]
       expected = [tags("p", ["alpha", []])]
@@ -17,7 +18,13 @@ defmodule Acceptance.Renderer.AstWalkerTest do
     end
   end
 
-  def replace_empty("empty"), do: []
-  def replace_empty(str), do: str
+  def replace_empty("empty") do
+    []
+  end
+
+  def replace_empty(str) do
+    str
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/earmark_helpers_tests/attr_parser_test.exs b/test/earmark_helpers_tests/attr_parser_test.exs
index c0ecdb5..ea47696 100644
--- a/test/earmark_helpers_tests/attr_parser_test.exs
+++ b/test/earmark_helpers_tests/attr_parser_test.exs
@@ -6,37 +6,46 @@ defmodule EarmarkParserHelpersTests.AttrParserTest do
   # describe "without errors" do  # still using Elixir 1.2
   #
   test "empty" do
-    assert_parsed_as( %{}, "")
+    assert_parsed_as(%{}, "")
   end
+
   test "base case" do
     assert_parsed_as(%{"title" => ~W[Pragdave]}, "title=Pragdave")
     assert_parsed_as(%{"authors" => ~W[Pragdave RobertDober]}, "authors=RobertDober authors=Pragdave")
   end
+
   test "many base cases" do
     assert_parsed_as(%{"title" => ~W[Pragdave], "alt" => ~W[Control]}, "title=Pragdave alt='Control'")
   end
+
   test "shortcuts" do
-    assert_parsed_as(%{"class" => ~W[80]},".80")
-    assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]},".80 #awesome-42")
-    assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]},"#awesome-42 .80")
+    assert_parsed_as(%{"class" => ~W[80]}, ".80")
+    assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]}, ".80 #awesome-42")
+    assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]}, "#awesome-42 .80")
   end
+
   test "double id" do
-    assert_parsed_as(%{"id" => ~W[id2 id1]},"#id1 #id2")
+    assert_parsed_as(%{"id" => ~W[id2 id1]}, "#id1 #id2")
   end
+
   test "what about #" do
-    assert_parsed_as(%{},"# 80")
+    assert_parsed_as(%{}, "# 80")
   end
+
   test "a wild mix" do
     assert_parsed_as(
       %{
-        "alt" => ["motion picture"], "class" => ["satchmo", "crooner", "upperclass"], "id" => ["Doris"], "title" => ["made my Day", "hello"]
+        "alt" => ["motion picture"],
+        "class" => ["satchmo", "crooner", "upperclass"],
+        "id" => ["Doris"],
+        "title" => ["made my Day", "hello"]
       },
       "title='hello' .upperclass .crooner alt=\"motion picture\" #Doris title='made my Day' .satchmo"
     )
   end
 
   test "ignored attribute spec" do
-    assert_parsed_as(%{}," # 80")
+    assert_parsed_as(%{}, " # 80")
   end
 
   #
@@ -44,48 +53,66 @@ defmodule EarmarkParserHelpersTests.AttrParserTest do
   #
   describe "base case - with errors" do
     test "bare error" do
-      assert_parsed_as(%{"title" => ~W[Pragdave]}, "error title=Pragdave", errors: "error" )
+      assert_parsed_as(%{"title" => ~W[Pragdave]}, "error title=Pragdave", errors: "error")
     end
+
     test "error at end" do
-      assert_parsed_as(%{"title" => ~W[Pragdave]}, "title=Pragdave error", errors: "error" )
+      assert_parsed_as(%{"title" => ~W[Pragdave]}, "title=Pragdave error", errors: "error")
     end
+
     test "two errors" do
-      assert_parsed_as(%{"title" => ~W[Pragdave]}, "error= title=Pragdave error", errors: ~W[error error=] )
+      assert_parsed_as(%{"title" => ~W[Pragdave]}, "error= title=Pragdave error", errors: ~W[error error=])
     end
   end
+
   test "many base cases - with errors" do
-    assert_parsed_as(%{"title" => ~W[Pragdave], "alt" => ~W[Control]}, "error title=Pragdave alt='Control'", errors: "error")
+    assert_parsed_as(%{"title" => ~W[Pragdave], "alt" => ~W[Control]}, "error title=Pragdave alt='Control'",
+      errors: "error"
+    )
   end
+
   describe "shortcuts - with errors" do
     test "class 80" do
-      assert_parsed_as(%{"class" => ~W[80]},".80 error", errors: "error")
-
+      assert_parsed_as(%{"class" => ~W[80]}, ".80 error", errors: "error")
     end
+
     test "awesome 42" do
-      assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]},".80 error #awesome-42", errors: "error")
+      assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]}, ".80 error #awesome-42", errors: "error")
     end
 
     test "awesome id" do
-      assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]},"#awesome-42 .80 error", errors: "error")
+      assert_parsed_as(%{"class" => ~W[80], "id" => ~W[awesome-42]}, "#awesome-42 .80 error", errors: "error")
     end
   end
+
   test "a wild mix - with errors" do
     assert_parsed_as(
       %{
-        "alt" => ["motion picture"], "class" => ["satchmo", "crooner", "upperclass"], "id" => ["Doris"], "title" => ["made my Day", "hello"]
+        "alt" => ["motion picture"],
+        "class" => ["satchmo", "crooner", "upperclass"],
+        "id" => ["Doris"],
+        "title" => ["made my Day", "hello"]
       },
       "title='hello' .upperclass   one% .crooner alt=\"motion picture\" two- #Doris title='made my Day' .satchmo    three",
       errors: ~W[three two- one%]
     )
   end
 
-  defp assert_parsed_as( attrs, str, errors \\ [errors: []]  ) do
-    errors = Keyword.get( errors, :errors )
-    errors = if is_list(errors), do: errors, else: [errors]
-    {context, result} = parse_attrs( %EarmarkParser.Context{}, str, 0 )
+  defp assert_parsed_as(attrs, str, errors \\ [errors: []]) do
+    errors = Keyword.get(errors, :errors)
+
+    errors =
+      if is_list(errors) do
+        errors
+      else
+        [errors]
+      end
+
+    {context, result} = parse_attrs(%EarmarkParser.Context{}, str, 0)
     assert attrs == result
+
     unless Enum.empty?(errors) do
-      expected = [{:warning, 0, "Illegal attributes #{inspect errors} ignored in IAL"}]
+      expected = [{:warning, 0, "Illegal attributes #{inspect(errors)} ignored in IAL"}]
       assert context.options.messages == MapSet.new(expected)
     end
   end
diff --git a/test/earmark_helpers_tests/link_parser_test.exs b/test/earmark_helpers_tests/link_parser_test.exs
index a9f3087..5457743 100644
--- a/test/earmark_helpers_tests/link_parser_test.exs
+++ b/test/earmark_helpers_tests/link_parser_test.exs
@@ -55,15 +55,18 @@ defmodule EarmarkParserHelpersTests.LinkParserTest do
     end
 
     test "url part: complex imbrication" do
-      assert parse_link("[text](pre](in fix)suff)") == {~s<[text](pre](in fix)suff)>, ~s<text>, ~s<pre](in fix)suff>, nil, :link}
+      assert parse_link("[text](pre](in fix)suff)") ==
+               {~s<[text](pre](in fix)suff)>, ~s<text>, ~s<pre](in fix)suff>, nil, :link}
     end
 
     test "url part: deep imbrication" do
-      assert parse_link("[text](a(1)[((2) \\\\one)z)") == {~s<[text](a(1)[((2) \\one)z)>, ~s<text>, ~s<a(1)[((2) \\one)z>, nil, :link}
+      assert parse_link("[text](a(1)[((2) \\\\one)z)") ==
+               {~s<[text](a(1)[((2) \\one)z)>, ~s<text>, ~s<a(1)[((2) \\one)z>, nil, :link}
     end
 
     test "url part: simple, text part: escapes" do
-      assert parse_link("[hello \\*world\\*](url)") == {~s<[hello \\*world\\*](url)>, ~s<hello \\*world\\*>, ~s<url>, nil, :link}
+      assert parse_link("[hello \\*world\\*](url)") ==
+               {~s<[hello \\*world\\*](url)>, ~s<hello \\*world\\*>, ~s<url>, nil, :link}
     end
 
     test "url part: missing closing parens" do
@@ -138,10 +141,12 @@ defmodule EarmarkParserHelpersTests.LinkParserTest do
     test "finally!!!" do
       assert parse_link("![text](pre[\\()") == {~s<![text](pre[()>, ~s<text>, ~s<pre[(>, nil, :image}
     end
-    test "and with leading spaces" do 
+
+    test "and with leading spaces" do
       assert parse_link(" ![text](pre[\\()") == nil
     end
   end
+
   defp parse_link(markdown) do
     EarmarkParser.Parser.LinkParser.parse_link(markdown, 0)
   end
diff --git a/test/earmark_helpers_tests/pure_link_helper_test.exs b/test/earmark_helpers_tests/pure_link_helper_test.exs
index cfb7d19..d53fe67 100644
--- a/test/earmark_helpers_tests/pure_link_helper_test.exs
+++ b/test/earmark_helpers_tests/pure_link_helper_test.exs
@@ -1,5 +1,4 @@
 defmodule EarmarkParser.Helpers.TestPureLinkHelpers do
-
   use ExUnit.Case, async: true
   import EarmarkParser.Helpers.PureLinkHelpers, only: [convert_pure_link: 1]
   import EarmarkAstDsl
@@ -8,7 +7,7 @@ defmodule EarmarkParser.Helpers.TestPureLinkHelpers do
     test "nothing fancy just a plain link" do
       #                           0....+....1....+...
       result = convert_pure_link("https://a.link.com")
-      expected = { a("https://a.link.com", href: "https://a.link.com"), 18}
+      expected = {a("https://a.link.com", href: "https://a.link.com"), 18}
       assert result == expected
     end
 
@@ -29,14 +28,17 @@ defmodule EarmarkParser.Helpers.TestPureLinkHelpers do
     test "however opening parens are" do
       #                           0....+....1....+...
       result = convert_pure_link("https://a.link.com(")
-      expected = {a( "https://a.link.com(", href:  "https://a.link.com("), 19}
+      expected = {a("https://a.link.com(", href: "https://a.link.com("), 19}
       assert result == expected
     end
 
     test "closing parens inside are ok" do
       #                          0....+....1....+....2....+....3....+....4....+
       result = convert_pure_link("http://www.google.com/search?q=(business))+ok")
-      expected = {a( "http://www.google.com/search?q=(business))+ok", href:  "http://www.google.com/search?q=(business))+ok"), 45}
+
+      expected =
+        {a("http://www.google.com/search?q=(business))+ok", href: "http://www.google.com/search?q=(business))+ok"), 45}
+
       assert result == expected
     end
 
@@ -58,19 +60,19 @@ defmodule EarmarkParser.Helpers.TestPureLinkHelpers do
     test "invalid characters should not be part of the link" do
       #                          0....+....1....+....2....+
       result = convert_pure_link("https://a.link.com<br/>")
-      expected = {a( "https://a.link.com", href:  "https://a.link.com"), 18}
+      expected = {a("https://a.link.com", href: "https://a.link.com"), 18}
       assert result == expected
     end
 
     test "trailing parens should be unaffected by unbalanced parens inside" do
       result = convert_pure_link("https://a.link.com/q=foo)+(ok))")
-      expected = {tag("a",  "https://a.link.com/q=foo)+(ok)", href:  "https://a.link.com/q=foo)+(ok)"), 30}
+      expected = {tag("a", "https://a.link.com/q=foo)+(ok)", href: "https://a.link.com/q=foo)+(ok)"), 30}
       assert result == expected
     end
 
     test "recognize www. prefix" do
       result = convert_pure_link("www.github.com")
-      expected = {tag("a",  "www.github.com", href:  "http://www.github.com"), 14}
+      expected = {tag("a", "www.github.com", href: "http://www.github.com"), 14}
       assert result == expected
     end
 
@@ -82,9 +84,10 @@ defmodule EarmarkParser.Helpers.TestPureLinkHelpers do
 
     test "trailing dot must not be part of the link" do
       result = convert_pure_link("www.github.com.")
-      expected = {tag("a",  "www.github.com", href:  "http://www.github.com"), 14}
+      expected = {tag("a", "www.github.com", href: "http://www.github.com"), 14}
       assert result == expected
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/earmark_parser_test.exs b/test/earmark_parser_test.exs
index d8c4588..4d932a5 100644
--- a/test/earmark_parser_test.exs
+++ b/test/earmark_parser_test.exs
@@ -5,7 +5,7 @@ defmodule EarmarkParserTest do
 
   describe "some basic functions" do
     test "version" do
-      assert Regex.match?(~r{\A\d+\.\d+}, to_string(EarmarkParser.version))
+      assert Regex.match?(~r{\A\d+\.\d+}, to_string(EarmarkParser.version()))
     end
   end
 end
diff --git a/test/functional/inline/converter/complex_conversion_test.exs b/test/functional/inline/converter/complex_conversion_test.exs
index 553e4b2..78d943d 100644
--- a/test/functional/inline/converter/complex_conversion_test.exs
+++ b/test/functional/inline/converter/complex_conversion_test.exs
@@ -20,9 +20,7 @@ defmodule Test.Functional.Inline.Converter.ComplexConversionTest do
 
       expected = [
         " again",
-        {"a",
-         [{"href", "#fn:1"}, {"id", "fnref:1"}, {"class", "footnote"}, {"title", "see footnote"}],
-         ["1"], %{}},
+        {"a", [{"href", "#fn:1"}, {"id", "fnref:1"}, {"class", "footnote"}, {"title", "see footnote"}], ["1"], %{}},
         " foo"
       ]
 
@@ -44,8 +42,7 @@ defmodule Test.Functional.Inline.Converter.ComplexConversionTest do
 
       expected = [
         ")",
-        {"a", [{"href", "http://www.google.com/search?q=business"}],
-         ["http://www.google.com/search?q=business"], %{}},
+        {"a", [{"href", "http://www.google.com/search?q=business"}], ["http://www.google.com/search?q=business"], %{}},
         "("
       ]
 
@@ -54,8 +51,7 @@ defmodule Test.Functional.Inline.Converter.ComplexConversionTest do
 
     test " a link" do
       expected = [
-        {"a", [{"href", "http://www.google.com/search?q=business"}],
-         ["http://www.google.com/search?q=business"], %{}}
+        {"a", [{"href", "http://www.google.com/search?q=business"}], ["http://www.google.com/search?q=business"], %{}}
       ]
 
       assert convert(@link) == expected
diff --git a/test/functional/inline/converter/optional_conversion_test.exs b/test/functional/inline/converter/optional_conversion_test.exs
index a9e3c89..407ad41 100644
--- a/test/functional/inline/converter/optional_conversion_test.exs
+++ b/test/functional/inline/converter/optional_conversion_test.exs
@@ -5,13 +5,15 @@ defmodule Test.Functional.Inline.Converter.OptionalConversionTest do
     test "classic br" do
       assert convert("  \n ") == [" ", {"br", [], [], %{}}]
     end
+
     test "no br" do
       assert convert(" \na") == [" \na"]
     end
+
     test "hard breaks" do
       assert convert(" \na", breaks: true) == ["a", {"br", [], [], %{}}]
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/functional/inline/converter/single_conversion_test.exs b/test/functional/inline/converter/single_conversion_test.exs
index c92ac95..6253752 100644
--- a/test/functional/inline/converter/single_conversion_test.exs
+++ b/test/functional/inline/converter/single_conversion_test.exs
@@ -3,8 +3,9 @@ defmodule Test.Functional.Inline.Converter.SingleConversionTest do
 
   describe "autolinks:" do
     test "autolink, http" do
-      assert convert("<http:/mysite>") == [{"a", [{"href", "http:/mysite"}], ["http:/mysite"], %{}}] 
+      assert convert("<http:/mysite>") == [{"a", [{"href", "http:/mysite"}], ["http:/mysite"], %{}}]
     end
+
     test "autolink, mailto" do
       assert convert("<http@mysite>") == [{"a", [{"href", "mailto:http@mysite"}], ["http@mysite"], %{}}]
     end
@@ -12,13 +13,15 @@ defmodule Test.Functional.Inline.Converter.SingleConversionTest do
 
   describe "escape:" do
     test "escape" do
-      assert convert("a\\_b") == ~W[a_b] 
+      assert convert("a\\_b") == ~W[a_b]
     end
+
     test "escape at beginning" do
-      assert convert("\\_b") == ~W[_b] 
+      assert convert("\\_b") == ~W[_b]
     end
+
     test "escape an escape" do
-      assert convert("a\\\\_b") == ~W[a\_b] 
+      assert convert("a\\\\_b") == ~W[a\_b]
     end
   end
 
@@ -26,10 +29,11 @@ defmodule Test.Functional.Inline.Converter.SingleConversionTest do
     test "strikethrough" do
       assert convert("~~alpha~~") == [{"del", [], ["alpha"], %{}}]
     end
+
     test "no strikethrough" do
       assert convert("~~ alpha~~") == ["~~ alpha~~"]
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/functional/scanner/deprecation_test.exs b/test/functional/scanner/deprecation_test.exs
index 7ef6880..2172b30 100644
--- a/test/functional/scanner/deprecation_test.exs
+++ b/test/functional/scanner/deprecation_test.exs
@@ -1,32 +1,39 @@
 defmodule Test.Functional.Scanner.DeprecationTest do
   use ExUnit.Case
 
-  import Support.Helpers, only: [ as_ast: 2]
+  import Support.Helpers, only: [as_ast: 2]
 
   describe "Deprecations to be removed in 1.5.0" do
     test "pedantic" do
       markdown = ""
-      ast      = []
-      messages = [{:deprecated, 0, "The pedantic option has no effect anymore and will be removed in EarmarkParser 1.5"}]
+      ast = []
+
+      messages = [
+        {:deprecated, 0, "The pedantic option has no effect anymore and will be removed in EarmarkParser 1.5"}
+      ]
 
       assert as_ast(markdown, pedantic: true) == {:ok, ast, messages}
     end
 
     test "smartypants" do
       markdown = ""
-      ast      = []
-      messages = [{:deprecated, 0, "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}]
+      ast = []
+
+      messages = [
+        {:deprecated, 0, "The smartypants option has no effect anymore and will be removed in EarmarkParser 1.5"}
+      ]
 
       assert as_ast(markdown, smartypants: true) == {:ok, ast, messages}
     end
 
     test "timeout" do
       markdown = ""
-      ast      = []
+      ast = []
       messages = [{:deprecated, 0, "The timeout option has no effect anymore and will be removed in EarmarkParser 1.5"}]
 
       assert as_ast(markdown, timeout: 42) == {:ok, ast, messages}
     end
   end
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/functional/scanner/line_type_test.exs b/test/functional/scanner/line_type_test.exs
index 79f5c73..6602ef8 100644
--- a/test/functional/scanner/line_type_test.exs
+++ b/test/functional/scanner/line_type_test.exs
@@ -7,7 +7,6 @@ defmodule Functional.Scanner.LineTypeTest do
 
   @all_but_leading_ws ~r{\S.*}
 
-
   id1 = ~S{[ID1]: http://example.com  "The title"}
   id2 = ~S{[ID2]: http://example.com  'The title'}
   id3 = ~S{[ID3]: http://example.com  (The title)}
@@ -22,7 +21,7 @@ defmodule Functional.Scanner.LineTypeTest do
   id11 = ~S{[ID11]: http://example.com "Title with trailing whitespace" }
   id12 = ~S{[ID12]: ]hello}
 
- # Leave Blanks at the beginning, they will be dropped for IAL tests
+  # Leave Blanks at the beginning, they will be dropped for IAL tests
   test_cases =
     [
       {"", %Line.Blank{}, nil},
@@ -169,8 +168,10 @@ defmodule Functional.Scanner.LineTypeTest do
       {"<wbr class='a'>", %Line.HtmlOneLine{tag: "wbr", content: "<wbr class='a'>"}, "annotated"},
       {"<h2>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2>Headline</h2>"}, nil},
       {"<h2>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2>Headline</h2>"}, "annotated"},
-      {"<h2 id='headline'>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2 id='headline'>Headline</h2>"}, nil},
-      {"<h2 id='headline'>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2 id='headline'>Headline</h2>"}, "annotated"},
+      {"<h2 id='headline'>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2 id='headline'>Headline</h2>"},
+       nil},
+      {"<h2 id='headline'>Headline</h2>", %Line.HtmlOneLine{tag: "h2", content: "<h2 id='headline'>Headline</h2>"},
+       "annotated"},
       {"<h3>Headline", %Line.HtmlOpenTag{tag: "h3", content: "<h3>Headline"}, nil},
       {"<h3>Headline", %Line.HtmlOpenTag{tag: "h3", content: "<h3>Headline"}, "annotated"},
       {id1, %Line.IdDef{id: "ID1", url: "http://example.com", title: "The title"}, nil},
@@ -189,8 +190,18 @@ defmodule Functional.Scanner.LineTypeTest do
       {id7, %Line.IdDef{id: "ID7", url: "http://example.com", title: "The title"}, "annotated"},
       {id8, %Line.IdDef{id: "ID8", url: "http://example.com", title: "The title"}, nil},
       {id8, %Line.IdDef{id: "ID8", url: "http://example.com", title: "The title"}, "annotated"},
-      {id9, %Line.Indent{ content: "[ID9]: http://example.com  \"The title\"", level: 1, line: "    [ID9]: http://example.com  \"The title\"" }, nil},
-      {id9, %Line.Indent{ content: "[ID9]: http://example.com  \"The title\"", level: 1, line: "    [ID9]: http://example.com  \"The title\"" }, "annotated"},
+      {id9,
+       %Line.Indent{
+         content: "[ID9]: http://example.com  \"The title\"",
+         level: 1,
+         line: "    [ID9]: http://example.com  \"The title\""
+       }, nil},
+      {id9,
+       %Line.Indent{
+         content: "[ID9]: http://example.com  \"The title\"",
+         level: 1,
+         line: "    [ID9]: http://example.com  \"The title\""
+       }, "annotated"},
       {id10, %Line.IdDef{id: "ID10", url: "/url/", title: "Title with \"quotes\" inside"}, nil},
       {id11, %Line.IdDef{id: "ID11", url: "http://example.com", title: "Title with trailing whitespace"}, nil},
       {id11, %Line.IdDef{id: "ID11", url: "http://example.com", title: "Title with trailing whitespace"}, "annotated"},
@@ -209,9 +220,11 @@ defmodule Functional.Scanner.LineTypeTest do
       {"1. ol1", %Line.ListItem{type: :ol, bullet: "1.", content: "ol1", list_indent: 3}, nil},
       {"1. ol1", %Line.ListItem{type: :ol, bullet: "1.", content: "ol1", list_indent: 3}, "annotated"},
       {"12345.      ol2", %Line.ListItem{type: :ol, bullet: "12345.", content: "     ol2", list_indent: 7}, nil},
-      {"12345.      ol2", %Line.ListItem{type: :ol, bullet: "12345.", content: "     ol2", list_indent: 7}, "annotated"},
+      {"12345.      ol2", %Line.ListItem{type: :ol, bullet: "12345.", content: "     ol2", list_indent: 7},
+       "annotated"},
       {"12345)      ol3", %Line.ListItem{type: :ol, bullet: "12345)", content: "     ol3", list_indent: 7}, nil},
-      {"12345)      ol3", %Line.ListItem{type: :ol, bullet: "12345)", content: "     ol3", list_indent: 7}, "annotated"},
+      {"12345)      ol3", %Line.ListItem{type: :ol, bullet: "12345)", content: "     ol3", list_indent: 7},
+       "annotated"},
       {"1234567890. ol4", %Line.Text{content: "1234567890. ol4"}, nil},
       {"1234567890. ol4", %Line.Text{content: "1234567890. ol4"}, "annotated"},
       {"1.ol5", %Line.Text{content: "1.ol5"}, nil},
@@ -253,20 +266,27 @@ defmodule Functional.Scanner.LineTypeTest do
          content: "[^1]: bar baz",
          line: "[^1]: bar baz",
          lnb: 42
-       }, "annotated"},
+       }, "annotated"}
     ]
-    |> Enum.with_index
+    |> Enum.with_index()
 
   @annotation "%%"
   describe "scan with annotations" do
     test_cases
     |> Enum.map(fn {{input, token, annotation}, test_nb} ->
       tag = "ann_#{test_nb}" |> String.to_atom()
-      annotation_ = if annotation, do: Enum.join([@annotation, annotation])
+
+      annotation_ =
+        if annotation do
+          Enum.join([@annotation, annotation])
+        end
+
       input_ = "#{input}#{annotation_}"
       name = "test: #{test_nb} (#{input_})"
+
       result =
         EarmarkParser.LineScanner.type_of({input_, 1729}, normalize(annotations: @annotation), false)
+
       indent = input |> String.replace(@all_but_leading_ws, "") |> String.length()
       expected = struct(token, annotation: annotation_, line: input, indent: indent, lnb: 1729)
 
@@ -283,8 +303,10 @@ defmodule Functional.Scanner.LineTypeTest do
     |> Enum.map(fn {{input, token, _nil}, test_nb} ->
       tag = "noann_#{test_nb}" |> String.to_atom()
       name = "test: #{test_nb} (#{input})"
+
       result =
         EarmarkParser.LineScanner.type_of({input, 1731}, false)
+
       indent = input |> String.replace(@all_but_leading_ws, "") |> String.length()
       expected = struct(token, line: input, indent: indent, lnb: 1731)
 
@@ -296,30 +318,32 @@ defmodule Functional.Scanner.LineTypeTest do
   end
 
   ial_test_cases = [
-      {"# H1", %Line.Heading{level: 1, content: "H1"}, nil},
-      {"# H1", %Line.Heading{level: 1, content: "H1"}, "H1"},
-      {"## H2", %Line.Heading{level: 2, content: "H2"}, nil},
-      {"## H2", %Line.Heading{level: 2, content: "H2"}, "H2"},
-      {"### H3", %Line.Heading{level: 3, content: "H3"}, nil},
-      {"### H3", %Line.Heading{level: 3, content: "H3"}, "H3"},
-      {"#### H4", %Line.Heading{level: 4, content: "H4"}, nil},
-      {"#### H4", %Line.Heading{level: 4, content: "H4"}, "H4"},
-      {"##### H5", %Line.Heading{level: 5, content: "H5"}, nil},
-      {"##### H5", %Line.Heading{level: 5, content: "H5"}, "H5"},
-      {"###### H6", %Line.Heading{level: 6, content: "H6"}, nil},
-      {"###### H6", %Line.Heading{level: 6, content: "H6"}, "H6"},
-    ]
+    {"# H1", %Line.Heading{level: 1, content: "H1"}, nil},
+    {"# H1", %Line.Heading{level: 1, content: "H1"}, "H1"},
+    {"## H2", %Line.Heading{level: 2, content: "H2"}, nil},
+    {"## H2", %Line.Heading{level: 2, content: "H2"}, "H2"},
+    {"### H3", %Line.Heading{level: 3, content: "H3"}, nil},
+    {"### H3", %Line.Heading{level: 3, content: "H3"}, "H3"},
+    {"#### H4", %Line.Heading{level: 4, content: "H4"}, nil},
+    {"#### H4", %Line.Heading{level: 4, content: "H4"}, "H4"},
+    {"##### H5", %Line.Heading{level: 5, content: "H5"}, nil},
+    {"##### H5", %Line.Heading{level: 5, content: "H5"}, "H5"},
+    {"###### H6", %Line.Heading{level: 6, content: "H6"}, nil},
+    {"###### H6", %Line.Heading{level: 6, content: "H6"}, "H6"}
+  ]
 
   @ial "{:.ial_class}"
   describe "scan with IAL" do
     ial_test_cases
-    |> Enum.with_index
+    |> Enum.with_index()
     |> Enum.map(fn {{input, token, _nil}, test_nb} ->
       tag = "ial_#{test_nb}" |> String.to_atom()
       name = "test: #{test_nb} (#{input})"
       input = "#{input}#{@ial}"
+
       result =
         EarmarkParser.LineScanner.type_of({input, 1774}, false)
+
       indent = input |> String.replace(@all_but_leading_ws, "") |> String.length()
       expected = struct(token, ial: ".ial_class", line: input, indent: indent, lnb: 1774)
 
@@ -331,23 +355,28 @@ defmodule Functional.Scanner.LineTypeTest do
   end
 
   block_ial_test_cases = [
-      {"> quote", %Line.BlockQuote{content: "quote"}},
-      {">    quote", %Line.BlockQuote{content: "   quote"}},
-      {">quote", %Line.BlockQuote{content: "quote"}},
-      {" >  quote", %Line.BlockQuote{content: " quote"}},
-      {" >", %Line.BlockQuote{content: ""}},
-      ]
+    {"> quote", %Line.BlockQuote{content: "quote"}},
+    {">    quote", %Line.BlockQuote{content: "   quote"}},
+    {">quote", %Line.BlockQuote{content: "quote"}},
+    {" >  quote", %Line.BlockQuote{content: " quote"}},
+    {" >", %Line.BlockQuote{content: ""}}
+  ]
+
   describe "IAL needs to be passed through content" do
     block_ial_test_cases
-    |> Enum.with_index
+    |> Enum.with_index()
     |> Enum.map(fn {{input, token}, test_nb} ->
       tag = "block_ial_#{test_nb}" |> String.to_atom()
       name = "test: #{test_nb} (#{input})"
       input = "#{input}#{@ial}"
+
       result =
         EarmarkParser.LineScanner.type_of({input, 1774}, false)
+
       indent = input |> String.replace(@all_but_leading_ws, "") |> String.length()
-      expected = struct(token, content: token.content <> @ial, ial: ".ial_class", line: input, indent: indent, lnb: 1774)
+
+      expected =
+        struct(token, content: token.content <> @ial, ial: ".ial_class", line: input, indent: indent, lnb: 1774)
 
       @tag tag
       test name do
@@ -357,31 +386,34 @@ defmodule Functional.Scanner.LineTypeTest do
   end
 
   not_ial_test_cases =
-  [
-    {"--", %Line.Text{annotation: nil, indent: 0, line: "--{:.not-ial}", lnb: 1905, content: "--{:.not-ial}"}},
-    {"* * *", %Line.ListItem{
-              annotation: nil,
-              ial: nil,
-              indent: 0,
-              line: "* * *{:.not-ial}",
-              lnb: 1905,
-              type: :ul,
-              bullet: "*",
-              content: "* *{:.not-ial}",
-              initial_indent: 0,
-              list_indent: 2
-            }},
-  ]
+    [
+      {"--", %Line.Text{annotation: nil, indent: 0, line: "--{:.not-ial}", lnb: 1905, content: "--{:.not-ial}"}},
+      {"* * *",
+       %Line.ListItem{
+         annotation: nil,
+         ial: nil,
+         indent: 0,
+         line: "* * *{:.not-ial}",
+         lnb: 1905,
+         type: :ul,
+         bullet: "*",
+         content: "* *{:.not-ial}",
+         initial_indent: 0,
+         list_indent: 2
+       }}
+    ]
 
   describe "not IAL" do
     not_ial_test_cases
-    |> Enum.with_index
+    |> Enum.with_index()
     |> Enum.map(fn {{input, token}, test_nb} ->
       tag = "not_ial_#{test_nb + 1}" |> String.to_atom()
       name = "test: #{test_nb + 1} (#{input})"
       input_ = "#{input}{:.not-ial}"
+
       result =
         EarmarkParser.LineScanner.type_of({input_, 1905}, false)
+
       indent = input |> String.replace(@all_but_leading_ws, "") |> String.length()
       expected = struct(token, line: input_, indent: indent, lnb: 1905)
 
diff --git a/test/support/acceptance_test_case.ex b/test/support/acceptance_test_case.ex
index 55fe157..c20528e 100644
--- a/test/support/acceptance_test_case.ex
+++ b/test/support/acceptance_test_case.ex
@@ -1,5 +1,4 @@
 defmodule Support.AcceptanceTestCase do
-
   defmacro __using__(_options) do
     quote do
       use ExUnit.Case, async: true
@@ -11,6 +10,6 @@ defmodule Support.AcceptanceTestCase do
       import Support.AstHelpers, only: [assert_asts_are_equal: 2, ast_from_md: 1, ast_from_md: 2]
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/support/ast_helpers.ex b/test/support/ast_helpers.ex
index 49dc5e8..431dc78 100644
--- a/test/support/ast_helpers.ex
+++ b/test/support/ast_helpers.ex
@@ -1,24 +1,31 @@
 defmodule Support.AstHelpers do
-
-   def assert_asts_are_equal(result, expected) do
-     quote do
+  def assert_asts_are_equal(result, expected) do
+    quote do
       assert _delta_between(unquote(Macro.escape(result)), unquote(Macro.escape(expected))) == []
-     end
-   end
+    end
+  end
 
-   def ast_from_md(md, opts \\ []) do
-    with {:ok, ast, []} <- EarmarkParser.as_ast(md, opts), do: ast
+  def ast_from_md(md, opts \\ []) do
+    with {:ok, ast, []} <- EarmarkParser.as_ast(md, opts) do
+      ast
+    end
   end
 
   def ast_with_errors(md) do
-    with {:error, ast, messages} <- EarmarkParser.as_ast(md), do: {ast, messages}
+    with {:error, ast, messages} <- EarmarkParser.as_ast(md) do
+      {ast, messages}
+    end
   end
 
   def p(content, atts \\ [])
-  def p(content, atts) when is_binary(content) or is_tuple(content),
-    do: {"p", atts, [content]}
-  def p(content, atts),
-    do: {"p", atts, content}
+
+  def p(content, atts) when is_binary(content) or is_tuple(content) do
+    {"p", atts, [content]}
+  end
+
+  def p(content, atts) do
+    {"p", atts, content}
+  end
 
   def tag(name, content \\ nil, atts \\ []) do
     {to_string(name), _atts(atts), _content(content)}
@@ -28,15 +35,23 @@ defmodule Support.AstHelpers do
     {to_string(tag), atts, []}
   end
 
-
   defp _atts(atts) do
-    atts |> Enum.into(Keyword.new) |> Enum.map(fn {x, y} -> {to_string(x), to_string(y)} end)
+    atts |> Enum.into(Keyword.new()) |> Enum.map(fn {x, y} -> {to_string(x), to_string(y)} end)
   end
 
   defp _content(c)
-  defp _content(nil), do: []
-  defp _content(s) when is_binary(s), do: [s]
-  defp _content(c), do: c
 
+  defp _content(nil) do
+    []
+  end
+
+  defp _content(s) when is_binary(s) do
+    [s]
+  end
+
+  defp _content(c) do
+    c
+  end
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/support/error_plugin.ex b/test/support/error_plugin.ex
index 8c526bd..a49b76c 100644
--- a/test/support/error_plugin.ex
+++ b/test/support/error_plugin.ex
@@ -1,16 +1,24 @@
 defmodule Support.ErrorPlugin do
-
   def as_html(lines) do
     if Enum.all?(lines, &correct?/1) do
       "<strong>correct</strong>\n"
     else
-      { for line <- lines, correct?(line) do "<strong>correct</strong>" end,
-        for line <- lines, !correct?(line) do make_error(line) end }
+      {for line <- lines, correct?(line) do
+         "<strong>correct</strong>"
+       end,
+       for line <- lines, !correct?(line) do
+         make_error(line)
+       end}
     end
   end
 
-  defp correct?({line, _}), do: line == "correct"
-  defp make_error({_, lnb}), do: {:error, lnb, "that is incorrect"}
+  defp correct?({line, _}) do
+    line == "correct"
+  end
+
+  defp make_error({_, lnb}) do
+    {:error, lnb, "that is incorrect"}
+  end
 end
 
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/support/helpers.ex b/test/support/helpers.ex
index 8cdb5d5..e65ce5d 100644
--- a/test/support/helpers.ex
+++ b/test/support/helpers.ex
@@ -1,5 +1,4 @@
 defmodule Support.Helpers do
-
   alias EarmarkParser.Block.IdDef
   alias EarmarkParser.Context
 
@@ -11,7 +10,9 @@ defmodule Support.Helpers do
     %EarmarkParser.Context{}
   end
 
-  def annotated(meta, annotation), do: Map.put(meta, :annotation, annotation)
+  def annotated(meta, annotation) do
+    Map.put(meta, :annotation, annotation)
+  end
 
   def as_ast(markdown, options \\ []) do
     EarmarkParser.as_ast(markdown, options)
@@ -19,7 +20,7 @@ defmodule Support.Helpers do
 
   def parse_html(html, metadata_fun \\ &default_metadata_fun/1) do
     if System.get_env("DEBUG") do
-      _parse_html(html) |> _add_4th(metadata_fun) |> IO.inspect
+      _parse_html(html) |> _add_4th(metadata_fun) |> IO.inspect()
     else
       _parse_html(html) |> _add_4th(metadata_fun)
     end
@@ -45,13 +46,12 @@ defmodule Support.Helpers do
 
   def test_links do
     [
-     {"id1", %IdDef{url: "url 1", title: "title 1"}},
-     {"id2", %IdDef{url: "url 2"}},
-
-     {"img1", %IdDef{url: "img 1", title: "image 1"}},
-     {"img2", %IdDef{url: "img 2"}},
+      {"id1", %IdDef{url: "url 1", title: "title 1"}},
+      {"id2", %IdDef{url: "url 2"}},
+      {"img1", %IdDef{url: "img 1", title: "image 1"}},
+      {"img2", %IdDef{url: "img 2"}}
     ]
-    |> Enum.into(Map.new)
+    |> Enum.into(Map.new())
   end
 
   def pedantic_context do
@@ -66,21 +66,29 @@ defmodule Support.Helpers do
   end
 
   defp _add_4th(node, metadata_fun)
+
   defp _add_4th(nodes, metadata_fun) when is_list(nodes) do
     nodes
     |> Enum.map(&_add_4th(&1, metadata_fun))
   end
+
   defp _add_4th({t, a, c}, metadata_fun) do
     c = _add_4th(c, metadata_fun)
     {t, a, c, metadata_fun.({t, a, c})}
   end
+
   defp _add_4th({:comment, content}, _) do
     {:comment, [], content, %{comment: true}}
   end
-  defp _add_4th(other, _), do: other
+
+  defp _add_4th(other, _) do
+    other
+  end
 
   defp _parse_html(html) do
-    with {_, ast} = Floki.parse_fragment(html), do: ast
+    with {_, ast} = Floki.parse_fragment(html) do
+      ast
+    end
   end
 end
 
diff --git a/test/support/inline_converter_case.ex b/test/support/inline_converter_case.ex
index d8259bd..8d86f73 100644
--- a/test/support/inline_converter_case.ex
+++ b/test/support/inline_converter_case.ex
@@ -1,5 +1,4 @@
 defmodule Support.InlineConverterCase do
-
   defmacro __using__(_opts) do
     quote do
       use ExUnit.Case
@@ -7,16 +6,19 @@ defmodule Support.InlineConverterCase do
 
       def convert(src, options \\ [], lnb \\ 74) do
         options = EarmarkParser.Options.normalize(options)
-        context = %EarmarkParser.Context{options: options} |> EarmarkParser.Context.update_context 
+        context = %EarmarkParser.Context{options: options} |> EarmarkParser.Context.update_context()
 
         EarmarkParser.Ast.Inline.convert(src, lnb, context).value
       end
 
       def convert_with_footnotes(src, fnids)
+
       def convert_with_footnotes(src, fnids) when is_list(fnids) do
         footnotes = fnids |> Enum.zip(Stream.cycle([true])) |> Enum.into(%{})
         options = EarmarkParser.Options.normalize(footnotes: true)
-        context = %EarmarkParser.Context{options: options, footnotes: footnotes} |> EarmarkParser.Context.update_context 
+
+        context =
+          %EarmarkParser.Context{options: options, footnotes: footnotes} |> EarmarkParser.Context.update_context()
 
         EarmarkParser.Ast.Inline.convert(src, 1, context).value
       end
@@ -26,14 +28,14 @@ defmodule Support.InlineConverterCase do
       end
 
       def convert_with_reflink(src, link_id, url, title, options \\ []) do
-        links   = %{link_id => %{url: url, title: title}}
+        links = %{link_id => %{url: url, title: title}}
         options = EarmarkParser.Options.normalize(options)
-        context = %EarmarkParser.Context{options: options, links: links} |> EarmarkParser.Context.update_context 
+        context = %EarmarkParser.Context{options: options, links: links} |> EarmarkParser.Context.update_context()
 
         EarmarkParser.Ast.Inline.convert(src, 1, context).value
       end
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/support/parser.ex b/test/support/parser.ex
index 53b8c11..0a560f1 100644
--- a/test/support/parser.ex
+++ b/test/support/parser.ex
@@ -1,5 +1,5 @@
 defmodule Support.Parser do
-  def parse_lines lines do
+  def parse_lines(lines) do
     EarmarkParser.Parser.parse(%EarmarkParser.Options{}, lines, false)
   end
 end
diff --git a/test/support/table_helpers.ex b/test/support/table_helpers.ex
index 30460c2..0513408 100644
--- a/test/support/table_helpers.ex
+++ b/test/support/table_helpers.ex
@@ -13,13 +13,13 @@ defmodule Support.TableHelpers do
     tag("thead", tag("tr", cells))
   end
 
-  def td(content, align \\ "left" ) do
+  def td(content, align \\ "left") do
     tag("td", [content], style: "text-align: #{align};")
   end
 
-  def th(content, align \\ "left" ) do
+  def th(content, align \\ "left") do
     tag("th", [content], style: "text-align: #{align};")
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0
diff --git a/test/support/wip_helpers.ex b/test/support/wip_helpers.ex
index 65fe0d9..467f755 100644
--- a/test/support/wip_helpers.ex
+++ b/test/support/wip_helpers.ex
@@ -1,6 +1,5 @@
 defmodule Support.WipHelpers do
-  
-  defmacro assert_size list, size do
+  defmacro assert_size(list, size) do
     quote do
       assert Enum.count(unquote(list)) == unquote(size)
     end
diff --git a/test/unit/ast_walker_test.exs b/test/unit/ast_walker_test.exs
index 8d35ca7..7fd77b2 100644
--- a/test/unit/ast_walker_test.exs
+++ b/test/unit/ast_walker_test.exs
@@ -7,6 +7,7 @@ defmodule Test.Unit.AstWalkerTest do
     test "empty" do
       assert walk([], & &1) == []
     end
+
     test "one element" do
       str = "do not use a palindrome here"
       assert walk([str], &String.reverse/1) == [String.reverse(str)]
@@ -17,6 +18,7 @@ defmodule Test.Unit.AstWalkerTest do
     test "empty" do
       assert walk(%{}, & &1) == %{}
     end
+
     test "one element" do
       str = "do not use a palindrome here"
       assert walk(%{str: str}, &String.reverse/1, true) == %{str: String.reverse(str)}
@@ -27,10 +29,10 @@ defmodule Test.Unit.AstWalkerTest do
     test "empty" do
       assert walk({}, & &1) == {}
     end
+
     test "one element" do
       str = "do not use a palindrome here"
       assert walk({str}, &String.reverse/1, true) == {String.reverse(str)}
     end
-    
   end
 end
diff --git a/test/unit/convert_test.exs b/test/unit/convert_test.exs
index 130ef27..f07bd34 100644
--- a/test/unit/convert_test.exs
+++ b/test/unit/convert_test.exs
@@ -13,7 +13,9 @@ defmodule Test.Unit.ConvertTest do
       markdown = "[**strong**][lnk1]"
       ctxt = "lnk1" |> with_link()
 
-      assert convert(markdown, ctxt) == [{"a", [{"href", "lnk1_url"}, {"title", "title"}], [{"strong", [], ["strong"], %{}}], %{}}]
+      assert convert(markdown, ctxt) == [
+               {"a", [{"href", "lnk1_url"}, {"title", "title"}], [{"strong", [], ["strong"], %{}}], %{}}
+             ]
     end
 
     test "just an image" do
@@ -22,19 +24,28 @@ defmodule Test.Unit.ConvertTest do
 
       assert convert(markdown, ctxt) == [{"img", [{"src", "lnk1_url"}, {"alt", "Img1"}, {"title", "title"}], [], %{}}]
     end
+
     test "image inside" do
       markdown = "[![Img1][img1]][lnk1]"
-      expected = [{"a", [{"href", "lnk1_url"}, {"title", "title"}], 
-        [{"img", [{"src", "lnk1_url"}, {"alt", "Img1"}, {"title", "title"}], [], %{}}],
-        %{}}]
+
+      expected = [
+        {"a", [{"href", "lnk1_url"}, {"title", "title"}],
+         [{"img", [{"src", "lnk1_url"}, {"alt", "Img1"}, {"title", "title"}], [], %{}}], %{}}
+      ]
 
       ctxt = "lnk1" |> with_link() |> with_link("img1")
       assert convert(markdown, ctxt) == expected
     end
   end
-  defp convert(content, context \\ %Context{}), do: Inline.convert(content, 42, context).value
 
-  defp with_link(id), do: with_link(Context.update_context(%Context{}), id)
+  defp convert(content, context \\ %Context{}) do
+    Inline.convert(content, 42, context).value
+  end
+
+  defp with_link(id) do
+    with_link(Context.update_context(%Context{}), id)
+  end
+
   defp with_link(ctxt, id) do
     id_def = %IdDef{
       annotation: nil,
@@ -42,8 +53,9 @@ defmodule Test.Unit.ConvertTest do
       id: id,
       lnb: 3,
       title: "title",
-      url: "lnk1_url",
+      url: "lnk1_url"
     }
-    %{ ctxt | links: Map.put(ctxt.links, id, id_def) }
+
+    %{ctxt | links: Map.put(ctxt.links, id, id_def)}
   end
 end
diff --git a/test/unit/enum/ext_test.exs b/test/unit/enum/ext_test.exs
index 8ebb052..aa6e5ab 100644
--- a/test/unit/enum/ext_test.exs
+++ b/test/unit/enum/ext_test.exs
@@ -2,4 +2,5 @@ defmodule Test.Unit.Enum.ExtTest do
   use ExUnit.Case
   doctest EarmarkParser.Enum.Ext, import: true
 end
+
 #  SPDX-License-Identifier: Apache-2.0
diff --git a/test/unit/helpers_test.exs b/test/unit/helpers_test.exs
index 40bad43..9421a93 100644
--- a/test/unit/helpers_test.exs
+++ b/test/unit/helpers_test.exs
@@ -8,6 +8,7 @@ defmodule HelpersTest do
     test "expand_tab spaces only(1)" do
       assert expand_tabs(" ") == " "
     end
+
     test "expand_tab spaces only" do
       assert expand_tabs("   ") == "   "
     end
@@ -19,9 +20,11 @@ defmodule HelpersTest do
     test "expand_tab mixed, 1 space" do
       assert expand_tabs(" \t ") == "     "
     end
+
     test "expand_tab mixed, 2 spaces" do
       assert expand_tabs("  \t ") == "     "
     end
+
     test "expand_tab mixed, 3 spaces" do
       assert expand_tabs("   \t ") == "     "
     end
@@ -39,6 +42,6 @@ defmodule HelpersTest do
       assert extract_ial("#{input}{:#{ial}}") == {ial, input}
     end
   end
-
 end
+
 # SPDX-License-Identifier: Apache-2.0

From 7eb0dcca8385589c958fe56fd354cc4a60752a9f Mon Sep 17 00:00:00 2001
From: RobertDober <robert.dober@gmail.com>
Date: Wed, 12 Mar 2025 14:50:49 +0100
Subject: [PATCH 7/7] Fixes #164

    Older Elixir versions added back to GHA workflow
    Doc updated for CONTRIBUTIONS
---
 .github/workflows/elixir.yml | 46 ++++++++++++++++++------------------
 README.md.eex                |  7 ++++++
 2 files changed, 30 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/elixir.yml b/.github/workflows/elixir.yml
index a6086c4..e89ef4b 100644
--- a/.github/workflows/elixir.yml
+++ b/.github/workflows/elixir.yml
@@ -15,29 +15,29 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # - elixir: 1.14.x
-          #   otp: 25
-          #   os: ubuntu-latest
-          # - elixir: 1.15.x
-          #   otp: 25
-          #   os: ubuntu-latest
-          #   warnings_as_errors: true
-          # - elixir: 1.16.x
-          #   otp: 26
-          #   os: ubuntu-latest
-          #   warnings_as_errors: true
-          # - elixir: 1.17.x
-          #   otp: 27
-          #   os: ubuntu-latest
-          #   warnings_as_errors: true
-          # - elixir: 1.18.0-otp-25
-          #   otp: 25
-          #   os: ubuntu-latest
-          #   warnings_as_errors: true
-          # - elixir: 1.18.0-otp-27
-          #   otp: 27
-          #   os: ubuntu-latest
-          #   warnings_as_errors: true
+          - elixir: 1.14.x
+            otp: 25
+            os: ubuntu-latest
+          - elixir: 1.15.x
+            otp: 25
+            os: ubuntu-latest
+            warnings_as_errors: true
+          - elixir: 1.16.x
+            otp: 26
+            os: ubuntu-latest
+            warnings_as_errors: true
+          - elixir: 1.17.x
+            otp: 27
+            os: ubuntu-latest
+            warnings_as_errors: true
+          - elixir: 1.18.0-otp-25
+            otp: 25
+            os: ubuntu-latest
+            warnings_as_errors: true
+          - elixir: 1.18.0-otp-27
+            otp: 27
+            os: ubuntu-latest
+            warnings_as_errors: true
           - elixir: 1.18.3-otp-27
             otp: 27
             os: ubuntu-latest
diff --git a/README.md.eex b/README.md.eex
index 6b39c46..a2e5b2d 100644
--- a/README.md.eex
+++ b/README.md.eex
@@ -21,6 +21,13 @@
 
 Pull Requests are happily accepted.
 
+### mix format
+
+Now we have decided to enforce formatting, when providing PRs please be sure that that `mix format --check-formatted` passes
+because it will be tested in the GHA workflow
+
+### Editing README
+
 Please be aware of one _caveat_ when correcting/improving `README.md`.
 
 The `README.md` is generated by the coammand mix task `xtra` from `README.md.eex` and