···

       
14
       
 
       
  length: next.length != null ? next.length : prev.length,

     

       
15
       
 
       
  onAbort: next.onAbort != null ? next.onAbort : prev.onAbort,

     

       
16
       
 
       
  abort: next.abort != null ? next.abort : prev.abort,

     

       
17
       
-
       
  capturing: next.capturing != null ? next.capturing : prev.capturing,

     

       
18
       
 
       
});

     

       
19
       
 
       


     

       
20
       
 
       
const assignIndex = (depth) =>

     
···

       
47
       
 
       
    ${opts.abort || ''}

     

       
48
       
 
       
  `;

     

       
49
       
 
       


     

       
50
       
-
       
  if (!opts.capturing) {

     

       
51
       
 
       
    return js`

     

       
52
       
 
       
      if (!(${ast.expression})) {

     

       
53
       
 
       
        ${abort}

     
···

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

     

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

     

       
70
       
 
       


     

       
71
       
-
       
  const capturing = !!opts.capturing && !!ast.capturing;

     

       
72
       
 
       


     

       
73
       
 
       
  let group = '';

     

       
74
       
-
       
  if (!opts.length && capturing) {

     

       
75
       
 
       
    return js`

     

       
76
       
 
       
      ${js`var length_${depth} = ${_node}.length;`}

     

       
77
       
 
       
      ${astSequence(

     
···

       
79
       
 
       
        depth + 1,

     

       
80
       
 
       
        newOpts(opts, {

     

       
81
       
 
       
          length: depth,

     

       
82
       
-
       
          capturing,

     

       
83
       
 
       
        })

     

       
84
       
 
       
      )}

     

       
85
       
 
       
    `;

     
···

       
89
       
 
       
    ast.sequence,

     

       
90
       
 
       
    depth + 1,

     

       
91
       
 
       
    newOpts(opts, {

     

       
92
       
-
       
      capturing,

     

       
93
       
 
       
    })

     

       
94
       
 
       
  );

     

       
95
       
 
       
};

     
···

       
159
       
 
       
  const { index, abort } = opts;

     

       
160
       
 
       
  const label = `invert_${depth}`;

     

       
161
       
 
       


     

       
162
       
-
       
  if (ast.lookahead === 'negative') {

     

       
163
       
 
       
    opts = newOpts(opts, {

     

       
164
       
 
       
      index: depth,

     

       
165
       
 
       
      abort: js`break ${label};`,

     
···

       
174
       
 
       
  else if (ast.quantifier === 'optional') child = astOptional(ast, depth, opts);

     

       
175
       
 
       
  else child = astChild(ast, depth, opts);

     

       
176
       
 
       


     

       
177
       
-
       
  if (ast.lookahead === 'negative') {

     

       
178
       
 
       
    return js`

     

       
179
       
 
       
      ${label}: {

     

       
180
       
 
       
        ${assignIndex(depth)}

     
···

       
183
       
 
       
        ${abort}

     

       
184
       
 
       
      }

     

       
185
       
 
       
    `;

     

       
186
       
-
       
  } else if (ast.lookahead) {

     

       
187
       
 
       
    return js`

     

       
188
       
 
       
      ${assignIndex(depth)}

     

       
189
       
 
       
      ${child}

     
···

       
247
       
 
       
      length: 0,

     

       
248
       
 
       
      onAbort: '',

     

       
249
       
 
       
      abort: js`return;`,

     

       
250
       
-
       
      capturing: true,

     

       
251
       
 
       
    })}

     

       
252
       
 
       


     

       
253
       
 
       
    ${_node}.tag = ${name};

     

···

       
14
       
 
       
  length: next.length != null ? next.length : prev.length,

     

       
15
       
 
       
  onAbort: next.onAbort != null ? next.onAbort : prev.onAbort,

     

       
16
       
 
       
  abort: next.abort != null ? next.abort : prev.abort,

     

       
17
       
+
       
  capture: next.capture != null ? next.capture : prev.capture,

     

       
18
       
 
       
});

     

       
19
       
 
       


     

       
20
       
 
       
const assignIndex = (depth) =>

     
···

       
47
       
 
       
    ${opts.abort || ''}

     

       
48
       
 
       
  `;

     

       
49
       
 
       


     

       
50
       
+
       
  if (!opts.capture) {

     

       
51
       
 
       
    return js`

     

       
52
       
 
       
      if (!(${ast.expression})) {

     

       
53
       
 
       
        ${abort}

     
···

       
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 = '';

     

       
74
       
+
       
  if (!opts.length && capture) {

     

       
75
       
 
       
    return js`

     

       
76
       
 
       
      ${js`var length_${depth} = ${_node}.length;`}

     

       
77
       
 
       
      ${astSequence(

     
···

       
79
       
 
       
        depth + 1,

     

       
80
       
 
       
        newOpts(opts, {

     

       
81
       
 
       
          length: depth,

     

       
82
       
+
       
          capture,

     

       
83
       
 
       
        })

     

       
84
       
 
       
      )}

     

       
85
       
 
       
    `;

     
···

       
89
       
 
       
    ast.sequence,

     

       
90
       
 
       
    depth + 1,

     

       
91
       
 
       
    newOpts(opts, {

     

       
92
       
+
       
      capture,

     

       
93
       
 
       
    })

     

       
94
       
 
       
  );

     

       
95
       
 
       
};

     
···

       
159
       
 
       
  const { index, abort } = opts;

     

       
160
       
 
       
  const label = `invert_${depth}`;

     

       
161
       
 
       


     

       
162
       
+
       
  if (ast.capture === '!') {

     

       
163
       
 
       
    opts = newOpts(opts, {

     

       
164
       
 
       
      index: depth,

     

       
165
       
 
       
      abort: js`break ${label};`,

     
···

       
174
       
 
       
  else if (ast.quantifier === 'optional') child = astOptional(ast, depth, opts);

     

       
175
       
 
       
  else child = astChild(ast, depth, opts);

     

       
176
       
 
       


     

       
177
       
+
       
  if (ast.capture === '!') {

     

       
178
       
 
       
    return js`

     

       
179
       
 
       
      ${label}: {

     

       
180
       
 
       
        ${assignIndex(depth)}

     
···

       
183
       
 
       
        ${abort}

     

       
184
       
 
       
      }

     

       
185
       
 
       
    `;

     

       
186
       
+
       
  } else if (ast.capture === '=') {

     

       
187
       
 
       
    return js`

     

       
188
       
 
       
      ${assignIndex(depth)}

     

       
189
       
 
       
      ${child}

     
···

       
247
       
 
       
      length: 0,

     

       
248
       
 
       
      onAbort: '',

     

       
249
       
 
       
      abort: js`return;`,

     

       
250
       
+
       
      capture: true,

     

       
251
       
 
       
    })}

     

       
252
       
 
       


     

       
253
       
 
       
    ${_node}.tag = ${name};

     

···

       
50
       
 
       
            sequence: [],

     

       
51
       
 
       
            alternation: null,

     

       
52
       
 
       
          },

     

       
53
       
-
       
          capturing: true,

     

       
54
       
 
       
          lookahead: null,

     

       
55
       
 
       
          quantifier: null,

     

       
56
       
 
       
        };

     
···

       
70
       
 
       
        }

     

       
71
       
 
       


     

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

     

       
73
       
-
       
          currentGroup.capturing = false;

     

       
74
       
 
       
          continue;

     

       
75
       
 
       
        } else if (nextChar === '=') {

     

       
76
       
-
       
          currentGroup.capturing = false;

     

       
77
       
-
       
          currentGroup.lookahead = 'positive';

     

       
78
       
 
       
          continue;

     

       
79
       
 
       
        } else if (nextChar === '!') {

     

       
80
       
-
       
          currentGroup.capturing = false;

     

       
81
       
-
       
          currentGroup.lookahead = 'negative';

     

       
82
       
 
       
          continue;

     

       
83
       
 
       
        }

     

       
84
       
 
       
      } else if (

     

···

       
50
       
 
       
            sequence: [],

     

       
51
       
 
       
            alternation: null,

     

       
52
       
 
       
          },

     

       
53
       
+
       
          capture: null,

     

       
54
       
 
       
          lookahead: null,

     

       
55
       
 
       
          quantifier: null,

     

       
56
       
 
       
        };

     
···

       
70
       
 
       
        }

     

       
71
       
 
       


     

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

     

       
73
       
+
       
          currentGroup.capture = nextChar;

     

       
74
       
 
       
          continue;

     

       
75
       
 
       
        } else if (nextChar === '=') {

     

       
76
       
+
       
          currentGroup.capture = nextChar;

     

       
0
       
 
       

     

       
77
       
 
       
          continue;

     

       
78
       
 
       
        } else if (nextChar === '!') {

     

       
79
       
+
       
          currentGroup.capture = nextChar;

     

       
0
       
 
       

     

       
80
       
 
       
          continue;

     

       
81
       
 
       
        }

     

       
82
       
 
       
      } else if (

     

···

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

     

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

     

       
69
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

       
70
       
-
       
  expect(ast).toHaveProperty('sequence.0.capturing', false);

     

       
71
       
-
       
  expect(ast).toHaveProperty('sequence.0.lookahead', null);

     

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

     

       
73
       
 
       
});

     

       
74
       
 
       


     
···

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

     

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

     

       
78
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

       
79
       
-
       
  expect(ast).toHaveProperty('sequence.0.capturing', false);

     

       
80
       
-
       
  expect(ast).toHaveProperty('sequence.0.lookahead', 'positive');

     

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

     

       
82
       
 
       
});

     

       
83
       
 
       


     
···

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

     

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

     

       
87
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

       
88
       
-
       
  expect(ast).toHaveProperty('sequence.0.capturing', false);

     

       
89
       
-
       
  expect(ast).toHaveProperty('sequence.0.lookahead', 'negative');

     

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

     

       
91
       
 
       
});

     

       
92
       
 
       


     
···

       
96
       
 
       
      "alternation": null,

     

       
97
       
 
       
      "sequence": Array [

     

       
98
       
 
       
        Object {

     

       
99
       
-
       
          "capturing": true,

     

       
100
       
 
       
          "lookahead": null,

     

       
101
       
 
       
          "quantifier": null,

     

       
102
       
 
       
          "sequence": Object {

     

···

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

     

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

     

       
69
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

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

     

       
0
       
 
       

     

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

     

       
72
       
 
       
});

     

       
73
       
 
       


     
···

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

     

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

     

       
77
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

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

     

       
0
       
 
       

     

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

     

       
80
       
 
       
});

     

       
81
       
 
       


     
···

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

     

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

     

       
85
       
 
       
  expect(ast).toHaveProperty('sequence.0.type', 'group');

     

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

     

       
0
       
 
       

     

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

     

       
88
       
 
       
});

     

       
89
       
 
       


     
···

       
93
       
 
       
      "alternation": null,

     

       
94
       
 
       
      "sequence": Array [

     

       
95
       
 
       
        Object {

     

       
96
       
+
       
          "capture": null,

     

       
97
       
 
       
          "lookahead": null,

     

       
98
       
 
       
          "quantifier": null,

     

       
99
       
 
       
          "sequence": Object {