···

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

     

       
10
       
 
       


     

       
11
       
 
       
const node = function (state) {

     

       
12
       
-
       
  var index_1 = state.index;

     

       
13
       
 
       
  var node = [];

     

       
14
       
-
       
  var match;

     

       
15
       
 
       


     

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

     

       
17
       
-
       
    node.push(match);

     

       
18
       
 
       
  } else {

     

       
19
       
-
       
    state.index = index_1;

     

       
20
       
 
       
    return;

     

       
21
       
 
       
  }

     

       
22
       
 
       


     

       
23
       
-
       
  if (match = (0, _reghex._exec)(state, _node_expression2)) {

     

       
24
       
-
       
    node.push(match);

     

       
25
       
 
       
  } else {

     

       
26
       
-
       
    state.index = index_1;

     

       
27
       
 
       
    return;

     

       
28
       
 
       
  }

     

       
29
       
 
       


     
···

       
43
       
 
       
var _inner_expression = _pattern(/inner/);

     

       
44
       
 
       


     

       
45
       
 
       
const inner = function (state) {

     

       
46
       
-
       
  var index_1 = state.index;

     

       
47
       
 
       
  var node = [];

     

       
48
       
-
       
  var match;

     

       
49
       
 
       


     

       
50
       
-
       
  if (match = _exec(state, _inner_expression)) {

     

       
51
       
-
       
    node.push(match);

     

       
52
       
 
       
  } else {

     

       
53
       
-
       
    state.index = index_1;

     

       
54
       
 
       
    return;

     

       
55
       
 
       
  }

     

       
56
       
 
       


     
···

       
59
       
 
       
};

     

       
60
       
 
       


     

       
61
       
 
       
const node = function (state) {

     

       
62
       
-
       
  var index_1 = state.index;

     

       
63
       
 
       
  var node = [];

     

       
64
       
-
       
  var match;

     

       
65
       
 
       


     

       
66
       
-
       
  if (match = inner(state)) {

     

       
67
       
-
       
    node.push(match);

     

       
68
       
 
       
  } else {

     

       
69
       
-
       
    state.index = index_1;

     

       
70
       
 
       
    return;

     

       
71
       
 
       
  }

     

       
72
       
 
       


     
···

       
83
       
 
       
    _node_expression3 = _pattern(3);

     

       
84
       
 
       


     

       
85
       
 
       
const node = function (state) {

     

       
86
       
-
       
  var index_1 = state.index;

     

       
87
       
 
       
  var node = [];

     

       
88
       
-
       
  var match;

     

       
89
       
 
       


     

       
90
       
-
       
  if (match = _exec(state, _node_expression)) {

     

       
91
       
-
       
    node.push(match);

     

       
92
       
 
       
  } else {

     

       
93
       
-
       
    state.index = index_1;

     

       
94
       
 
       
    return;

     

       
95
       
 
       
  }

     

       
96
       
 
       


     

       
97
       
-
       
  var length_2 = node.length;

     

       
98
       
 
       


     

       
99
       
 
       
  alternation_3: {

     

       
100
       
 
       
    block_3: {

     

       
101
       
-
       
      var index_3 = state.index;

     

       
102
       
 
       


     

       
103
       
-
       
      if (match = _exec(state, _node_expression2)) {

     

       
104
       
-
       
        node.push(match);

     

       
105
       
 
       
      } else {

     

       
106
       
-
       
        state.index = index_3;

     

       
107
       
-
       
        node.length = length_2;

     

       
108
       
 
       
        break block_3;

     

       
109
       
 
       
      }

     

       
110
       
 
       


     

       
111
       
 
       
      break alternation_3;

     

       
112
       
 
       
    }

     

       
113
       
 
       


     

       
114
       
-
       
    loop_3: for (var count_3 = 0; true; count_3++) {

     

       
115
       
-
       
      var index_3 = state.index;

     

       
116
       
 
       


     

       
117
       
 
       
      if (!_exec(state, _node_expression3)) {

     

       
118
       
-
       
        if (count_3) {

     

       
119
       
-
       
          state.index = index_3;

     

       
120
       
 
       
          break loop_3;

     

       
121
       
 
       
        } else {}

     

       
122
       
 
       


     

       
123
       
-
       
        state.index = index_1;

     

       
124
       
-
       
        node.length = length_2;

     

       
125
       
 
       
        return;

     

       
126
       
 
       
      }

     

       
127
       
 
       
    }

     
···

       
136
       
 
       
"import { match, tag, _exec, _pattern } from 'reghex';

     

       
137
       
 
       


     

       
138
       
 
       
const inner = function (state) {

     

       
139
       
-
       
  var index_1 = state.index;

     

       
140
       
 
       
  var node = [];

     

       
141
       
-
       
  var match;

     

       
142
       
 
       


     

       
143
       
-
       
  if (match = node(state)) {

     

       
144
       
-
       
    node.push(match);

     

       
145
       
 
       
  } else {

     

       
146
       
-
       
    state.index = index_1;

     

       
147
       
 
       
    return;

     

       
148
       
 
       
  }

     

       
149
       
 
       


     
···

       
152
       
 
       
};

     

       
153
       
 
       


     

       
154
       
 
       
const node = function (state) {

     

       
155
       
-
       
  var index_1 = state.index;

     

       
156
       
 
       
  var node = [];

     

       
157
       
-
       
  var match;

     

       
158
       
 
       


     

       
159
       
-
       
  if (match = inner(state)) {

     

       
160
       
-
       
    node.push(match);

     

       
161
       
 
       
  } else {

     

       
162
       
-
       
    state.index = index_1;

     

       
163
       
 
       
    return;

     

       
164
       
 
       
  }

     

       
165
       
 
       


     
···

       
178
       
 
       
    _node_expression5 = _pattern(5);

     

       
179
       
 
       


     

       
180
       
 
       
const node = function (state) {

     

       
181
       
-
       
  var index_1 = state.index;

     

       
182
       
 
       
  var node = [];

     

       
183
       
-
       
  var match;

     

       
184
       
 
       


     

       
185
       
 
       
  alternation_2: {

     

       
186
       
 
       
    block_2: {

     

       
187
       
-
       
      var index_2 = state.index;

     

       
188
       
 
       


     

       
189
       
-
       
      loop_2: for (var count_2 = 0; true; count_2++) {

     

       
190
       
-
       
        var index_2 = state.index;

     

       
191
       
 
       


     

       
192
       
-
       
        if (match = _exec(state, _node_expression)) {

     

       
193
       
-
       
          node.push(match);

     

       
194
       
 
       
        } else {

     

       
195
       
-
       
          if (count_2) {

     

       
196
       
-
       
            state.index = index_2;

     

       
197
       
 
       
            break loop_2;

     

       
198
       
 
       
          } else {}

     

       
199
       
 
       


     

       
200
       
-
       
          state.index = index_2;

     

       
201
       
 
       
          break block_2;

     

       
202
       
 
       
        }

     

       
203
       
 
       
      }

     
···

       
205
       
 
       
      break alternation_2;

     

       
206
       
 
       
    }

     

       
207
       
 
       


     

       
208
       
-
       
    loop_2: for (var count_2 = 0; true; count_2++) {

     

       
209
       
-
       
      var index_2 = state.index;

     

       
210
       
 
       


     

       
211
       
-
       
      if (match = _exec(state, _node_expression2)) {

     

       
212
       
-
       
        node.push(match);

     

       
213
       
 
       
      } else {

     

       
214
       
-
       
        if (count_2) {

     

       
215
       
-
       
          state.index = index_2;

     

       
216
       
 
       
          break loop_2;

     

       
217
       
 
       
        } else {}

     

       
218
       
 
       


     

       
219
       
-
       
        state.index = index_1;

     

       
220
       
 
       
        return;

     

       
221
       
 
       
      }

     

       
222
       
 
       
    }

     

       
223
       
 
       


     

       
224
       
-
       
    loop_2: while (true) {

     

       
225
       
-
       
      var index_2 = state.index;

     

       
226
       
-
       
      var length_2 = node.length;

     

       
227
       
 
       


     

       
228
       
-
       
      if (match = _exec(state, _node_expression3)) {

     

       
229
       
-
       
        node.push(match);

     

       
230
       
 
       
      } else {

     

       
231
       
-
       
        state.index = index_2;

     

       
232
       
-
       
        node.length = length_2;

     

       
233
       
 
       
        break loop_2;

     

       
234
       
 
       
      }

     

       
235
       
 
       


     

       
236
       
-
       
      var index_4 = state.index;

     

       
237
       
 
       


     

       
238
       
-
       
      if (match = _exec(state, _node_expression4)) {

     

       
239
       
-
       
        node.push(match);

     

       
240
       
 
       
      } else {

     

       
241
       
-
       
        state.index = index_4;

     

       
242
       
 
       
      }

     

       
243
       
 
       


     

       
244
       
-
       
      if (match = _exec(state, _node_expression5)) {

     

       
245
       
-
       
        node.push(match);

     

       
246
       
 
       
      } else {

     

       
247
       
-
       
        state.index = index_2;

     

       
248
       
-
       
        node.length = length_2;

     

       
249
       
 
       
        break loop_2;

     

       
250
       
 
       
      }

     

       
251
       
 
       
    }

     
···

       
262
       
 
       
var _inner_transform = x => x;

     

       
263
       
 
       


     

       
264
       
 
       
const first = function (state) {

     

       
265
       
-
       
  var index_1 = state.index;

     

       
266
       
 
       
  var node = [];

     

       
267
       
-
       
  var match;

     

       
268
       
 
       
  node.tag = 'inner';

     

       
269
       
 
       
  return _inner_transform(node);

     

       
270
       
 
       
};

     
···

       
272
       
 
       
const transform = x => x;

     

       
273
       
 
       


     

       
274
       
 
       
const second = function (state) {

     

       
275
       
-
       
  var index_1 = state.index;

     

       
276
       
 
       
  var node = [];

     

       
277
       
-
       
  var match;

     

       
278
       
 
       
  node.tag = 'node';

     

       
279
       
 
       
  return transform(node);

     

       
280
       
 
       
};"

     

···

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

     

       
10
       
 
       


     

       
11
       
 
       
const node = function (state) {

     

       
12
       
+
       
  var idx1 = state.index;

     

       
13
       
 
       
  var node = [];

     

       
14
       
+
       
  var x;

     

       
15
       
 
       


     

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

     

       
17
       
+
       
    node.push(x);

     

       
18
       
 
       
  } else {

     

       
19
       
+
       
    state.index = idx1;

     

       
20
       
 
       
    return;

     

       
21
       
 
       
  }

     

       
22
       
 
       


     

       
23
       
+
       
  if (x = (0, _reghex._exec)(state, _node_expression2)) {

     

       
24
       
+
       
    node.push(x);

     

       
25
       
 
       
  } else {

     

       
26
       
+
       
    state.index = idx1;

     

       
27
       
 
       
    return;

     

       
28
       
 
       
  }

     

       
29
       
 
       


     
···

       
43
       
 
       
var _inner_expression = _pattern(/inner/);

     

       
44
       
 
       


     

       
45
       
 
       
const inner = function (state) {

     

       
46
       
+
       
  var idx1 = state.index;

     

       
47
       
 
       
  var node = [];

     

       
48
       
+
       
  var x;

     

       
49
       
 
       


     

       
50
       
+
       
  if (x = _exec(state, _inner_expression)) {

     

       
51
       
+
       
    node.push(x);

     

       
52
       
 
       
  } else {

     

       
53
       
+
       
    state.index = idx1;

     

       
54
       
 
       
    return;

     

       
55
       
 
       
  }

     

       
56
       
 
       


     
···

       
59
       
 
       
};

     

       
60
       
 
       


     

       
61
       
 
       
const node = function (state) {

     

       
62
       
+
       
  var idx1 = state.index;

     

       
63
       
 
       
  var node = [];

     

       
64
       
+
       
  var x;

     

       
65
       
 
       


     

       
66
       
+
       
  if (x = inner(state)) {

     

       
67
       
+
       
    node.push(x);

     

       
68
       
 
       
  } else {

     

       
69
       
+
       
    state.index = idx1;

     

       
70
       
 
       
    return;

     

       
71
       
 
       
  }

     

       
72
       
 
       


     
···

       
83
       
 
       
    _node_expression3 = _pattern(3);

     

       
84
       
 
       


     

       
85
       
 
       
const node = function (state) {

     

       
86
       
+
       
  var idx1 = state.index;

     

       
87
       
 
       
  var node = [];

     

       
88
       
+
       
  var x;

     

       
89
       
 
       


     

       
90
       
+
       
  if (x = _exec(state, _node_expression)) {

     

       
91
       
+
       
    node.push(x);

     

       
92
       
 
       
  } else {

     

       
93
       
+
       
    state.index = idx1;

     

       
94
       
 
       
    return;

     

       
95
       
 
       
  }

     

       
96
       
 
       


     

       
97
       
+
       
  var ln2 = node.length;

     

       
98
       
 
       


     

       
99
       
 
       
  alternation_3: {

     

       
100
       
 
       
    block_3: {

     

       
101
       
+
       
      var idx3 = state.index;

     

       
102
       
 
       


     

       
103
       
+
       
      if (x = _exec(state, _node_expression2)) {

     

       
104
       
+
       
        node.push(x);

     

       
105
       
 
       
      } else {

     

       
106
       
+
       
        state.index = idx3;

     

       
107
       
+
       
        node.length = ln2;

     

       
108
       
 
       
        break block_3;

     

       
109
       
 
       
      }

     

       
110
       
 
       


     

       
111
       
 
       
      break alternation_3;

     

       
112
       
 
       
    }

     

       
113
       
 
       


     

       
114
       
+
       
    loop_3: for (var j3 = 0; 1; j3++) {

     

       
115
       
+
       
      var idx3 = state.index;

     

       
116
       
 
       


     

       
117
       
 
       
      if (!_exec(state, _node_expression3)) {

     

       
118
       
+
       
        if (j3) {

     

       
119
       
+
       
          state.index = idx3;

     

       
120
       
 
       
          break loop_3;

     

       
121
       
 
       
        } else {}

     

       
122
       
 
       


     

       
123
       
+
       
        state.index = idx1;

     

       
124
       
+
       
        node.length = ln2;

     

       
125
       
 
       
        return;

     

       
126
       
 
       
      }

     

       
127
       
 
       
    }

     
···

       
136
       
 
       
"import { match, tag, _exec, _pattern } from 'reghex';

     

       
137
       
 
       


     

       
138
       
 
       
const inner = function (state) {

     

       
139
       
+
       
  var idx1 = state.index;

     

       
140
       
 
       
  var node = [];

     

       
141
       
+
       
  var x;

     

       
142
       
 
       


     

       
143
       
+
       
  if (x = node(state)) {

     

       
144
       
+
       
    node.push(x);

     

       
145
       
 
       
  } else {

     

       
146
       
+
       
    state.index = idx1;

     

       
147
       
 
       
    return;

     

       
148
       
 
       
  }

     

       
149
       
 
       


     
···

       
152
       
 
       
};

     

       
153
       
 
       


     

       
154
       
 
       
const node = function (state) {

     

       
155
       
+
       
  var idx1 = state.index;

     

       
156
       
 
       
  var node = [];

     

       
157
       
+
       
  var x;

     

       
158
       
 
       


     

       
159
       
+
       
  if (x = inner(state)) {

     

       
160
       
+
       
    node.push(x);

     

       
161
       
 
       
  } else {

     

       
162
       
+
       
    state.index = idx1;

     

       
163
       
 
       
    return;

     

       
164
       
 
       
  }

     

       
165
       
 
       


     
···

       
178
       
 
       
    _node_expression5 = _pattern(5);

     

       
179
       
 
       


     

       
180
       
 
       
const node = function (state) {

     

       
181
       
+
       
  var idx1 = state.index;

     

       
182
       
 
       
  var node = [];

     

       
183
       
+
       
  var x;

     

       
184
       
 
       


     

       
185
       
 
       
  alternation_2: {

     

       
186
       
 
       
    block_2: {

     

       
187
       
+
       
      var idx2 = state.index;

     

       
188
       
 
       


     

       
189
       
+
       
      loop_2: for (var j2 = 0; 1; j2++) {

     

       
190
       
+
       
        var idx2 = state.index;

     

       
191
       
 
       


     

       
192
       
+
       
        if (x = _exec(state, _node_expression)) {

     

       
193
       
+
       
          node.push(x);

     

       
194
       
 
       
        } else {

     

       
195
       
+
       
          if (j2) {

     

       
196
       
+
       
            state.index = idx2;

     

       
197
       
 
       
            break loop_2;

     

       
198
       
 
       
          } else {}

     

       
199
       
 
       


     

       
200
       
+
       
          state.index = idx2;

     

       
201
       
 
       
          break block_2;

     

       
202
       
 
       
        }

     

       
203
       
 
       
      }

     
···

       
205
       
 
       
      break alternation_2;

     

       
206
       
 
       
    }

     

       
207
       
 
       


     

       
208
       
+
       
    loop_2: for (var j2 = 0; 1; j2++) {

     

       
209
       
+
       
      var idx2 = state.index;

     

       
210
       
 
       


     

       
211
       
+
       
      if (x = _exec(state, _node_expression2)) {

     

       
212
       
+
       
        node.push(x);

     

       
213
       
 
       
      } else {

     

       
214
       
+
       
        if (j2) {

     

       
215
       
+
       
          state.index = idx2;

     

       
216
       
 
       
          break loop_2;

     

       
217
       
 
       
        } else {}

     

       
218
       
 
       


     

       
219
       
+
       
        state.index = idx1;

     

       
220
       
 
       
        return;

     

       
221
       
 
       
      }

     

       
222
       
 
       
    }

     

       
223
       
 
       


     

       
224
       
+
       
    loop_2: for (;;) {

     

       
225
       
+
       
      var idx2 = state.index;

     

       
226
       
+
       
      var ln2 = node.length;

     

       
227
       
 
       


     

       
228
       
+
       
      if (x = _exec(state, _node_expression3)) {

     

       
229
       
+
       
        node.push(x);

     

       
230
       
 
       
      } else {

     

       
231
       
+
       
        state.index = idx2;

     

       
232
       
+
       
        node.length = ln2;

     

       
233
       
 
       
        break loop_2;

     

       
234
       
 
       
      }

     

       
235
       
 
       


     

       
236
       
+
       
      var idx4 = state.index;

     

       
237
       
 
       


     

       
238
       
+
       
      if (x = _exec(state, _node_expression4)) {

     

       
239
       
+
       
        node.push(x);

     

       
240
       
 
       
      } else {

     

       
241
       
+
       
        state.index = idx4;

     

       
242
       
 
       
      }

     

       
243
       
 
       


     

       
244
       
+
       
      if (x = _exec(state, _node_expression5)) {

     

       
245
       
+
       
        node.push(x);

     

       
246
       
 
       
      } else {

     

       
247
       
+
       
        state.index = idx2;

     

       
248
       
+
       
        node.length = ln2;

     

       
249
       
 
       
        break loop_2;

     

       
250
       
 
       
      }

     

       
251
       
 
       
    }

     
···

       
262
       
 
       
var _inner_transform = x => x;

     

       
263
       
 
       


     

       
264
       
 
       
const first = function (state) {

     

       
265
       
+
       
  var idx1 = state.index;

     

       
266
       
 
       
  var node = [];

     

       
267
       
+
       
  var x;

     

       
268
       
 
       
  node.tag = 'inner';

     

       
269
       
 
       
  return _inner_transform(node);

     

       
270
       
 
       
};

     
···

       
272
       
 
       
const transform = x => x;

     

       
273
       
 
       


     

       
274
       
 
       
const second = function (state) {

     

       
275
       
+
       
  var idx1 = state.index;

     

       
276
       
 
       
  var node = [];

     

       
277
       
+
       
  var x;

     

       
278
       
 
       
  node.tag = 'node';

     

       
279
       
 
       
  return transform(node);

     

       
280
       
 
       
};"

     

···

       
1
       
 
       
const _state = 'state';

     

       
2
       
-
       
const _match = 'match';

     

       
3
       
 
       
const _node = 'node';

     

       
0
       
 
       

     

       
4
       
 
       


     

       
5
       
 
       
function js(/* arguments */) {

     

       
6
       
 
       
  let body = arguments[0][0];

     
···

       
16
       
 
       
};

     

       
17
       
 
       


     

       
18
       
 
       
const assignIndex = (depth) =>

     

       
19
       
-
       
  depth ? js`var index_${depth} = ${_state}.index;` : '';

     

       
20
       
 
       


     

       
21
       
 
       
const restoreIndex = (depth) =>

     

       
22
       
-
       
  depth ? js`${_state}.index = index_${depth};` : '';

     

       
23
       
 
       


     

       
24
       
 
       
const abortOnCondition = (condition, hooks) => js`

     

       
25
       
 
       
  if (${condition}) {

     

       
26
       
 
       
    ${restoreIndex(opts.index)}

     

       
27
       
-
       
    ${opts.abort || ''}

     

       
28
       
 
       
  } else {

     

       
29
       
-
       
    ${opts.onAbort || ''}

     

       
30
       
 
       
  }

     

       
31
       
 
       
`;

     

       
32
       
 
       


     

       
33
       
 
       
const astExpression = (ast, depth, opts) => {

     

       
34
       
 
       
  const restoreLength =

     

       
35
       
-
       
    opts.length &&

     

       
36
       
-
       
    opts.abort &&

     

       
37
       
-
       
    js`

     

       
38
       
-
       
    ${_node}.length = length_${opts.length};

     

       
39
       
-
       
  `;

     

       
40
       
 
       


     

       
41
       
 
       
  const abort = js`

     

       
42
       
-
       
    ${opts.onAbort || ''}

     

       
43
       
 
       
    ${restoreIndex(opts.index)}

     

       
44
       
-
       
    ${restoreLength || ''}

     

       
45
       
-
       
    ${opts.abort || ''}

     

       
46
       
 
       
  `;

     

       
47
       
 
       


     

       
48
       
 
       
  if (!opts.capture) {

     
···

       
72
       
 
       
  if (!opts.length && capture) {

     

       
73
       
 
       
    opts.length = depth;

     

       
74
       
 
       
    return js`

     

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

     

       
76
       
 
       
      ${astSequence(ast.sequence, depth + 1, opts)}

     

       
77
       
 
       
    `;

     

       
78
       
 
       
  }

     
···

       
85
       
 
       


     

       
86
       
 
       
const astQuantifier = (ast, depth, opts) => {

     

       
87
       
 
       
  const { index, abort, onAbort } = opts;

     

       
88
       
-
       
  const invert = `invert_${depth}`;

     

       
89
       
 
       
  const loop = `loop_${depth}`;

     

       
90
       
-
       
  const count = `count_${depth}`;

     

       
91
       
 
       


     

       
92
       
 
       
  opts = copy(opts);

     

       
93
       
 
       
  if (ast.capture === '!') {

     
···

       
107
       
 
       
    `;

     

       
108
       
 
       


     

       
109
       
 
       
    child = js`

     

       
110
       
-
       
      ${loop}: for (var ${count} = 0; true; ${count}++) {

     

       
111
       
 
       
        ${assignIndex(depth)}

     

       
112
       
 
       
        ${astChild(ast, depth, opts)}

     

       
113
       
 
       
      }

     
···

       
119
       
 
       
    opts.onAbort = '';

     

       
120
       
 
       


     

       
121
       
 
       
    child = js`

     

       
122
       
-
       
      ${loop}: while (true) {

     

       
123
       
 
       
        ${assignIndex(depth)}

     

       
124
       
 
       
        ${astChild(ast, depth, opts)}

     

       
125
       
 
       
      }

     

···

       
1
       
 
       
const _state = 'state';

     

       
0
       
 
       

     

       
2
       
 
       
const _node = 'node';

     

       
3
       
+
       
const _match = 'x';

     

       
4
       
 
       


     

       
5
       
 
       
function js(/* arguments */) {

     

       
6
       
 
       
  let body = arguments[0][0];

     
···

       
16
       
 
       
};

     

       
17
       
 
       


     

       
18
       
 
       
const assignIndex = (depth) =>

     

       
19
       
+
       
  depth ? js`var idx${depth} = ${_state}.index;` : '';

     

       
20
       
 
       


     

       
21
       
 
       
const restoreIndex = (depth) =>

     

       
22
       
+
       
  depth ? js`${_state}.index = idx${depth};` : '';

     

       
23
       
 
       


     

       
24
       
 
       
const abortOnCondition = (condition, hooks) => js`

     

       
25
       
 
       
  if (${condition}) {

     

       
26
       
 
       
    ${restoreIndex(opts.index)}

     

       
27
       
+
       
    ${opts.abort}

     

       
28
       
 
       
  } else {

     

       
29
       
+
       
    ${opts.onAbort}

     

       
30
       
 
       
  }

     

       
31
       
 
       
`;

     

       
32
       
 
       


     

       
33
       
 
       
const astExpression = (ast, depth, opts) => {

     

       
34
       
 
       
  const restoreLength =

     

       
35
       
+
       
    (opts.length && opts.abort && js`${_node}.length = ln${opts.length};`) ||

     

       
36
       
+
       
    '';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       


     

       
38
       
 
       
  const abort = js`

     

       
39
       
+
       
    ${opts.onAbort}

     

       
40
       
 
       
    ${restoreIndex(opts.index)}

     

       
41
       
+
       
    ${restoreLength}

     

       
42
       
+
       
    ${opts.abort}

     

       
43
       
 
       
  `;

     

       
44
       
 
       


     

       
45
       
 
       
  if (!opts.capture) {

     
···

       
69
       
 
       
  if (!opts.length && capture) {

     

       
70
       
 
       
    opts.length = depth;

     

       
71
       
 
       
    return js`

     

       
72
       
+
       
      ${js`var ln${depth} = ${_node}.length;`}

     

       
73
       
 
       
      ${astSequence(ast.sequence, depth + 1, opts)}

     

       
74
       
 
       
    `;

     

       
75
       
 
       
  }

     
···

       
82
       
 
       


     

       
83
       
 
       
const astQuantifier = (ast, depth, opts) => {

     

       
84
       
 
       
  const { index, abort, onAbort } = opts;

     

       
85
       
+
       
  const invert = `inv_${depth}`;

     

       
86
       
 
       
  const loop = `loop_${depth}`;

     

       
87
       
+
       
  const count = `j${depth}`;

     

       
88
       
 
       


     

       
89
       
 
       
  opts = copy(opts);

     

       
90
       
 
       
  if (ast.capture === '!') {

     
···

       
104
       
 
       
    `;

     

       
105
       
 
       


     

       
106
       
 
       
    child = js`

     

       
107
       
+
       
      ${loop}: for (var ${count} = 0; 1; ${count}++) {

     

       
108
       
 
       
        ${assignIndex(depth)}

     

       
109
       
 
       
        ${astChild(ast, depth, opts)}

     

       
110
       
 
       
      }

     
···

       
116
       
 
       
    opts.onAbort = '';

     

       
117
       
 
       


     

       
118
       
 
       
    child = js`

     

       
119
       
+
       
      ${loop}: for (;;) {

     

       
120
       
 
       
        ${assignIndex(depth)}

     

       
121
       
 
       
        ${astChild(ast, depth, opts)}

     

       
122
       
 
       
      }