Sylvester's sequence Sylvester's sequence, OEIS A000058, is an integer sequence defined as follows:
Each member is the product of all previous members plus one.  The first member of the sequence is 2.
Task
Create the smallest program possible that takes an n and calculates the nth term of Sylvester's Sequence.  Standard input, output and loopholes apply.
Since the result grows very quickly you are not expected to take any term of which the result would cause an overflow in your chosen language.
Test Cases
You may use either zero or one indexing. (Here I use zero indexing)
&gt;&gt;0
2
&gt;&gt;1
3
&gt;&gt;2
7
&gt;&gt;3
43
&gt;&gt;4
1807
Brain-Flak, 76 68 58 52 46 bytes

&lt;&gt;(()())&lt;&gt;{({}[()])&lt;&gt;({({}[()])({})}{}())&lt;&gt;}&lt;&gt;


Try it online!

Uses this relationship instead:



which is derived from this relationship modified from that provided in the sequence:

a(n+1) = a(n) * (a(n) - 1) + 1.

Explanation

For a documentation of what each command does, please visit the GitHub page.

There are two stacks in Brain-Flak, which I shall name as Stack 1 and Stack 2 respectively.

The input is stored in Stack 1.

&lt;&gt;(()())&lt;&gt;             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 &lt;- Stack_1 - 1;
  &lt;&gt;                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  &lt;&gt;                       Switch back to Stack 1.
}

&lt;&gt;                     Switch to Stack 2, implicitly print.


For the generation algorithm:

({({}[()])({})}{}())      Top &lt;- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).


Alternative 46-byte version

This uses only one stack.

({}&lt;(()())&gt;){({}&lt;({({}[()])({})}{}())&gt;[()])}{}


Try it online!