···

       
9
       
 
       
    _node_expression2 = (0, _reghex._pattern)(2);

     

       
10
       
 
       


     

       
11
       
 
       
const node = function _node(state) {

     

       
0
       
 
       

     

       
12
       
 
       
  var match,

     

       
13
       
-
       
      last_index = state.index,

     

       
14
       
-
       
      node = (0, _reghex.tag)([], 'node');

     

       
15
       
 
       


     

       
16
       
 
       
  if (match = (0, _reghex._exec)(state, _node_expression)) {

     

       
17
       
 
       
    node.push(match);

     
···

       
27
       
 
       
    return;

     

       
28
       
 
       
  }

     

       
29
       
 
       


     

       
30
       
-
       
  return node;

     

       
31
       
 
       
};"

     

       
32
       
 
       
`;

     

       
33
       
 
       


     
···

       
37
       
 
       
var _inner_expression = _pattern(/inner/);

     

       
38
       
 
       


     

       
39
       
 
       
const inner = function _inner(state) {

     

       
0
       
 
       

     

       
40
       
 
       
  var match,

     

       
41
       
-
       
      last_index = state.index,

     

       
42
       
-
       
      node = tag([], 'inner');

     

       
43
       
 
       


     

       
44
       
 
       
  if (match = _exec(state, _inner_expression)) {

     

       
45
       
 
       
    node.push(match);

     
···

       
48
       
 
       
    return;

     

       
49
       
 
       
  }

     

       
50
       
 
       


     

       
51
       
-
       
  return node;

     

       
52
       
 
       
};

     

       
53
       
 
       


     

       
54
       
 
       
const node = function _node(state) {

     

       
0
       
 
       

     

       
55
       
 
       
  var match,

     

       
56
       
-
       
      last_index = state.index,

     

       
57
       
-
       
      node = tag([], 'node');

     

       
58
       
 
       


     

       
59
       
 
       
  if (match = inner(state)) {

     

       
60
       
 
       
    node.push(match);

     
···

       
63
       
 
       
    return;

     

       
64
       
 
       
  }

     

       
65
       
 
       


     

       
66
       
-
       
  return node;

     

       
67
       
 
       
};"

     

       
68
       
 
       
`;

     

       
69
       
 
       


     
···

       
75
       
 
       
    _node_expression3 = _pattern(3);

     

       
76
       
 
       


     

       
77
       
 
       
const node = function _node(state) {

     

       
0
       
 
       

     

       
78
       
 
       
  var match,

     

       
79
       
-
       
      last_index = state.index,

     

       
80
       
-
       
      node = _tag([], 'node');

     

       
81
       
 
       


     

       
82
       
 
       
  if (match = _exec(state, _node_expression)) {

     

       
83
       
 
       
    node.push(match);

     
···

       
119
       
 
       
    }

     

       
120
       
 
       
  }

     

       
121
       
 
       


     

       
122
       
-
       
  return node;

     

       
123
       
 
       
};"

     

       
124
       
 
       
`;

     

       
125
       
 
       


     
···

       
133
       
 
       
    _node_expression5 = _pattern(5);

     

       
134
       
 
       


     

       
135
       
 
       
const node = function _node(state) {

     

       
0
       
 
       

     

       
136
       
 
       
  var match,

     

       
137
       
-
       
      last_index = state.index,

     

       
138
       
-
       
      node = _tag([], 'node');

     

       
139
       
 
       


     

       
140
       
 
       
  block_0: {

     

       
141
       
 
       
    var index_0 = state.index;

     
···

       
156
       
 
       
      }

     

       
157
       
 
       
    }

     

       
158
       
 
       


     

       
159
       
-
       
    return node;

     

       
160
       
 
       
  }

     

       
161
       
 
       


     

       
162
       
 
       
  loop_0: for (var iter_0 = 0; true; iter_0++) {

     
···

       
204
       
 
       
    }

     

       
205
       
 
       
  }

     

       
206
       
 
       


     

       
207
       
-
       
  return node;

     

       
208
       
 
       
};"

     

       
209
       
 
       
`;

     

       
210
       
 
       


     
···

       
214
       
 
       
var _inner_transform = x => x;

     

       
215
       
 
       


     

       
216
       
 
       
const first = function _inner(state) {

     

       
0
       
 
       

     

       
217
       
 
       
  var match,

     

       
218
       
-
       
      last_index = state.index,

     

       
219
       
-
       
      node = _tag([], 'inner');

     

       
220
       
-
       


     

       
221
       
-
       
  return _inner_transform(node);

     

       
222
       
 
       
};

     

       
223
       
 
       


     

       
224
       
 
       
const transform = x => x;

     

       
225
       
 
       


     

       
226
       
 
       
const second = function _node(state) {

     

       
0
       
 
       

     

       
227
       
 
       
  var match,

     

       
228
       
-
       
      last_index = state.index,

     

       
229
       
-
       
      node = _tag([], 'node');

     

       
230
       
-
       


     

       
231
       
-
       
  return transform(node);

     

       
232
       
 
       
};"

     

       
233
       
 
       
`;

     

···

       
9
       
 
       
    _node_expression2 = (0, _reghex._pattern)(2);

     

       
10
       
 
       


     

       
11
       
 
       
const node = function _node(state) {

     

       
12
       
+
       
  var last_index = state.index;

     

       
13
       
 
       
  var match,

     

       
14
       
+
       
      node = [];

     

       
0
       
 
       

     

       
15
       
 
       


     

       
16
       
 
       
  if (match = (0, _reghex._exec)(state, _node_expression)) {

     

       
17
       
 
       
    node.push(match);

     
···

       
27
       
 
       
    return;

     

       
28
       
 
       
  }

     

       
29
       
 
       


     

       
30
       
+
       
  return (0, _reghex.tag)(node, 'node');

     

       
31
       
 
       
};"

     

       
32
       
 
       
`;

     

       
33
       
 
       


     
···

       
37
       
 
       
var _inner_expression = _pattern(/inner/);

     

       
38
       
 
       


     

       
39
       
 
       
const inner = function _inner(state) {

     

       
40
       
+
       
  var last_index = state.index;

     

       
41
       
 
       
  var match,

     

       
42
       
+
       
      node = [];

     

       
0
       
 
       

     

       
43
       
 
       


     

       
44
       
 
       
  if (match = _exec(state, _inner_expression)) {

     

       
45
       
 
       
    node.push(match);

     
···

       
48
       
 
       
    return;

     

       
49
       
 
       
  }

     

       
50
       
 
       


     

       
51
       
+
       
  return tag(node, 'inner');

     

       
52
       
 
       
};

     

       
53
       
 
       


     

       
54
       
 
       
const node = function _node(state) {

     

       
55
       
+
       
  var last_index = state.index;

     

       
56
       
 
       
  var match,

     

       
57
       
+
       
      node = [];

     

       
0
       
 
       

     

       
58
       
 
       


     

       
59
       
 
       
  if (match = inner(state)) {

     

       
60
       
 
       
    node.push(match);

     
···

       
63
       
 
       
    return;

     

       
64
       
 
       
  }

     

       
65
       
 
       


     

       
66
       
+
       
  return tag(node, 'node');

     

       
67
       
 
       
};"

     

       
68
       
 
       
`;

     

       
69
       
 
       


     
···

       
75
       
 
       
    _node_expression3 = _pattern(3);

     

       
76
       
 
       


     

       
77
       
 
       
const node = function _node(state) {

     

       
78
       
+
       
  var last_index = state.index;

     

       
79
       
 
       
  var match,

     

       
80
       
+
       
      node = [];

     

       
0
       
 
       

     

       
81
       
 
       


     

       
82
       
 
       
  if (match = _exec(state, _node_expression)) {

     

       
83
       
 
       
    node.push(match);

     
···

       
119
       
 
       
    }

     

       
120
       
 
       
  }

     

       
121
       
 
       


     

       
122
       
+
       
  return _tag(node, 'node');

     

       
123
       
 
       
};"

     

       
124
       
 
       
`;

     

       
125
       
 
       


     
···

       
133
       
 
       
    _node_expression5 = _pattern(5);

     

       
134
       
 
       


     

       
135
       
 
       
const node = function _node(state) {

     

       
136
       
+
       
  var last_index = state.index;

     

       
137
       
 
       
  var match,

     

       
138
       
+
       
      node = [];

     

       
0
       
 
       

     

       
139
       
 
       


     

       
140
       
 
       
  block_0: {

     

       
141
       
 
       
    var index_0 = state.index;

     
···

       
156
       
 
       
      }

     

       
157
       
 
       
    }

     

       
158
       
 
       


     

       
159
       
+
       
    return _tag(node, 'node');

     

       
160
       
 
       
  }

     

       
161
       
 
       


     

       
162
       
 
       
  loop_0: for (var iter_0 = 0; true; iter_0++) {

     
···

       
204
       
 
       
    }

     

       
205
       
 
       
  }

     

       
206
       
 
       


     

       
207
       
+
       
  return _tag(node, 'node');

     

       
208
       
 
       
};"

     

       
209
       
 
       
`;

     

       
210
       
 
       


     
···

       
214
       
 
       
var _inner_transform = x => x;

     

       
215
       
 
       


     

       
216
       
 
       
const first = function _inner(state) {

     

       
217
       
+
       
  var last_index = state.index;

     

       
218
       
 
       
  var match,

     

       
219
       
+
       
      node = [];

     

       
220
       
+
       
  return _inner_transform(_tag(node, 'inner'));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
221
       
 
       
};

     

       
222
       
 
       


     

       
223
       
 
       
const transform = x => x;

     

       
224
       
 
       


     

       
225
       
 
       
const second = function _node(state) {

     

       
226
       
+
       
  var last_index = state.index;

     

       
227
       
 
       
  var match,

     

       
228
       
+
       
      node = [];

     

       
229
       
+
       
  return transform(_tag(node, 'node'));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
230
       
 
       
};"

     

       
231
       
 
       
`;

     

···

       
231
       
 
       
    const loopId = t.identifier(`loop_${this.depth}`);

     

       
232
       
 
       
    const iterId = t.identifier(`iter_${this.depth}`);

     

       
233
       
 
       
    const indexId = t.identifier(`index_${this.depth}`);

     

       
234
       
-
       
    const lastIndex = t.memberExpression(ids.state, t.identifier('index'));

     

       
235
       
 
       


     

       
236
       
 
       
    let statements;

     

       
237
       
 
       
    if (quantifier && !quantifier.singular && quantifier.required) {

     
···

       
245
       
 
       
            t.booleanLiteral(true),

     

       
246
       
 
       
            t.updateExpression('++', iterId),

     

       
247
       
 
       
            t.blockStatement([

     

       
248
       
-
       
              t.variableDeclaration('var', [

     

       
249
       
-
       
                t.variableDeclarator(indexId, lastIndex),

     

       
250
       
-
       
              ]),

     

       
251
       
 
       
              ...this.childNode.statements(),

     

       
252
       
 
       
            ])

     

       
253
       
 
       
          )

     
···

       
260
       
 
       
          t.whileStatement(

     

       
261
       
 
       
            t.booleanLiteral(true),

     

       
262
       
 
       
            t.blockStatement([

     

       
263
       
-
       
              t.variableDeclaration('var', [

     

       
264
       
-
       
                t.variableDeclarator(indexId, lastIndex),

     

       
265
       
-
       
              ]),

     

       
266
       
 
       
              ...this.childNode.statements(),

     

       
267
       
 
       
            ])

     

       
268
       
 
       
          )

     

       
269
       
 
       
        ),

     

       
270
       
 
       
      ];

     

       
271
       
 
       
    } else if (quantifier && !quantifier.required) {

     

       
272
       
-
       
      statements = [

     

       
273
       
-
       
        t.variableDeclaration('var', [

     

       
274
       
-
       
          t.variableDeclarator(indexId, lastIndex),

     

       
275
       
-
       
        ]),

     

       
276
       
-
       
        ...this.childNode.statements(),

     

       
277
       
-
       
      ];

     

       
278
       
 
       
    } else {

     

       
279
       
 
       
      statements = this.childNode.statements();

     

       
280
       
 
       
    }

     
···

       
382
       
 
       
export class RootNode {

     

       
383
       
 
       
  constructor(ast, nameNode, transformNode) {

     

       
384
       
 
       
    const indexId = t.identifier('last_index');

     

       
0
       
 
       

     

       
385
       
 
       


     

       
386
       
 
       
    this.returnStatement = t.returnStatement(

     

       
387
       
-
       
      transformNode ? t.callExpression(transformNode, [ids.node]) : ids.node

     

       
388
       
 
       
    );

     

       
389
       
 
       


     

       
390
       
-
       
    this.nameNode = nameNode;

     

       
391
       
 
       
    this.node = new AlternationNode(ast, 0, {

     

       
392
       
 
       
      returnStatement: this.returnStatement,

     

       
393
       
 
       
      restoreIndex: new RestoreIndexNode(indexId, true),

     
···

       
399
       
 
       
  }

     

       
400
       
 
       


     

       
401
       
 
       
  statements() {

     

       
402
       
-
       
    const indexId = t.identifier('last_index');

     

       
403
       
-
       
    const lastIndex = t.memberExpression(ids.state, t.identifier('index'));

     

       
404
       
-
       


     

       
405
       
 
       
    return [

     

       
0
       
 
       

     

       
406
       
 
       
      t.variableDeclaration('var', [

     

       
407
       
 
       
        t.variableDeclarator(ids.match),

     

       
408
       
-
       
        t.variableDeclarator(indexId, lastIndex),

     

       
409
       
-
       
        t.variableDeclarator(

     

       
410
       
-
       
          ids.node,

     

       
411
       
-
       
          t.callExpression(ids.tag, [t.arrayExpression(), this.nameNode])

     

       
412
       
-
       
        ),

     

       
413
       
 
       
      ]),

     

       
414
       
 
       
      ...this.node.statements(),

     

       
415
       
 
       
      this.returnStatement,

     

···

       
231
       
 
       
    const loopId = t.identifier(`loop_${this.depth}`);

     

       
232
       
 
       
    const iterId = t.identifier(`iter_${this.depth}`);

     

       
233
       
 
       
    const indexId = t.identifier(`index_${this.depth}`);

     

       
234
       
+
       
    const assignIndex = new AssignIndexNode(indexId);

     

       
235
       
 
       


     

       
236
       
 
       
    let statements;

     

       
237
       
 
       
    if (quantifier && !quantifier.singular && quantifier.required) {

     
···

       
245
       
 
       
            t.booleanLiteral(true),

     

       
246
       
 
       
            t.updateExpression('++', iterId),

     

       
247
       
 
       
            t.blockStatement([

     

       
248
       
+
       
              assignIndex.statement(),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
249
       
 
       
              ...this.childNode.statements(),

     

       
250
       
 
       
            ])

     

       
251
       
 
       
          )

     
···

       
258
       
 
       
          t.whileStatement(

     

       
259
       
 
       
            t.booleanLiteral(true),

     

       
260
       
 
       
            t.blockStatement([

     

       
261
       
+
       
              assignIndex.statement(),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
262
       
 
       
              ...this.childNode.statements(),

     

       
263
       
 
       
            ])

     

       
264
       
 
       
          )

     

       
265
       
 
       
        ),

     

       
266
       
 
       
      ];

     

       
267
       
 
       
    } else if (quantifier && !quantifier.required) {

     

       
268
       
+
       
      statements = [assignIndex.statement(), ...this.childNode.statements()];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
269
       
 
       
    } else {

     

       
270
       
 
       
      statements = this.childNode.statements();

     

       
271
       
 
       
    }

     
···

       
373
       
 
       
export class RootNode {

     

       
374
       
 
       
  constructor(ast, nameNode, transformNode) {

     

       
375
       
 
       
    const indexId = t.identifier('last_index');

     

       
376
       
+
       
    const node = t.callExpression(ids.tag, [ids.node, nameNode]);

     

       
377
       
 
       


     

       
378
       
 
       
    this.returnStatement = t.returnStatement(

     

       
379
       
+
       
      transformNode ? t.callExpression(transformNode, [node]) : node

     

       
380
       
 
       
    );

     

       
381
       
 
       


     

       
382
       
+
       
    this.assignIndex = new AssignIndexNode(indexId);

     

       
383
       
 
       
    this.node = new AlternationNode(ast, 0, {

     

       
384
       
 
       
      returnStatement: this.returnStatement,

     

       
385
       
 
       
      restoreIndex: new RestoreIndexNode(indexId, true),

     
···

       
391
       
 
       
  }

     

       
392
       
 
       


     

       
393
       
 
       
  statements() {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
394
       
 
       
    return [

     

       
395
       
+
       
      this.assignIndex.statement(),

     

       
396
       
 
       
      t.variableDeclaration('var', [

     

       
397
       
 
       
        t.variableDeclarator(ids.match),

     

       
398
       
+
       
        t.variableDeclarator(ids.node, t.arrayExpression()),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
399
       
 
       
      ]),

     

       
400
       
 
       
      ...this.node.statements(),

     

       
401
       
 
       
      this.returnStatement,