···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1
       
 
       
export const parse = (quasis, expressions) => {

     

       
2
       
 
       
  let quasiIndex = 0;

     

       
3
       
 
       
  let stackIndex = 0;

     
···

       
9
       
 
       
  let lastMatch;

     

       
10
       
 
       
  let currentSequence = rootSequence;

     

       
11
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
14
       
 
       
      currentSequence.push({

     

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

     
···

       
17
       
 
       
    }

     

       
18
       
 
       


     

       
19
       
 
       
    const quasi = quasis[stackIndex >> 1];

     

       
20
       
-
       
    while (quasiIndex < quasi.length) {

     

       
21
       
 
       
      const char = quasi[quasiIndex++];

     

       
22
       
-
       


     

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

     

       
24
       
-
       
        continue;

     

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

     

       
26
       
 
       
        currentSequence = currentSequence.alternation = [];

     

       
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: [],

     

       
35
       
-
       
        };

     

       
36
       
-
       


     

       
37
       
 
       
        sequenceStack.push(currentSequence);

     

       
38
       
-
       
        currentSequence.push(currentGroup);

     

       
39
       
 
       
        currentSequence = currentGroup.sequence;

     

       
40
       
-
       
        continue;

     

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

     

       
42
       
 
       
        const nextChar = quasi[quasiIndex++];

     

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

     

       
44
       
 
       
          currentGroup.capture = nextChar;

     

       
45
       
-
       
          continue;

     

       
46
       
-
       
        } else if (nextChar === '=') {

     

       
47
       
-
       
          currentGroup.capture = nextChar;

     

       
48
       
-
       
          continue;

     

       
49
       
-
       
        } else if (nextChar === '!') {

     

       
50
       
-
       
          currentGroup.capture = nextChar;

     

       
51
       
-
       
          continue;

     

       
52
       
 
       
        }

     

       
53
       
 
       
      } else if (

     

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

     

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

     

       
56
       
 
       
      ) {

     

       
57
       
 
       
        lastMatch.quantifier = char;

     

       
58
       
-
       
        continue;

     

       
0
       
 
       

     

       
59
       
 
       
      }

     

       
60
       
-
       


     

       
61
       
-
       
      throw new SyntaxError('Unexpected token "' + char + '"');

     

       
62
       
 
       
    }

     

       
63
       
-
       


     

       
64
       
-
       
    stackIndex++;

     

       
65
       
-
       
    quasiIndex = 0;

     

       
66
       
 
       
  }

     

       
67
       
 
       


     

       
68
       
 
       
  return rootSequence;

     

···

       
1
       
+
       
const syntaxError = (char) => {

     

       
2
       
+
       
  throw new SyntaxError('Unexpected token "' + char + '"');

     

       
3
       
+
       
};

     

       
4
       
+
       


     

       
5
       
 
       
export const parse = (quasis, expressions) => {

     

       
6
       
 
       
  let quasiIndex = 0;

     

       
7
       
 
       
  let stackIndex = 0;

     
···

       
13
       
 
       
  let lastMatch;

     

       
14
       
 
       
  let currentSequence = rootSequence;

     

       
15
       
 
       


     

       
16
       
+
       
  for (

     

       
17
       
+
       
    let quasiIndex = 0, stackIndex = 0;

     

       
18
       
+
       
    stackIndex < quasis.length + expressions.length;

     

       
19
       
+
       
    stackIndex++

     

       
20
       
+
       
  ) {

     

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

     

       
22
       
 
       
      currentSequence.push({

     

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

     
···

       
25
       
 
       
    }

     

       
26
       
 
       


     

       
27
       
 
       
    const quasi = quasis[stackIndex >> 1];

     

       
28
       
+
       
    for (quasiIndex = 0; quasiIndex < quasi.length; ) {

     

       
29
       
 
       
      const char = quasi[quasiIndex++];

     

       
0
       
 
       

     

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

     

       
0
       
 
       

     

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

     

       
32
       
 
       
        currentSequence = currentSequence.alternation = [];

     

       
0
       
 
       

     

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

     

       
34
       
 
       
        currentGroup = null;

     

       
35
       
 
       
        currentSequence = sequenceStack.pop();

     

       
36
       
+
       
        if (!currentSequence) syntaxError(char);

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       
        sequenceStack.push(currentSequence);

     

       
39
       
+
       
        currentSequence.push((currentGroup = { sequence: [] }));

     

       
40
       
 
       
        currentSequence = currentGroup.sequence;

     

       
0
       
 
       

     

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

     

       
42
       
 
       
        const nextChar = quasi[quasiIndex++];

     

       
43
       
+
       
        if (nextChar === ':' || nextChar === '=' || nextChar === '!') {

     

       
44
       
 
       
          currentGroup.capture = nextChar;

     

       
45
       
+
       
        } else {

     

       
46
       
+
       
          syntaxError(char);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
47
       
 
       
        }

     

       
48
       
 
       
      } else if (

     

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

     

       
50
       
 
       
        (lastMatch = currentSequence[currentSequence.length - 1])

     

       
51
       
 
       
      ) {

     

       
52
       
 
       
        lastMatch.quantifier = char;

     

       
53
       
+
       
      } else {

     

       
54
       
+
       
        syntaxError(char);

     

       
55
       
 
       
      }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
56
       
 
       
    }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
57
       
 
       
  }

     

       
58
       
 
       


     

       
59
       
 
       
  return rootSequence;