Find the First Bracket Match This was one of a series of challenges leading up to Brain-Flak's birthday. Find out more here.

Challenge
For this challenge your objective will be to find the very first pair of matching brackets in a fully matched string of ()[]{}&lt;&gt; brackets. To borrow DJMcMayhem's definition of a fully matched string:

For the purpose of this challenge, a &quot;bracket&quot; is any of these characters: ()[]{}&lt;&gt;.

A pair of brackets is considered &quot;matched&quot; if the opening and closing brackets are in the right order and have no characters inside of them, such as
()
[]{}

Or if every subelement inside of it is also matched.
[()()()()]
{&lt;[]&gt;}
(()())

Subelements can also be nested several layers deep.
[(){&lt;&gt;&lt;&gt;[()]}&lt;&gt;()]
&lt;[{((()))}]&gt;


A string is considered &quot;Fully matched&quot; if and only if each pair of brackets has the correct opening and closing bracket in the right order.


Input
Input will consist of a single nonempty string or char array containing only the characters ()[]{}&lt;&gt;, and is guaranteed to be fully matched. You may take input in any reasonable manner that corresponds with our i/o defaults.
Output
The output of your program or function will be the index of the bracket which closes the first one. Output must be either 0 or 1 indexed. Again, output may be in any reasonable manner that corresponds with our i/o defaults.
Test Cases
Input       0-indexed   1-indexed
()          1           2
(&lt;&gt;)        3           4
&lt;[]{&lt;&gt;}&gt;    7           8
{}{}{}{}    1           2
[[]&lt;&gt;[]]    7           8

This is code-golf, fewest bytes wins!
Brain-Flak, 685, 155, 151, 137 bytes

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


Try it online!

136 bytes of code, plus one byte for -a. One indexed.

530 bytes golfed off! That's probably the largest golf I've ever done.

14 bytes saved thanks to Riley!

This abuses a formula of the opening/closing parenthesis: if you take the ASCII values, increment it by one, and take modulo of 4, the openers (({[&lt;) will always get 0 or 1, whereas the closers ()}]&gt;) will always get 2 or 3.

Explanation:

#Push 1
(())

#While true
({&lt;

    #Pop stack height
    {}

    #Compute (TOS + 1) % 4
    ({}()&lt;(()()()())&gt;)({}(&lt;&gt;))&lt;&gt;{(({})){({}[()])&lt;&gt;}{}}{}&lt;&gt;([{}()]{})

    #Decrement if positive
    (({})){{}({}[()])(&lt;()&gt;)}{}

    #Push 0 onto alternate
    (&lt;&gt;)

    #Toggle back
    &lt;&gt;

    #Pop two zeros from alternate if closer
    {{}&lt;&gt;{}({}&lt;&gt;)}{}

    #Push height of alternate stack
    (&lt;&gt;[]&lt;&gt;)

#Make each time through evaluate to 1
&gt;()

#Endwhile
}

#Push the number of loops onto the offstack
&lt;&gt;)