What?

Recursively match balanced string pairs, like { and } or and using balanced-match and add level information to the matches.

Example

yarn add balanced-match-all

1
2    const match_all = require("balanced-match-all")
3
4    let str = 'pre{in{nested{deep-nested}}}post'
5    let arr = match_all('{', '}', str);
6
7    console.log(arr);
8
9    console.log(arr.map(o => o.body));
10

This will output:

1    [
2        {
3            "start": 3,
4            "end": 27,
5            "pre": "pre",
6            "body": "in{nested{deep-nested}}",
7            "post": "post",
8            "level": 0
9        },
10        {
11            "start": 6,
12            "end": 26,
13            "pre": "in",
14            "body": "nested{deep-nested}",
15            "post": "",
16            "level": 1
17        },
18        {
19            "start": 13,
20            "end": 25,
21            "pre": "nested",
22            "body": "deep-nested",
23            "post": "",
24            "level": 2
25        }
26    ]
27

API

The API is exactly the same as balanced-match.

var m = balanced(a, b, str)

For the first non-nested matching pair of a and b in str, return an object with those keys:

• start the index of the first match of a
• end the index of the matching b
• pre the preamble, a and b not included
• body the match, a and b not included
• post the postscript, a and b not included

If there's no match, undefined will be returned.

If the str contains more a than b / there are unmatched pairs, the first match that was closed will be used. For example, {{a} will match ['{', 'a', ''] and {a}} will match ['', 'a', '}'].