···

       
65
       
 
       
};

     

       
66
       
 
       


     

       
67
       
 
       
const astGroup = (ast, depth, opts) => {

     

       
68
       
-
       
  if (ast.sequence.length === 1)

     

       
69
       
-
       
    return astExpression(ast.sequence[0], depth, opts);

     

       
70
       
-
       


     

       
71
       
 
       
  const capture = !!opts.capture && !ast.capture;

     

       
72
       
 
       


     

       
73
       
 
       
  let group = '';

     
···

       
208
       
 
       
    }

     

       
209
       
 
       


     

       
210
       
 
       
    let sequence = '';

     

       
211
       
-
       
    for (let i = 0; i < ast.sequence.length; i++)

     

       
212
       
-
       
      sequence += astQuantifier(ast.sequence[i], depth, childOpts);

     

       
213
       
 
       


     

       
214
       
 
       
    if (!ast.alternation) {

     

       
215
       
 
       
      body += sequence;

     

···

       
65
       
 
       
};

     

       
66
       
 
       


     

       
67
       
 
       
const astGroup = (ast, depth, opts) => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
68
       
 
       
  const capture = !!opts.capture && !ast.capture;

     

       
69
       
 
       


     

       
70
       
 
       
  let group = '';

     
···

       
205
       
 
       
    }

     

       
206
       
 
       


     

       
207
       
 
       
    let sequence = '';

     

       
208
       
+
       
    for (let i = 0; i < ast.length; i++)

     

       
209
       
+
       
      sequence += astQuantifier(ast[i], depth, childOpts);

     

       
210
       
 
       


     

       
211
       
 
       
    if (!ast.alternation) {

     

       
212
       
 
       
      body += sequence;

     

···

       
3
       
 
       
  let stackIndex = 0;

     

       
4
       
 
       


     

       
5
       
 
       
  const sequenceStack = [];

     

       
6
       
-
       
  const rootSequence = {

     

       
7
       
-
       
    sequence: [],

     

       
8
       
-
       
  };

     

       
9
       
 
       


     

       
10
       
 
       
  let currentGroup = null;

     

       
11
       
 
       
  let lastMatch;

     
···

       
13
       
 
       


     

       
14
       
 
       
  while (stackIndex < quasis.length + expressions.length) {

     

       
15
       
 
       
    if (stackIndex % 2 !== 0) {

     

       
16
       
-
       
      currentSequence.sequence.push({

     

       
17
       
 
       
        expression: expressions[stackIndex++ >> 1],

     

       
18
       
 
       
      });

     

       
19
       
 
       
    }

     
···

       
24
       
 
       


     

       
25
       
 
       
      if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {

     

       
26
       
 
       
        continue;

     

       
27
       
-
       
      } else if (char === '|' && currentSequence.sequence.length > 0) {

     

       
28
       
-
       
        currentSequence = currentSequence.alternation = {

     

       
29
       
-
       
          sequence: [],

     

       
30
       
-
       
        };

     

       
31
       
-
       


     

       
32
       
 
       
        continue;

     

       
33
       
-
       
      } else if (char === ')' && currentSequence.sequence.length > 0) {

     

       
34
       
 
       
        currentGroup = null;

     

       
35
       
 
       
        currentSequence = sequenceStack.pop();

     

       
36
       
 
       
        if (currentSequence) continue;

     

       
37
       
 
       
      } else if (char === '(') {

     

       
38
       
 
       
        currentGroup = {

     

       
39
       
-
       
          sequence: {

     

       
40
       
-
       
            sequence: [],

     

       
41
       
-
       
          },

     

       
42
       
 
       
        };

     

       
43
       
 
       


     

       
44
       
 
       
        sequenceStack.push(currentSequence);

     

       
45
       
-
       
        currentSequence.sequence.push(currentGroup);

     

       
46
       
 
       
        currentSequence = currentGroup.sequence;

     

       
47
       
 
       
        continue;

     

       
48
       
-
       
      } else if (

     

       
49
       
-
       
        char === '?' &&

     

       
50
       
-
       
        currentSequence.sequence.length === 0 &&

     

       
51
       
-
       
        currentGroup

     

       
52
       
-
       
      ) {

     

       
53
       
 
       
        const nextChar = quasi[quasiIndex++];

     

       
54
       
 
       
        if (nextChar === ':') {

     

       
55
       
 
       
          currentGroup.capture = nextChar;

     
···

       
63
       
 
       
        }

     

       
64
       
 
       
      } else if (

     

       
65
       
 
       
        (char === '?' || char === '+' || char === '*') &&

     

       
66
       
-
       
        (lastMatch =

     

       
67
       
-
       
          currentSequence.sequence[currentSequence.sequence.length - 1])

     

       
68
       
 
       
      ) {

     

       
69
       
 
       
        lastMatch.quantifier = char;

     

       
70
       
 
       
        continue;

     

···

       
3
       
 
       
  let stackIndex = 0;

     

       
4
       
 
       


     

       
5
       
 
       
  const sequenceStack = [];

     

       
6
       
+
       
  const rootSequence = [];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
  let currentGroup = null;

     

       
9
       
 
       
  let lastMatch;

     
···

       
11
       
 
       


     

       
12
       
 
       
  while (stackIndex < quasis.length + expressions.length) {

     

       
13
       
 
       
    if (stackIndex % 2 !== 0) {

     

       
14
       
+
       
      currentSequence.push({

     

       
15
       
 
       
        expression: expressions[stackIndex++ >> 1],

     

       
16
       
 
       
      });

     

       
17
       
 
       
    }

     
···

       
22
       
 
       


     

       
23
       
 
       
      if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {

     

       
24
       
 
       
        continue;

     

       
25
       
+
       
      } else if (char === '|' && currentSequence.length) {

     

       
26
       
+
       
        currentSequence = currentSequence.alternation = [];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
27
       
 
       
        continue;

     

       
28
       
+
       
      } else if (char === ')' && currentSequence.length) {

     

       
29
       
 
       
        currentGroup = null;

     

       
30
       
 
       
        currentSequence = sequenceStack.pop();

     

       
31
       
 
       
        if (currentSequence) continue;

     

       
32
       
 
       
      } else if (char === '(') {

     

       
33
       
 
       
        currentGroup = {

     

       
34
       
+
       
          sequence: [],

     

       
0
       
 
       

     

       
0
       
 
       

     

       
35
       
 
       
        };

     

       
36
       
 
       


     

       
37
       
 
       
        sequenceStack.push(currentSequence);

     

       
38
       
+
       
        currentSequence.push(currentGroup);

     

       
39
       
 
       
        currentSequence = currentGroup.sequence;

     

       
40
       
 
       
        continue;

     

       
41
       
+
       
      } else if (char === '?' && !currentSequence.length && currentGroup) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
42
       
 
       
        const nextChar = quasi[quasiIndex++];

     

       
43
       
 
       
        if (nextChar === ':') {

     

       
44
       
 
       
          currentGroup.capture = nextChar;

     
···

       
52
       
 
       
        }

     

       
53
       
 
       
      } else if (

     

       
54
       
 
       
        (char === '?' || char === '+' || char === '*') &&

     

       
55
       
+
       
        (lastMatch = currentSequence[currentSequence.length - 1])

     

       
0
       
 
       

     

       
56
       
 
       
      ) {

     

       
57
       
 
       
        lastMatch.quantifier = char;

     

       
58
       
 
       
        continue;

     

···

       
2
       
 
       


     

       
3
       
 
       
const parseTag = (quasis, ...expressions) => parse(quasis, expressions);

     

       
4
       
 
       


     

       
5
       
-
       
it('supports parsing expressions', () => {

     

       
6
       
-
       
  expect(parseTag`${1}`).toEqual({

     

       
7
       
-
       
    sequence: [

     

       
8
       
-
       
      {

     

       
9
       
-
       
        expression: 1,

     

       
10
       
-
       
        quantifier: undefined,

     

       
11
       
-
       
      },

     

       
12
       
-
       
    ],

     

       
13
       
-
       
    alternation: undefined,

     

       
14
       
-
       
  });

     

       
15
       
-
       
});

     

       
16
       
-
       


     

       
17
       
 
       
it('supports parsing expressions with quantifiers', () => {

     

       
18
       
 
       
  let ast;

     

       
19
       
 
       


     

       
20
       
 
       
  ast = parseTag`${1}?`;

     

       
21
       
-
       
  expect(ast).toHaveProperty('sequence.0.quantifier', '?');

     

       
22
       
 
       


     

       
23
       
 
       
  ast = parseTag`${1}+`;

     

       
24
       
-
       
  expect(ast).toHaveProperty('sequence.0.quantifier', '+');

     

       
25
       
 
       


     

       
26
       
 
       
  ast = parseTag`${1}*`;

     

       
27
       
-
       
  expect(ast).toHaveProperty('sequence.0.quantifier', '*');

     

       
28
       
 
       
});

     

       
29
       
 
       


     

       
30
       
 
       
it('supports top-level alternations', () => {

     

       
31
       
 
       
  let ast;

     

       
32
       
 
       


     

       
33
       
 
       
  ast = parseTag`${1} | ${2}`;

     

       
34
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
35
       
-
       
  expect(ast).toHaveProperty('sequence.0.expression', 1);

     

       
36
       
-
       
  expect(ast).toHaveProperty('alternation.sequence.0.expression', 2);

     

       
37
       
 
       


     

       
38
       
 
       
  ast = parseTag`${1}? | ${2}?`;

     

       
39
       
-
       
  expect(ast).toHaveProperty('sequence.0.quantifier', '?');

     

       
40
       
 
       
});

     

       
41
       
 
       


     

       
42
       
 
       
it('supports groups with quantifiers', () => {

     

       
43
       
 
       
  let ast;

     

       
44
       
 
       


     

       
45
       
 
       
  ast = parseTag`(${1} ${2})`;

     

       
46
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
47
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.length', 2);

     

       
48
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.0.expression', 1);

     

       
49
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.1.expression', 2);

     

       
50
       
 
       


     

       
51
       
 
       
  ast = parseTag`(${1} ${2}?)?`;

     

       
52
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
53
       
-
       
  expect(ast).toHaveProperty('sequence.0.quantifier', '?');

     

       
54
       
-
       
  expect(ast).toHaveProperty(

     

       
55
       
-
       
    'sequence.0.sequence.sequence.0.quantifier',

     

       
56
       
-
       
    undefined

     

       
57
       
-
       
  );

     

       
58
       
 
       
});

     

       
59
       
 
       


     

       
60
       
 
       
it('supports non-capturing groups', () => {

     

       
61
       
 
       
  const ast = parseTag`(?: ${1})`;

     

       
62
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
63
       
-
       
  expect(ast).toHaveProperty('sequence.0.capture', ':');

     

       
64
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.length', 1);

     

       
65
       
 
       
});

     

       
66
       
 
       


     

       
67
       
 
       
it('supports positive lookahead groups', () => {

     

       
68
       
 
       
  const ast = parseTag`(?= ${1})`;

     

       
69
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
70
       
-
       
  expect(ast).toHaveProperty('sequence.0.capture', '=');

     

       
71
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.length', 1);

     

       
72
       
 
       
});

     

       
73
       
 
       


     

       
74
       
 
       
it('supports negative lookahead groups', () => {

     

       
75
       
 
       
  const ast = parseTag`(?! ${1})`;

     

       
76
       
-
       
  expect(ast).toHaveProperty('sequence.length', 1);

     

       
77
       
-
       
  expect(ast).toHaveProperty('sequence.0.capture', '!');

     

       
78
       
-
       
  expect(ast).toHaveProperty('sequence.0.sequence.sequence.length', 1);

     

       
79
       
 
       
});

     

       
80
       
 
       


     

       
81
       
 
       
it('supports groups with alternates', () => {

     

       
82
       
 
       
  expect(parseTag`(${1} | ${2}) ${3}`).toMatchInlineSnapshot(`

     

       
83
       
-
       
    Object {

     

       
84
       
-
       
      "sequence": Array [

     

       
85
       
-
       
        Object {

     

       
86
       
-
       
          "sequence": Object {

     

       
87
       
-
       
            "alternation": Object {

     

       
88
       
-
       
              "sequence": Array [

     

       
89
       
-
       
                Object {

     

       
90
       
-
       
                  "expression": 2,

     

       
91
       
-
       
                },

     

       
92
       
-
       
              ],

     

       
93
       
-
       
            },

     

       
94
       
-
       
            "sequence": Array [

     

       
95
       
-
       
              Object {

     

       
96
       
-
       
                "expression": 1,

     

       
97
       
-
       
              },

     

       
98
       
-
       
            ],

     

       
99
       
 
       
          },

     

       
100
       
-
       
        },

     

       
101
       
-
       
        Object {

     

       
102
       
-
       
          "expression": 3,

     

       
103
       
-
       
        },

     

       
104
       
-
       
      ],

     

       
105
       
-
       
    }

     

       
106
       
 
       
  `);

     

       
107
       
 
       
});

     

···

       
2
       
 
       


     

       
3
       
 
       
const parseTag = (quasis, ...expressions) => parse(quasis, expressions);

     

       
4
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
it('supports parsing expressions with quantifiers', () => {

     

       
6
       
 
       
  let ast;

     

       
7
       
 
       


     

       
8
       
 
       
  ast = parseTag`${1}?`;

     

       
9
       
+
       
  expect(ast).toHaveProperty('0.quantifier', '?');

     

       
10
       
 
       


     

       
11
       
 
       
  ast = parseTag`${1}+`;

     

       
12
       
+
       
  expect(ast).toHaveProperty('0.quantifier', '+');

     

       
13
       
 
       


     

       
14
       
 
       
  ast = parseTag`${1}*`;

     

       
15
       
+
       
  expect(ast).toHaveProperty('0.quantifier', '*');

     

       
16
       
 
       
});

     

       
17
       
 
       


     

       
18
       
 
       
it('supports top-level alternations', () => {

     

       
19
       
 
       
  let ast;

     

       
20
       
 
       


     

       
21
       
 
       
  ast = parseTag`${1} | ${2}`;

     

       
22
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
23
       
+
       
  expect(ast).toHaveProperty('0.expression', 1);

     

       
24
       
+
       
  expect(ast).toHaveProperty('alternation.0.expression', 2);

     

       
25
       
 
       


     

       
26
       
 
       
  ast = parseTag`${1}? | ${2}?`;

     

       
27
       
+
       
  expect(ast).toHaveProperty('0.quantifier', '?');

     

       
28
       
 
       
});

     

       
29
       
 
       


     

       
30
       
 
       
it('supports groups with quantifiers', () => {

     

       
31
       
 
       
  let ast;

     

       
32
       
 
       


     

       
33
       
 
       
  ast = parseTag`(${1} ${2})`;

     

       
34
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
35
       
+
       
  expect(ast).toHaveProperty('0.sequence.length', 2);

     

       
36
       
+
       
  expect(ast).toHaveProperty('0.sequence.0.expression', 1);

     

       
37
       
+
       
  expect(ast).toHaveProperty('0.sequence.1.expression', 2);

     

       
38
       
 
       


     

       
39
       
 
       
  ast = parseTag`(${1} ${2}?)?`;

     

       
40
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
41
       
+
       
  expect(ast).toHaveProperty('0.quantifier', '?');

     

       
42
       
+
       
  expect(ast).toHaveProperty('0.sequence.0.quantifier', undefined);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
});

     

       
44
       
 
       


     

       
45
       
 
       
it('supports non-capturing groups', () => {

     

       
46
       
 
       
  const ast = parseTag`(?: ${1})`;

     

       
47
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
48
       
+
       
  expect(ast).toHaveProperty('0.capture', ':');

     

       
49
       
+
       
  expect(ast).toHaveProperty('0.sequence.length', 1);

     

       
50
       
 
       
});

     

       
51
       
 
       


     

       
52
       
 
       
it('supports positive lookahead groups', () => {

     

       
53
       
 
       
  const ast = parseTag`(?= ${1})`;

     

       
54
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
55
       
+
       
  expect(ast).toHaveProperty('0.capture', '=');

     

       
56
       
+
       
  expect(ast).toHaveProperty('0.sequence.length', 1);

     

       
57
       
 
       
});

     

       
58
       
 
       


     

       
59
       
 
       
it('supports negative lookahead groups', () => {

     

       
60
       
 
       
  const ast = parseTag`(?! ${1})`;

     

       
61
       
+
       
  expect(ast).toHaveProperty('length', 1);

     

       
62
       
+
       
  expect(ast).toHaveProperty('0.capture', '!');

     

       
63
       
+
       
  expect(ast).toHaveProperty('0.sequence.length', 1);

     

       
64
       
 
       
});

     

       
65
       
 
       


     

       
66
       
 
       
it('supports groups with alternates', () => {

     

       
67
       
 
       
  expect(parseTag`(${1} | ${2}) ${3}`).toMatchInlineSnapshot(`

     

       
68
       
+
       
    Array [

     

       
69
       
+
       
      Object {

     

       
70
       
+
       
        "sequence": Array [

     

       
71
       
+
       
          Object {

     

       
72
       
+
       
            "expression": 1,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
73
       
 
       
          },

     

       
74
       
+
       
        ],

     

       
75
       
+
       
      },

     

       
76
       
+
       
      Object {

     

       
77
       
+
       
        "expression": 3,

     

       
78
       
+
       
      },

     

       
79
       
+
       
    ]

     

       
80
       
 
       
  `);

     

       
81
       
 
       
});