7 added 29 characters in body
source | link
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a)
                       ®          Ðḟ - recallfilter valuediscard fromif register
(non empty is truthy):
                  W           µÐL   - wrap a inloop auntil listno change:
                      ; ®           - concatenate    recall value from register
                     W           Ðḟ  - filter discard if:  wrap loop variable in a list
                      ;       µÐL   -  - loop until no change: concatenate
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split left on occurrences of sublist (a pairon ofthe brackets)right
                          F        -       flatten the result
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a)
                       ®           - recall value from register
                     W             - wrap a in a list
                      ;            - concatenate
                                Ðḟ - filter discard if:
                             µÐL   -   loop until no change:
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split on occurrences of sublist (a pair of brackets)
                          F        -       flatten the result
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation
                                Ðḟ - filter discard if (non empty is truthy):
                             µÐL   -   loop until no change:
                       ®           -     recall value from register
                     W             -     wrap loop variable in a list
                      ;            -     concatenate
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split left on occurrences of sublist on the right
                          F        -       flatten the result
6 added 12 characters in body
source | link
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a)
                       ®           - recall value from register
                     W             - wrap a in a list
                      ;            - concatenate
                                Ðḟ - filter discard if:
                            µÐL µÐL   -   loop until no change:
                           ¥ /      -     reduce with last two links as a dyad:
                        œṣ         -       split on occurrences of sublist (a pair of brackets)
                          F        -       flatten the result
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a)
                       ®           - recall value from register
                     W             - wrap a in a list
                      ;            - concatenate
                                Ðḟ - filter discard if:
                            µÐL    -   loop until no change:
                           ¥       -     last two links as a dyad:
                        œṣ         -       split on occurrences of sublist (a pair of brackets)
                          F        -       flatten the result
“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a)
                       ®           - recall value from register
                     W             - wrap a in a list
                      ;            - concatenate
                                Ðḟ - filter discard if:
                             µÐL   -   loop until no change:
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split on occurrences of sublist (a pair of brackets)
                          F        -       flatten the result
5 added 161 characters in body
source | link

Jelly, 50 40 4034 bytes

-6 bytes thanks to Leaky Nun (getting reduce to work where I couldn't)

®“œṣ⁾“F”jЀFvµÐL
“()“{}“[]“<>”©ẋ"FŒ!QÇÐḟQµW;®œṣF¥/µÐLÐḟ

Try it online!Try it online! (times out at TIO for [1,1,1,1] - yes, inefficient.)

Recursively removes pairs of matching brackets that reside right next to each other until no more may be removed for every possible string one may form, keeping such strings which reduce to nothing (hence have all matching content).

®“œṣ⁾“F”jЀFvµÐL“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - LinkMain 1link: recursive reductionlist: string s
         [n(), n{}, n[], n<>]
“()“{}“[]“<>” µÐL - loop until no change:
®                - recal from register:literal ["()", "{}", "[]", "<>"]
 “œṣ⁾“F”         - literal ["œṣ⁾", "F"]
©         Ѐ      - map:
     - copy to jregister
        -   join: [["œṣ⁾","()","F"],["œṣ⁾","{}   ","F"],["œṣ⁾","[]","F"],["œṣ⁾","<>","F"]]
           F        - flatten:zip "œṣ⁾()Fœṣ⁾{}Fœṣ⁾[]Fœṣ⁾<>F"with:
            v    - evaluate as Jelly code with input s           -   repeat list
                F -   œṣ     - split on sublists     } - flatten
                 -Œ!     ⁾..  - literal char-pair     } for each- ofall thepermutations four(yeah, possibleit's inefficient!)
                 -  Q      F         - flattende-duplicate
               }

“()“{}“[]“<>”©ẋ"FŒ!QÇÐḟ - Main link: list: [n(),µ n{}, n[], n<>]
“()“{}“[]“<>”           - literalmonadic ["chain separation (call that a)", 
 "{}", "[]", "<>"]
             ©       ®           - copyrecall tovalue from register
               "      W             - zipwrap with:a in a list
                      ;  -   repeat list      - concatenate
                F                Ðḟ - flattenfilter discard if:
                 Œ!           µÐL    - all permutations (yeah,loop it'suntil inefficient!)no change:
                   Q    - de   ¥       -duplicate     last two links as a dyad:
                     Ðḟ   œṣ         - filter discard if:    split on occurrences of sublist (a pair of brackets)
                    Ç   -   callF last link (1) as a monad (non -empty is truthy, while empty is falsey) flatten the result

Jelly, 50 40 bytes

®“œṣ⁾“F”jЀFvµÐL
“()“{}“[]“<>”©ẋ"FŒ!QÇÐḟ

Try it online! (times out at TIO for [1,1,1,1] - yes, inefficient.)

®“œṣ⁾“F”jЀFvµÐL - Link 1: recursive reduction: string s
             µÐL - loop until no change:
®                - recal from register: ["()", "{}", "[]", "<>"]
 “œṣ⁾“F”         - literal ["œṣ⁾", "F"]
         Ѐ      - map:
        j        -   join: [["œṣ⁾","()","F"],["œṣ⁾","{}","F"],["œṣ⁾","[]","F"],["œṣ⁾","<>","F"]]
           F     - flatten: "œṣ⁾()Fœṣ⁾{}Fœṣ⁾[]Fœṣ⁾<>F"
            v    - evaluate as Jelly code with input s
                 -   œṣ     - split on sublists     }
                 -     ⁾..  - literal char-pair     } for each of the four possible
                 -        F - flatten               }

“()“{}“[]“<>”©ẋ"FŒ!QÇÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”           - literal ["()", "{}", "[]", "<>"]
             ©          - copy to register
               "        - zip with:
                       -   repeat list
                F       - flatten
                 Œ!     - all permutations (yeah, it's inefficient!)
                   Q    - de-duplicate
                     Ðḟ - filter discard if:
                    Ç   -   call last link (1) as a monad (non-empty is truthy, while empty is falsey)

Jelly, 50 40 34 bytes

-6 bytes thanks to Leaky Nun (getting reduce to work where I couldn't)

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ

Try it online! (times out at TIO for [1,1,1,1] - yes, inefficient.)

Recursively removes pairs of matching brackets that reside right next to each other until no more may be removed for every possible string one may form, keeping such strings which reduce to nothing (hence have all matching content).

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
                                  -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation (call that a) 
                       ®           - recall value from register
                     W             - wrap a in a list
                      ;            - concatenate
                                Ðḟ - filter discard if:
                            µÐL    -   loop until no change:
                           ¥       -     last two links as a dyad:
                        œṣ         -       split on occurrences of sublist (a pair of brackets)
                          F        -       flatten the result
4 added 55 characters in body
source | link
3 added 55 characters in body
source | link
2 added 956 characters in body
source | link
1
source | link