···

       
68
       
 
       


     

       
69
       
 
       
var _reghex = require(\\"reghex\\");

     

       
70
       
 
       


     

       
71
       
-
       
var _node_expression = _reghex.__private.pattern(1),

     

       
72
       
-
       
    _node_expression2 = _reghex.__private.pattern(2);

     

       
73
       
 
       


     

       
74
       
 
       
const node = function (state) {

     

       
75
       
 
       
  var y1 = state.y,

     
···

       
77
       
 
       
  var node = [];

     

       
78
       
 
       
  var x;

     

       
79
       
 
       


     

       
80
       
-
       
  if (x = _reghex.__private.exec(state, _node_expression)) {

     

       
81
       
 
       
    node.push(x);

     

       
82
       
 
       
  } else {

     

       
83
       
 
       
    state.y = y1;

     
···

       
85
       
 
       
    return;

     

       
86
       
 
       
  }

     

       
87
       
 
       


     

       
88
       
-
       
  if (x = _reghex.__private.exec(state, _node_expression2)) {

     

       
89
       
 
       
    node.push(x);

     

       
90
       
 
       
  } else {

     

       
91
       
 
       
    state.y = y1;

     
···

       
104
       
 
       
`;

     

       
105
       
 
       


     

       
106
       
 
       
exports[`works with local recursion 1`] = `

     

       
107
       
-
       
"import { match as m, tag, __private } from 'reghex';

     

       
108
       
 
       


     

       
109
       
-
       
var _inner_expression = __private.pattern(/inner/);

     

       
110
       
 
       


     

       
111
       
 
       
const inner = function (state) {

     

       
112
       
 
       
  var y1 = state.y,

     
···

       
114
       
 
       
  var node = [];

     

       
115
       
 
       
  var x;

     

       
116
       
 
       


     

       
117
       
-
       
  if (x = __private.exec(state, _inner_expression)) {

     

       
118
       
 
       
    node.push(x);

     

       
119
       
 
       
  } else {

     

       
120
       
 
       
    state.y = y1;

     
···

       
132
       
 
       
  var node = [];

     

       
133
       
 
       
  var x;

     

       
134
       
 
       


     

       
135
       
-
       
  if (x = inner(state)) {

     

       
136
       
 
       
    node.push(x);

     

       
137
       
 
       
  } else {

     

       
138
       
 
       
    state.y = y1;

     
···

       
146
       
 
       
`;

     

       
147
       
 
       


     

       
148
       
 
       
exports[`works with non-capturing groups 1`] = `

     

       
149
       
-
       
"import { match, __private } from 'reghex';

     

       
150
       
 
       


     

       
151
       
-
       
var _node_expression = __private.pattern(1),

     

       
152
       
-
       
    _node_expression2 = __private.pattern(2),

     

       
153
       
-
       
    _node_expression3 = __private.pattern(3);

     

       
154
       
 
       


     

       
155
       
 
       
const node = function (state) {

     

       
156
       
 
       
  var y1 = state.y,

     
···

       
158
       
 
       
  var node = [];

     

       
159
       
 
       
  var x;

     

       
160
       
 
       


     

       
161
       
-
       
  if (x = __private.exec(state, _node_expression)) {

     

       
162
       
 
       
    node.push(x);

     

       
163
       
 
       
  } else {

     

       
164
       
 
       
    state.y = y1;

     
···

       
173
       
 
       
      var y3 = state.y,

     

       
174
       
 
       
          x3 = state.x;

     

       
175
       
 
       


     

       
176
       
-
       
      if (x = __private.exec(state, _node_expression2)) {

     

       
177
       
 
       
        node.push(x);

     

       
178
       
 
       
      } else {

     

       
179
       
 
       
        state.y = y3;

     
···

       
189
       
 
       
      var y3 = state.y,

     

       
190
       
 
       
          x3 = state.x;

     

       
191
       
 
       


     

       
192
       
-
       
      if (x = __private.exec(state, _node_expression3)) {} else {

     

       
193
       
 
       
        if (j3) {

     

       
194
       
 
       
          state.y = y3;

     

       
195
       
 
       
          state.x = x3;

     
···

       
210
       
 
       
`;

     

       
211
       
 
       


     

       
212
       
 
       
exports[`works with self-referential thunks 1`] = `

     

       
213
       
-
       
"import { match, tag, __private } from 'reghex';

     

       
214
       
 
       


     

       
215
       
 
       
const inner = function (state) {

     

       
216
       
 
       
  var y1 = state.y,

     
···

       
218
       
 
       
  var node = [];

     

       
219
       
 
       
  var x;

     

       
220
       
 
       


     

       
221
       
-
       
  if (x = node(state)) {

     

       
222
       
 
       
    node.push(x);

     

       
223
       
 
       
  } else {

     

       
224
       
 
       
    state.y = y1;

     
···

       
236
       
 
       
  var node = [];

     

       
237
       
 
       
  var x;

     

       
238
       
 
       


     

       
239
       
-
       
  if (x = inner(state)) {

     

       
240
       
 
       
    node.push(x);

     

       
241
       
 
       
  } else {

     

       
242
       
 
       
    state.y = y1;

     
···

       
250
       
 
       
`;

     

       
251
       
 
       


     

       
252
       
 
       
exports[`works with standard features 1`] = `

     

       
253
       
-
       
"import { match, __private } from \\"reghex\\";

     

       
254
       
 
       


     

       
255
       
-
       
var _node_expression = __private.pattern(1),

     

       
256
       
-
       
    _node_expression2 = __private.pattern(2),

     

       
257
       
-
       
    _node_expression3 = __private.pattern(3),

     

       
258
       
-
       
    _node_expression4 = __private.pattern(4),

     

       
259
       
-
       
    _node_expression5 = __private.pattern(5);

     

       
260
       
 
       


     

       
261
       
 
       
const node = function (state) {

     

       
262
       
 
       
  var y1 = state.y,

     
···

       
273
       
 
       
        var y2 = state.y,

     

       
274
       
 
       
            x2 = state.x;

     

       
275
       
 
       


     

       
276
       
-
       
        if (x = __private.exec(state, _node_expression)) {

     

       
277
       
 
       
          node.push(x);

     

       
278
       
 
       
        } else {

     

       
279
       
 
       
          if (j2) {

     
···

       
295
       
 
       
      var y2 = state.y,

     

       
296
       
 
       
          x2 = state.x;

     

       
297
       
 
       


     

       
298
       
-
       
      if (x = __private.exec(state, _node_expression2)) {

     

       
299
       
 
       
        node.push(x);

     

       
300
       
 
       
      } else {

     

       
301
       
 
       
        if (j2) {

     
···

       
315
       
 
       
          x2 = state.x;

     

       
316
       
 
       
      var ln2 = node.length;

     

       
317
       
 
       


     

       
318
       
-
       
      if (x = __private.exec(state, _node_expression3)) {

     

       
319
       
 
       
        node.push(x);

     

       
320
       
 
       
      } else {

     

       
321
       
 
       
        state.y = y2;

     
···

       
327
       
 
       
      var y4 = state.y,

     

       
328
       
 
       
          x4 = state.x;

     

       
329
       
 
       


     

       
330
       
-
       
      if (x = __private.exec(state, _node_expression4)) {

     

       
331
       
 
       
        node.push(x);

     

       
332
       
 
       
      } else {

     

       
333
       
 
       
        state.y = y4;

     

       
334
       
 
       
        state.x = x4;

     

       
335
       
 
       
      }

     

       
336
       
 
       


     

       
337
       
-
       
      if (x = __private.exec(state, _node_expression5)) {

     

       
338
       
 
       
        node.push(x);

     

       
339
       
 
       
      } else {

     

       
340
       
 
       
        state.y = y2;

     
···

       
351
       
 
       
`;

     

       
352
       
 
       


     

       
353
       
 
       
exports[`works with transform functions 1`] = `

     

       
354
       
-
       
"import { match, __private } from 'reghex';

     

       
355
       
 
       


     

       
356
       
 
       
var _inner_transform = x => x;

     

       
357
       
 
       


     

···

       
68
       
 
       


     

       
69
       
 
       
var _reghex = require(\\"reghex\\");

     

       
70
       
 
       


     

       
71
       
+
       
var _node_expression = (0, _reghex.__pattern)(1),

     

       
72
       
+
       
    _node_expression2 = (0, _reghex.__pattern)(2);

     

       
73
       
 
       


     

       
74
       
 
       
const node = function (state) {

     

       
75
       
 
       
  var y1 = state.y,

     
···

       
77
       
 
       
  var node = [];

     

       
78
       
 
       
  var x;

     

       
79
       
 
       


     

       
80
       
+
       
  if ((x = _node_expression(state)) != null) {

     

       
81
       
 
       
    node.push(x);

     

       
82
       
 
       
  } else {

     

       
83
       
 
       
    state.y = y1;

     
···

       
85
       
 
       
    return;

     

       
86
       
 
       
  }

     

       
87
       
 
       


     

       
88
       
+
       
  if ((x = _node_expression2(state)) != null) {

     

       
89
       
 
       
    node.push(x);

     

       
90
       
 
       
  } else {

     

       
91
       
 
       
    state.y = y1;

     
···

       
104
       
 
       
`;

     

       
105
       
 
       


     

       
106
       
 
       
exports[`works with local recursion 1`] = `

     

       
107
       
+
       
"import { match as m, tag, __pattern as _pattern } from 'reghex';

     

       
108
       
 
       


     

       
109
       
+
       
var _inner_expression = _pattern(/inner/);

     

       
110
       
 
       


     

       
111
       
 
       
const inner = function (state) {

     

       
112
       
 
       
  var y1 = state.y,

     
···

       
114
       
 
       
  var node = [];

     

       
115
       
 
       
  var x;

     

       
116
       
 
       


     

       
117
       
+
       
  if ((x = _inner_expression(state)) != null) {

     

       
118
       
 
       
    node.push(x);

     

       
119
       
 
       
  } else {

     

       
120
       
 
       
    state.y = y1;

     
···

       
132
       
 
       
  var node = [];

     

       
133
       
 
       
  var x;

     

       
134
       
 
       


     

       
135
       
+
       
  if ((x = inner(state)) != null) {

     

       
136
       
 
       
    node.push(x);

     

       
137
       
 
       
  } else {

     

       
138
       
 
       
    state.y = y1;

     
···

       
146
       
 
       
`;

     

       
147
       
 
       


     

       
148
       
 
       
exports[`works with non-capturing groups 1`] = `

     

       
149
       
+
       
"import { match, __pattern as _pattern } from 'reghex';

     

       
150
       
 
       


     

       
151
       
+
       
var _node_expression = _pattern(1),

     

       
152
       
+
       
    _node_expression2 = _pattern(2),

     

       
153
       
+
       
    _node_expression3 = _pattern(3);

     

       
154
       
 
       


     

       
155
       
 
       
const node = function (state) {

     

       
156
       
 
       
  var y1 = state.y,

     
···

       
158
       
 
       
  var node = [];

     

       
159
       
 
       
  var x;

     

       
160
       
 
       


     

       
161
       
+
       
  if ((x = _node_expression(state)) != null) {

     

       
162
       
 
       
    node.push(x);

     

       
163
       
 
       
  } else {

     

       
164
       
 
       
    state.y = y1;

     
···

       
173
       
 
       
      var y3 = state.y,

     

       
174
       
 
       
          x3 = state.x;

     

       
175
       
 
       


     

       
176
       
+
       
      if ((x = _node_expression2(state)) != null) {

     

       
177
       
 
       
        node.push(x);

     

       
178
       
 
       
      } else {

     

       
179
       
 
       
        state.y = y3;

     
···

       
189
       
 
       
      var y3 = state.y,

     

       
190
       
 
       
          x3 = state.x;

     

       
191
       
 
       


     

       
192
       
+
       
      if ((x = _node_expression3(state)) != null) {} else {

     

       
193
       
 
       
        if (j3) {

     

       
194
       
 
       
          state.y = y3;

     

       
195
       
 
       
          state.x = x3;

     
···

       
210
       
 
       
`;

     

       
211
       
 
       


     

       
212
       
 
       
exports[`works with self-referential thunks 1`] = `

     

       
213
       
+
       
"import { match, tag, __pattern as _pattern } from 'reghex';

     

       
214
       
 
       


     

       
215
       
 
       
const inner = function (state) {

     

       
216
       
 
       
  var y1 = state.y,

     
···

       
218
       
 
       
  var node = [];

     

       
219
       
 
       
  var x;

     

       
220
       
 
       


     

       
221
       
+
       
  if ((x = node(state)) != null) {

     

       
222
       
 
       
    node.push(x);

     

       
223
       
 
       
  } else {

     

       
224
       
 
       
    state.y = y1;

     
···

       
236
       
 
       
  var node = [];

     

       
237
       
 
       
  var x;

     

       
238
       
 
       


     

       
239
       
+
       
  if ((x = inner(state)) != null) {

     

       
240
       
 
       
    node.push(x);

     

       
241
       
 
       
  } else {

     

       
242
       
 
       
    state.y = y1;

     
···

       
250
       
 
       
`;

     

       
251
       
 
       


     

       
252
       
 
       
exports[`works with standard features 1`] = `

     

       
253
       
+
       
"import { match, __pattern as _pattern } from \\"reghex\\";

     

       
254
       
 
       


     

       
255
       
+
       
var _node_expression = _pattern(1),

     

       
256
       
+
       
    _node_expression2 = _pattern(2),

     

       
257
       
+
       
    _node_expression3 = _pattern(3),

     

       
258
       
+
       
    _node_expression4 = _pattern(4),

     

       
259
       
+
       
    _node_expression5 = _pattern(5);

     

       
260
       
 
       


     

       
261
       
 
       
const node = function (state) {

     

       
262
       
 
       
  var y1 = state.y,

     
···

       
273
       
 
       
        var y2 = state.y,

     

       
274
       
 
       
            x2 = state.x;

     

       
275
       
 
       


     

       
276
       
+
       
        if ((x = _node_expression(state)) != null) {

     

       
277
       
 
       
          node.push(x);

     

       
278
       
 
       
        } else {

     

       
279
       
 
       
          if (j2) {

     
···

       
295
       
 
       
      var y2 = state.y,

     

       
296
       
 
       
          x2 = state.x;

     

       
297
       
 
       


     

       
298
       
+
       
      if ((x = _node_expression2(state)) != null) {

     

       
299
       
 
       
        node.push(x);

     

       
300
       
 
       
      } else {

     

       
301
       
 
       
        if (j2) {

     
···

       
315
       
 
       
          x2 = state.x;

     

       
316
       
 
       
      var ln2 = node.length;

     

       
317
       
 
       


     

       
318
       
+
       
      if ((x = _node_expression3(state)) != null) {

     

       
319
       
 
       
        node.push(x);

     

       
320
       
 
       
      } else {

     

       
321
       
 
       
        state.y = y2;

     
···

       
327
       
 
       
      var y4 = state.y,

     

       
328
       
 
       
          x4 = state.x;

     

       
329
       
 
       


     

       
330
       
+
       
      if ((x = _node_expression4(state)) != null) {

     

       
331
       
 
       
        node.push(x);

     

       
332
       
 
       
      } else {

     

       
333
       
 
       
        state.y = y4;

     

       
334
       
 
       
        state.x = x4;

     

       
335
       
 
       
      }

     

       
336
       
 
       


     

       
337
       
+
       
      if ((x = _node_expression5(state)) != null) {

     

       
338
       
 
       
        node.push(x);

     

       
339
       
 
       
      } else {

     

       
340
       
 
       
        state.y = y2;

     
···

       
351
       
 
       
`;

     

       
352
       
 
       


     

       
353
       
 
       
exports[`works with transform functions 1`] = `

     

       
354
       
+
       
"import { match, __pattern as _pattern } from 'reghex';

     

       
355
       
 
       


     

       
356
       
 
       
var _inner_transform = x => x;

     

       
357
       
 
       


     

···

       
34
       
 
       
  ).toMatchSnapshot();

     

       
35
       
 
       
});

     

       
36
       
 
       


     

       
37
       
-
       
it.only('deduplicates hoisted expressions', () => {

     

       
38
       
 
       
  const code = `

     

       
39
       
 
       
    import { match } from 'reghex/macro';

     

       
40
       
 
       


     

···

       
34
       
 
       
  ).toMatchSnapshot();

     

       
35
       
 
       
});

     

       
36
       
 
       


     

       
37
       
+
       
it('deduplicates hoisted expressions', () => {

     

       
38
       
 
       
  const code = `

     

       
39
       
 
       
    import { match } from 'reghex/macro';

     

       
40