anchor.diff:                              [parse_node(noreturn,Params,M)]
                           )
                       ]),
  -                    lists:append(DefL2, recurse_var_assignments(
  +                    lists:append(AssignL, recurse_var_assignments(
                           M,
                           estree:identifier(atom_to_binary(ParamName, utf8))
                       ))};
   
                   {V={c_var, _, ParamName}, {c_alias, _, {c_var, _, NewName}, M}}->
  -                    {lists:append(DefL1,
  +                    {lists:append(DefineL,
                           recurse_var_declaration(M)
                       ),
                       lists:append(MatchL,[
  
positive.code:         [] -> ElseClausesActual = null;
          _  -> ElseClausesActual = ElseClauses
      end,
      % Assemble the if statement
       estree:if_statement(
          % The function that serves as pattern patching and guards
          assemble_case_condition(Params, Vars, Match, Evaluate),
          estree:block_statement(
              assemble_sequence(
                  % Assign the variables that are used in the match
                  % At this point in development it should be un-nessisary to filter for un-parsed
                  % variables, but I'll leave it here until I next review the case clauses.
                  lists:filter(fun(Elem) ->
                          case Elem of
                              ok -> false;
                              _  -> true
                          end
                      end,
                      assign_matched_vars(Params, Vars, Match)
                  ),
                  encapsulate_expressions(
                      list_check(
                          parse_node(ReturnAtom, Params, Consequent)
  
negative.code:                             [parse_node(noreturn,Params,M)]
                          )
                      ]),
                      lists:append(AssignL, lists:append(
                          recurse_var_assignments(
                              M,
                              estree:identifier(atom_to_binary(ParamName, utf8))
  