commit c5cf8d179e02fce12e652782f46e00f9bc1d6bbe · kitten.sh/reghex

+47 -18

README.md

···

       10
       10
        
         <br />

     

       11
       11
        
       </div>

     

       12
       12
        
       

     

       13
       13
       -
       Leveraging the power of sticky regexes and Babel code generation, `reghex` allows

     

       13
       13
       +
       Leveraging the power of sticky regexes and JS code generation, `reghex` allows

     

       14
       14
        
       you to code parsers quickly, by surrounding regular expressions with a regex-like

     

       15
       15
        
       [DSL](https://en.wikipedia.org/wiki/Domain-specific_language).

     

       16
       16
        
       

     
···

       30
       30
        
       npm install --save reghex

     

       31
       31
        
       ```

     

       32
       32
        
       

     

       33
       33
       -
       ##### 2. Add the plugin to your Babel configuration (`.babelrc`, `babel.config.js`, or `package.json:babel`)

     

       33
       33
       +
       ##### 2. Add the plugin to your Babel configuration _(optional)_

     

       34
       34
       +
       

     

       35
       35
       +
       In your `.babelrc`, `babel.config.js`, or `package.json:babel` add:

     

       34
       36
        
       

     

       35
       37
        
       ```json

     

       36
       38
        
       {

     
···

       41
       43
        
       Alternatively, you can set up [`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros) and

     

       42
       44
        
       import `reghex` from `"reghex/macro"` instead.

     

       43
       45
        
       

     

       46
       46
       +
       This step is **optional**. `reghex` can also generate its optimised JS code during runtime.

     

       47
       47
       +
       This will only incur a tiny parsing cost on initialisation, but due to the JIT of modern

     

       48
       48
       +
       JS engines there won't be any difference in performance between pre-compiled and compiled

     

       49
       49
       +
       versions otherwise.

     

       50
       50
       +
       

     

       51
       51
       +
       Since the `reghex` runtime is rather small, for larger grammars it may even make sense not

     

       52
       52
       +
       to precompile the matchers at all. For this case you may pass the `{ "codegen": false }`

     

       53
       53
       +
       option to the Babel plugin, which will minify the `reghex` matcher templates without

     

       54
       54
       +
       precompiling them.

     

       55
       55
       +
       

     

       44
       56
        
       ##### 3. Have fun writing parsers!

     

       45
       57
        
       

     

       46
       58
        
       ```js

     

       47
       47
       -
       import match, { parse } from 'reghex';

     

       59
       59
       +
       import { match, parse } from 'reghex';

     

       48
       60
        
       

     

       49
       61
        
       const name = match('name')`

     

       50
       62
        
         ${/\w+/}

     
···

       99
       111
        
       

     

       100
       112
        
       ## Authoring Guide

     

       101
       113
        
       

     

       102
       102
       -
       You can write "matchers" by importing the default import from `reghex` and

     

       114
       114
       +
       You can write "matchers" by importing the `match` import from `reghex` and

     

       103
       115
        
       using it to write a matcher expression.

     

       104
       116
        
       

     

       105
       117
        
       ```js

     

       106
       106
       -
       import match from 'reghex';

     

       118
       118
       +
       import { match } from 'reghex';

     

       107
       119
        
       

     

       108
       120
        
       const name = match('name')`

     

       109
       121
        
         ${/\w+/}

     

       110
       122
        
       `;

     

       111
       123
        
       ```

     

       112
       124
        
       

     

       113
       113
       -
       As can be seen above, the `match` function, which is what we've called the

     

       114
       114
       -
       default import, is called with a "node name" and is then called as a tagged

     

       115
       115
       -
       template. This template is our **parsing definition**.

     

       125
       125
       +
       As can be seen above, the `match` function, is called with a "node name" and

     

       126
       126
       +
       is then called as a tagged template. This template is our **parsing definition**.

     

       116
       127
        
       

     

       117
       128
        
       `reghex` functions only with its Babel plugin, which will detect `match('name')`

     

       118
       129
        
       and replace the entire tag with a parsing function, which may then look like

     
···

       161
       172
        
       Let's extend our original example;

     

       162
       173
        
       

     

       163
       174
        
       ```js

     

       164
       164
       -
       import match from 'reghex';

     

       175
       175
       +
       import { match } from 'reghex';

     

       165
       176
        
       

     

       166
       177
        
       const name = match('name')`

     

       167
       178
        
         ${/\w+/}

     
···

       193
       204
        
       */

     

       194
       205
        
       ```

     

       195
       206
        
       

     

       207
       207
       +
       Furthermore, interpolations don't have to just be RegHex matchers. They can

     

       208
       208
       +
       also be functions returning matchers or completely custom matching functions.

     

       209
       209
       +
       This is useful when your DSL becomes _self-referential_, i.e. when one matchers

     

       210
       210
       +
       start referencing each other forming a loop. To fix this we can create a

     

       211
       211
       +
       function that returns our root matcher:

     

       212
       212
       +
       

     

       213
       213
       +
       ```js

     

       214
       214
       +
       import { match } from 'reghex';

     

       215
       215
       +
       

     

       216
       216
       +
       const value = match('value')`

     

       217
       217
       +
         (${/\w+/} | ${() => root})+

     

       218
       218
       +
       `;

     

       219
       219
       +
       

     

       220
       220
       +
       const root = match('root')`

     

       221
       221
       +
         ${/root/}+ ${value}

     

       222
       222
       +
       `;

     

       223
       223
       +
       ```

     

       224
       224
       +
       

     

       196
       225
        
       ### Regex-like DSL

     

       197
       226
        
       

     

       198
       227
        
       We've seen in the previous examples that matchers are authored using tagged

     
···

       208
       237
        
       in the parsed string. This is just one feature of the regex-like DSL. The

     

       209
       238
        
       available operators are the following:

     

       210
       239
        
       

     

       211
       211
       -
       | Operator | Example            | Description                                                                                                                                                                                           |

     

       212
       212
       -
       | -------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

     

       213
       213
       -
       | `?`      | `${/1/}?`          | An **optional** may be used to make an interpolation optional. This means that the interpolation may or may not match.                                                                            |

     

       214
       214
       -
       | `*`      | `${/1/}*`          | A **star** can be used to match an arbitrary amount of interpolation or none at all. This means that the interpolation may repeat itself or may not be matched at all.                            |

     

       215
       215
       -
       | `+`      | `${/1/}+`          | A **plus** is used like `*` and must match one or more times. When the matcher doesn't match, that's considered a failing case, since the match isn't optional.                                       |

     

       216
       216
       -
       | `\|`     | `${/1/} \| ${/2/}` | An **alternation** can be used to match either one thing or another, falling back when the first interpolation fails.                                                                                 |

     

       217
       217
       -
       | `()`     | `(${/1/} ${/2/})+` | A **group** can be used to apply one of the other operators to an entire group of interpolations.                                                                                                        |

     

       240
       240
       +
       | Operator | Example            | Description                                                                                                                                                                              |

     

       241
       241
       +
       | -------- | ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

     

       242
       242
       +
       | `?`      | `${/1/}?`          | An **optional** may be used to make an interpolation optional. This means that the interpolation may or may not match.                                                                   |

     

       243
       243
       +
       | `*`      | `${/1/}*`          | A **star** can be used to match an arbitrary amount of interpolation or none at all. This means that the interpolation may repeat itself or may not be matched at all.                   |

     

       244
       244
       +
       | `+`      | `${/1/}+`          | A **plus** is used like `*` and must match one or more times. When the matcher doesn't match, that's considered a failing case, since the match isn't optional.                          |

     

       245
       245
       +
       | `\|`     | `${/1/} \| ${/2/}` | An **alternation** can be used to match either one thing or another, falling back when the first interpolation fails.                                                                    |

     

       246
       246
       +
       | `()`     | `(${/1/} ${/2/})+` | A **group** can be used to apply one of the other operators to an entire group of interpolations.                                                                                        |

     

       218
       247
        
       | `(?: )`  | `(?: ${/1/})`      | A **non-capturing group** is like a regular group, but the interpolations matched inside it don't appear in the parser's output.                                                         |

     

       219
       219
       -
       | `(?= )`  | `(?= ${/1/})`      | A **positive lookahead** checks whether interpolations match, and if so continues the matcher without changing the input. If it matches, it's essentially ignored.                             |

     

       248
       248
       +
       | `(?= )`  | `(?= ${/1/})`      | A **positive lookahead** checks whether interpolations match, and if so continues the matcher without changing the input. If it matches, it's essentially ignored.                       |

     

       220
       249
        
       | `(?! )`  | `(?! ${/1/})`      | A **negative lookahead** checks whether interpolations _don't_ match, and if so continues the matcher without changing the input. If the interpolations do match the matcher is aborted. |

     

       221
       250
        
       

     

       222
       251
        
       We can combine and compose these operators to create more complex matchers.

     
···

       320
       349
        
       matched, which would cause other matchers to treat it like a mismatch!

     

       321
       350
        
       

     

       322
       351
        
       ```js

     

       323
       323
       -
       import match, { parse } from 'reghex';

     

       352
       352
       +
       import { match, parse } from 'reghex';

     

       324
       353
        
       

     

       325
       354
        
       const name = match('name')((x) => {

     

       326
       355
        
         return x[0] !== 'tim' ? x : undefined;

+3 -2

package.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "reghex",

     

       3
       3
       -
         "version": "1.0.2",

     

       3
       3
       +
         "version": "2.0.0-beta.4",

     

       4
       4
        
         "description": "The magical sticky regex-based parser generator 🧙",

     

       5
       5
        
         "author": "Phil Pluckthun <phil@kitten.sh>",

     

       6
       6
        
         "license": "MIT",

     
···

       48
       48
        
           "url": "https://github.com/kitten/reghex/issues"

     

       49
       49
        
         },

     

       50
       50
        
         "devDependencies": {

     

       51
       51
       +
           "@ampproject/rollup-plugin-closure-compiler": "^0.26.0",

     

       51
       52
        
           "@babel/core": "7.9.6",

     

       52
       53
        
           "@babel/plugin-transform-modules-commonjs": "^7.9.6",

     

       53
       53
       -
           "@babel/plugin-transform-object-assign": "^7.8.3",

     

       54
       54
        
           "@rollup/plugin-buble": "^0.21.3",

     

       55
       55
        
           "@rollup/plugin-commonjs": "^11.1.0",

     

       56
       56
        
           "@rollup/plugin-node-resolve": "^7.1.3",

     

       57
       57
       +
           "@rollup/pluginutils": "^4.1.0",

     

       57
       58
        
           "babel-jest": "^26.0.1",

     

       58
       59
        
           "babel-plugin-closure-elimination": "^1.3.1",

     

       59
       60
        
           "husky": "^4.2.5",

+29 -12

rollup.config.js

···

       2
       2
        
       import resolve from '@rollup/plugin-node-resolve';

     

       3
       3
        
       import buble from '@rollup/plugin-buble';

     

       4
       4
        
       import babel from 'rollup-plugin-babel';

     

       5
       5
       +
       import compiler from '@ampproject/rollup-plugin-closure-compiler';

     

       6
       6
       +
       

     

       7
       7
       +
       import simplifyJSTags from './scripts/simplify-jstags-plugin.js';

     

       5
       8
        
       

     

       6
       9
        
       const plugins = [

     

       7
       10
        
         commonjs({

     
···

       18
       21
        
           transforms: {

     

       19
       22
        
             unicodeRegExp: false,

     

       20
       23
        
             dangerousForOf: true,

     

       21
       21
       -
             dangerousTaggedTemplateString: true,

     

       24
       24
       +
             templateString: false,

     

       22
       25
        
           },

     

       23
       23
       -
           objectAssign: 'Object.assign',

     

       24
       26
        
           exclude: 'node_modules/**',

     

       25
       27
        
         }),

     

       26
       28
        
         babel({

     
···

       28
       30
        
           extensions: ['ts', 'tsx', 'js'],

     

       29
       31
        
           exclude: 'node_modules/**',

     

       30
       32
        
           presets: [],

     

       31
       31
       -
           plugins: [

     

       32
       32
       -
             '@babel/plugin-transform-object-assign',

     

       33
       33
       -
             'babel-plugin-closure-elimination',

     

       34
       34
       -
           ],

     

       33
       33
       +
           plugins: ['babel-plugin-closure-elimination'],

     

       35
       34
        
         }),

     

       36
       35
        
       ];

     

       37
       36
        
       

     
···

       47
       46
        
         freeze: false,

     

       48
       47
        
         strict: false,

     

       49
       48
        
         format,

     

       49
       49
       +
         plugins: [

     

       50
       50
       +
           simplifyJSTags(),

     

       51
       51
       +
           compiler({

     

       52
       52
       +
             formatting: 'PRETTY_PRINT',

     

       53
       53
       +
             compilation_level: 'SIMPLE_OPTIMIZATIONS',

     

       54
       54
       +
           }),

     

       55
       55
       +
         ],

     

       50
       56
        
       });

     

       51
       57
        
       

     

       52
       52
       -
       export default {

     

       53
       53
       -
         input: {

     

       54
       54
       -
           core: './src/core.js',

     

       55
       55
       -
           babel: './src/babel/plugin.js',

     

       56
       56
       -
           macro: './src/babel/macro.js',

     

       57
       57
       -
         },

     

       58
       58
       +
       const base = {

     

       58
       59
        
         onwarn: () => {},

     

       59
       60
        
         external: () => false,

     

       60
       61
        
         treeshake: {

     
···

       63
       64
        
         plugins,

     

       64
       65
        
         output: [output('cjs', '.js'), output('esm', '.mjs')],

     

       65
       66
        
       };

     

       67
       67
       +
       

     

       68
       68
       +
       export default [

     

       69
       69
       +
         {

     

       70
       70
       +
           ...base,

     

       71
       71
       +
           input: {

     

       72
       72
       +
             core: './src/core.js',

     

       73
       73
       +
           },

     

       74
       74
       +
         },

     

       75
       75
       +
         {

     

       76
       76
       +
           ...base,

     

       77
       77
       +
           input: {

     

       78
       78
       +
             babel: './src/babel/plugin.js',

     

       79
       79
       +
             macro: './src/babel/macro.js',

     

       80
       80
       +
           },

     

       81
       81
       +
         },

     

       82
       82
       +
       ];

+54

scripts/simplify-jstags-plugin.js

···

       1
       1
       +
       import { transformSync as transform } from '@babel/core';

     

       2
       2
       +
       import { createFilter } from '@rollup/pluginutils';

     

       3
       3
       +
       

     

       4
       4
       +
       const simplifyJSTags = ({ types: t }) => ({

     

       5
       5
       +
         visitor: {

     

       6
       6
       +
           TaggedTemplateExpression(path) {

     

       7
       7
       +
             if (path.node.tag.name !== 'js') return;

     

       8
       8
       +
       

     

       9
       9
       +
             const expressions = path.node.quasi.expressions;

     

       10
       10
       +
       

     

       11
       11
       +
             const quasis = path.node.quasi.quasis.map((x) =>

     

       12
       12
       +
               x.value.cooked

     

       13
       13
       +
                 .replace(/\s*[=(){},;:!]\s*/g, (x) => x.trim())

     

       14
       14
       +
                 .replace(/\s+/g, ' ')

     

       15
       15
       +
                 .replace(/^\s+$/g, '')

     

       16
       16
       +
             );

     

       17
       17
       +
       

     

       18
       18
       +
             const concat = expressions.reduceRight(

     

       19
       19
       +
               (prev, node, i) =>

     

       20
       20
       +
                 t.binaryExpression(

     

       21
       21
       +
                   '+',

     

       22
       22
       +
                   t.stringLiteral(quasis[i]),

     

       23
       23
       +
                   t.binaryExpression('+', node, prev)

     

       24
       24
       +
                 ),

     

       25
       25
       +
               t.stringLiteral(quasis[quasis.length - 1])

     

       26
       26
       +
             );

     

       27
       27
       +
       

     

       28
       28
       +
             path.replaceWith(concat);

     

       29
       29
       +
           },

     

       30
       30
       +
         },

     

       31
       31
       +
       });

     

       32
       32
       +
       

     

       33
       33
       +
       function simplifyJSTagsPlugin(opts = {}) {

     

       34
       34
       +
         const filter = createFilter(opts.include, opts.exclude, {

     

       35
       35
       +
           resolve: false,

     

       36
       36
       +
         });

     

       37
       37
       +
       

     

       38
       38
       +
         return {

     

       39
       39
       +
           name: 'cleanup',

     

       40
       40
       +
       

     

       41
       41
       +
           renderChunk(code, chunk) {

     

       42
       42
       +
             if (!filter(chunk.fileName)) {

     

       43
       43
       +
               return null;

     

       44
       44
       +
             }

     

       45
       45
       +
       

     

       46
       46
       +
             return transform(code, {

     

       47
       47
       +
               plugins: [simplifyJSTags],

     

       48
       48
       +
               babelrc: false,

     

       49
       49
       +
             });

     

       50
       50
       +
           },

     

       51
       51
       +
         };

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       export default simplifyJSTagsPlugin;

+162 -110

src/babel/__snapshots__/plugin.test.js.snap

···

       8
       8
        
       var _node_expression = (0, _reghex._pattern)(1),

     

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

     

       10
       10
        
       

     

       11
       11
       -
       const node = function _node(state) {

     

       12
       12
       -
         var last_index = state.index;

     

       13
       13
       -
         var match,

     

       14
       14
       -
             node = [];

     

       11
       11
       +
       const node = function (state) {

     

       12
       12
       +
         var index_1 = state.index;

     

       13
       13
       +
         var node = [];

     

       14
       14
       +
         var match;

     

       15
       15
        
       

     

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

     

       17
       17
        
           node.push(match);

     

       18
       18
        
         } else {

     

       19
       19
       -
           state.index = last_index;

     

       19
       19
       +
           state.index = index_1;

     

       20
       20
        
           return;

     

       21
       21
        
         }

     

       22
       22
        
       

     

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

     

       24
       24
        
           node.push(match);

     

       25
       25
        
         } else {

     

       26
       26
       -
           state.index = last_index;

     

       26
       26
       +
           state.index = index_1;

     

       27
       27
        
           return;

     

       28
       28
        
         }

     

       29
       29
        
       

     

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

     

       30
       30
       +
         node.tag = 'node';

     

       31
       31
       +
         return node;

     

       31
       32
        
       };"

     

       32
       33
        
       `;

     

       33
       34
        
       

     

       35
       35
       +
       exports[`works while only minifying 1`] = `

     

       36
       36
       +
       "import { match } from 'reghex/macro';

     

       37
       37
       +
       const node = match('node')([\\"\\", \\"+|\\", \\"+(\\", \\"(\\", \\"?\\", \\"))*\\"], 1, 2, 3, 4, 5);"

     

       38
       38
       +
       `;

     

       39
       39
       +
       

     

       34
       40
        
       exports[`works with local recursion 1`] = `

     

       35
       35
       -
       "import { tag, _exec, _substr, _pattern } from 'reghex';

     

       41
       41
       +
       "import { match as m, tag, _exec, _pattern } from 'reghex';

     

       42
       42
       +
       

     

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

     

       36
       44
        
       

     

       37
       37
       -
       const inner = function _inner(state) {

     

       38
       38
       -
         var last_index = state.index;

     

       39
       39
       -
         var match,

     

       40
       40
       -
             node = [];

     

       45
       45
       +
       const inner = function (state) {

     

       46
       46
       +
         var index_1 = state.index;

     

       47
       47
       +
         var node = [];

     

       48
       48
       +
         var match;

     

       41
       49
        
       

     

       42
       42
       -
         if (match = _substr(state, \\"inner\\")) {

     

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

     

       43
       51
        
           node.push(match);

     

       44
       52
        
         } else {

     

       45
       45
       -
           state.index = last_index;

     

       53
       53
       +
           state.index = index_1;

     

       46
       54
        
           return;

     

       47
       55
        
         }

     

       48
       56
        
       

     

       49
       49
       -
         return tag(node, 'inner');

     

       57
       57
       +
         node.tag = 'inner';

     

       58
       58
       +
         return node;

     

       50
       59
        
       };

     

       51
       60
        
       

     

       52
       52
       -
       const node = function _node(state) {

     

       53
       53
       -
         var last_index = state.index;

     

       54
       54
       -
         var match,

     

       55
       55
       -
             node = [];

     

       61
       61
       +
       const node = function (state) {

     

       62
       62
       +
         var index_1 = state.index;

     

       63
       63
       +
         var node = [];

     

       64
       64
       +
         var match;

     

       56
       65
        
       

     

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

     

       58
       67
        
           node.push(match);

     

       59
       68
        
         } else {

     

       60
       60
       -
           state.index = last_index;

     

       69
       69
       +
           state.index = index_1;

     

       61
       70
        
           return;

     

       62
       71
        
         }

     

       63
       72
        
       

     

       64
       64
       -
         return tag(node, 'node');

     

       73
       73
       +
         node.tag = 'node';

     

       74
       74
       +
         return node;

     

       65
       75
        
       };"

     

       66
       76
        
       `;

     

       67
       77
        
       

     

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

     

       69
       69
       -
       "import { _exec, _substr, _pattern, tag as _tag } from 'reghex';

     

       79
       79
       +
       "import { match, _exec, _pattern, tag as _tag } from 'reghex';

     

       70
       80
        
       

     

       71
       81
        
       var _node_expression = _pattern(1),

     

       72
       82
        
           _node_expression2 = _pattern(2),

     

       73
       83
        
           _node_expression3 = _pattern(3);

     

       74
       84
        
       

     

       75
       75
       -
       const node = function _node(state) {

     

       76
       76
       -
         var last_index = state.index;

     

       77
       77
       -
         var match,

     

       78
       78
       -
             node = [];

     

       85
       85
       +
       const node = function (state) {

     

       86
       86
       +
         var index_1 = state.index;

     

       87
       87
       +
         var node = [];

     

       88
       88
       +
         var match;

     

       79
       89
        
       

     

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

     

       81
       91
        
           node.push(match);

     

       82
       92
        
         } else {

     

       83
       83
       -
           state.index = last_index;

     

       93
       93
       +
           state.index = index_1;

     

       84
       94
        
           return;

     

       85
       95
        
         }

     

       86
       96
        
       

     

       87
       87
       -
         var length_0 = node.length;

     

       97
       97
       +
         var length_2 = node.length;

     

       88
       98
        
       

     

       89
       89
       -
         alternation_1: {

     

       90
       90
       -
           block_1: {

     

       91
       91
       -
             var index_1 = state.index;

     

       99
       99
       +
         alternation_3: {

     

       100
       100
       +
           block_3: {

     

       101
       101
       +
             var index_3 = state.index;

     

       92
       102
        
       

     

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

     

       94
       104
        
               node.push(match);

     

       95
       105
        
             } else {

     

       96
       96
       -
               node.length = length_0;

     

       97
       97
       -
               state.index = index_1;

     

       98
       98
       -
               break block_1;

     

       106
       106
       +
               state.index = index_3;

     

       107
       107
       +
               node.length = length_2;

     

       108
       108
       +
               break block_3;

     

       99
       109
        
             }

     

       100
       110
        
       

     

       101
       101
       -
             break alternation_1;

     

       111
       111
       +
             break alternation_3;

     

       102
       112
        
           }

     

       103
       113
        
       

     

       104
       104
       -
           loop_1: for (var iter_1 = 0; true; iter_1++) {

     

       105
       105
       -
             var index_1 = state.index;

     

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

     

       115
       115
       +
             var index_3 = state.index;

     

       106
       116
        
       

     

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

     

       108
       108
       -
               if (iter_1) {

     

       109
       109
       -
                 state.index = index_1;

     

       110
       110
       -
                 break loop_1;

     

       111
       111
       -
               }

     

       118
       118
       +
               if (count_3) {

     

       119
       119
       +
                 state.index = index_3;

     

       120
       120
       +
                 break loop_3;

     

       121
       121
       +
               } else {}

     

       112
       122
        
       

     

       113
       113
       -
               node.length = length_0;

     

       114
       114
       -
               state.index = last_index;

     

       123
       123
       +
               state.index = index_1;

     

       124
       124
       +
               node.length = length_2;

     

       115
       125
        
               return;

     

       116
       126
        
             }

     

       117
       127
        
           }

     

       118
       128
        
         }

     

       119
       129
        
       

     

       120
       120
       -
         return _tag(node, 'node');

     

       130
       130
       +
         node.tag = 'node';

     

       131
       131
       +
         return node;

     

       132
       132
       +
       };"

     

       133
       133
       +
       `;

     

       134
       134
       +
       

     

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

     

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

     

       137
       137
       +
       

     

       138
       138
       +
       const inner = function (state) {

     

       139
       139
       +
         var index_1 = state.index;

     

       140
       140
       +
         var node = [];

     

       141
       141
       +
         var match;

     

       142
       142
       +
       

     

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

     

       144
       144
       +
           node.push(match);

     

       145
       145
       +
         } else {

     

       146
       146
       +
           state.index = index_1;

     

       147
       147
       +
           return;

     

       148
       148
       +
         }

     

       149
       149
       +
       

     

       150
       150
       +
         node.tag = 'inner';

     

       151
       151
       +
         return node;

     

       152
       152
       +
       };

     

       153
       153
       +
       

     

       154
       154
       +
       const node = function (state) {

     

       155
       155
       +
         var index_1 = state.index;

     

       156
       156
       +
         var node = [];

     

       157
       157
       +
         var match;

     

       158
       158
       +
       

     

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

     

       160
       160
       +
           node.push(match);

     

       161
       161
       +
         } else {

     

       162
       162
       +
           state.index = index_1;

     

       163
       163
       +
           return;

     

       164
       164
       +
         }

     

       165
       165
       +
       

     

       166
       166
       +
         node.tag = 'node';

     

       167
       167
       +
         return node;

     

       121
       168
        
       };"

     

       122
       169
        
       `;

     

       123
       170
        
       

     

       124
       171
        
       exports[`works with standard features 1`] = `

     

       125
       125
       -
       "import { _exec, _substr, _pattern, tag as _tag } from \\"reghex\\";

     

       172
       172
       +
       "import { match, _exec, _pattern, tag as _tag } from \\"reghex\\";

     

       126
       173
        
       

     

       127
       174
        
       var _node_expression = _pattern(1),

     

       128
       175
        
           _node_expression2 = _pattern(2),

     
···

       130
       177
        
           _node_expression4 = _pattern(4),

     

       131
       178
        
           _node_expression5 = _pattern(5);

     

       132
       179
        
       

     

       133
       133
       -
       const node = function _node(state) {

     

       134
       134
       -
         var last_index = state.index;

     

       135
       135
       -
         var match,

     

       136
       136
       -
             node = [];

     

       180
       180
       +
       const node = function (state) {

     

       181
       181
       +
         var index_1 = state.index;

     

       182
       182
       +
         var node = [];

     

       183
       183
       +
         var match;

     

       137
       184
        
       

     

       138
       138
       -
         block_0: {

     

       139
       139
       -
           var index_0 = state.index;

     

       185
       185
       +
         alternation_2: {

     

       186
       186
       +
           block_2: {

     

       187
       187
       +
             var index_2 = state.index;

     

       140
       188
        
       

     

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

     

       142
       142
       -
             var index_0 = state.index;

     

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

     

       190
       190
       +
               var index_2 = state.index;

     

       143
       191
        
       

     

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

     

       145
       145
       -
               node.push(match);

     

       146
       146
       -
             } else {

     

       147
       147
       -
               if (iter_0) {

     

       148
       148
       -
                 state.index = index_0;

     

       149
       149
       -
                 break loop_0;

     

       150
       150
       -
               }

     

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

     

       193
       193
       +
                 node.push(match);

     

       194
       194
       +
               } else {

     

       195
       195
       +
                 if (count_2) {

     

       196
       196
       +
                   state.index = index_2;

     

       197
       197
       +
                   break loop_2;

     

       198
       198
       +
                 } else {}

     

       151
       199
        
       

     

       152
       152
       -
               state.index = index_0;

     

       153
       153
       -
               break block_0;

     

       200
       200
       +
                 state.index = index_2;

     

       201
       201
       +
                 break block_2;

     

       202
       202
       +
               }

     

       154
       203
        
             }

     

       204
       204
       +
       

     

       205
       205
       +
             break alternation_2;

     

       155
       206
        
           }

     

       156
       207
        
       

     

       157
       157
       -
           return _tag(node, 'node');

     

       158
       158
       -
         }

     

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

     

       209
       209
       +
             var index_2 = state.index;

     

       159
       210
        
       

     

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

     

       161
       161
       -
           var index_0 = state.index;

     

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

     

       212
       212
       +
               node.push(match);

     

       213
       213
       +
             } else {

     

       214
       214
       +
               if (count_2) {

     

       215
       215
       +
                 state.index = index_2;

     

       216
       216
       +
                 break loop_2;

     

       217
       217
       +
               } else {}

     

       162
       218
        
       

     

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

     

       164
       164
       -
             node.push(match);

     

       165
       165
       -
           } else {

     

       166
       166
       -
             if (iter_0) {

     

       167
       167
       -
               state.index = index_0;

     

       168
       168
       -
               break loop_0;

     

       219
       219
       +
               state.index = index_1;

     

       220
       220
       +
               return;

     

       169
       221
        
             }

     

       170
       170
       -
       

     

       171
       171
       -
             state.index = last_index;

     

       172
       172
       -
             return;

     

       173
       222
        
           }

     

       174
       174
       -
         }

     

       175
       223
        
       

     

       176
       176
       -
         loop_0: while (true) {

     

       177
       177
       -
           var index_0 = state.index;

     

       178
       178
       -
           var length_0 = node.length;

     

       224
       224
       +
           loop_2: while (true) {

     

       225
       225
       +
             var index_2 = state.index;

     

       226
       226
       +
             var length_2 = node.length;

     

       179
       227
        
       

     

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

     

       181
       181
       -
             node.push(match);

     

       182
       182
       -
           } else {

     

       183
       183
       -
             node.length = length_0;

     

       184
       184
       -
             state.index = index_0;

     

       185
       185
       -
             break loop_0;

     

       186
       186
       -
           }

     

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

     

       229
       229
       +
               node.push(match);

     

       230
       230
       +
             } else {

     

       231
       231
       +
               state.index = index_2;

     

       232
       232
       +
               node.length = length_2;

     

       233
       233
       +
               break loop_2;

     

       234
       234
       +
             }

     

       187
       235
        
       

     

       188
       188
       -
           var index_2 = state.index;

     

       236
       236
       +
             var index_4 = state.index;

     

       189
       237
        
       

     

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

     

       191
       191
       -
             node.push(match);

     

       192
       192
       -
           } else {

     

       193
       193
       -
             state.index = index_2;

     

       194
       194
       -
           }

     

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

     

       239
       239
       +
               node.push(match);

     

       240
       240
       +
             } else {

     

       241
       241
       +
               state.index = index_4;

     

       242
       242
       +
             }

     

       195
       243
        
       

     

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

     

       197
       197
       -
             node.push(match);

     

       198
       198
       -
           } else {

     

       199
       199
       -
             node.length = length_0;

     

       200
       200
       -
             state.index = index_0;

     

       201
       201
       -
             break loop_0;

     

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

     

       245
       245
       +
               node.push(match);

     

       246
       246
       +
             } else {

     

       247
       247
       +
               state.index = index_2;

     

       248
       248
       +
               node.length = length_2;

     

       249
       249
       +
               break loop_2;

     

       250
       250
       +
             }

     

       202
       251
        
           }

     

       203
       252
        
         }

     

       204
       253
        
       

     

       205
       205
       -
         return _tag(node, 'node');

     

       254
       254
       +
         node.tag = 'node';

     

       255
       255
       +
         return node;

     

       206
       256
        
       };"

     

       207
       257
        
       `;

     

       208
       258
        
       

     

       209
       259
        
       exports[`works with transform functions 1`] = `

     

       210
       210
       -
       "import { _exec, _substr, _pattern, tag as _tag } from 'reghex';

     

       260
       260
       +
       "import { match, _exec, _pattern, tag as _tag } from 'reghex';

     

       211
       261
        
       

     

       212
       262
        
       var _inner_transform = x => x;

     

       213
       263
        
       

     

       214
       214
       -
       const first = function _inner(state) {

     

       215
       215
       -
         var last_index = state.index;

     

       216
       216
       -
         var match,

     

       217
       217
       -
             node = [];

     

       218
       218
       -
         return _inner_transform(_tag(node, 'inner'));

     

       264
       264
       +
       const first = function (state) {

     

       265
       265
       +
         var index_1 = state.index;

     

       266
       266
       +
         var node = [];

     

       267
       267
       +
         var match;

     

       268
       268
       +
         node.tag = 'inner';

     

       269
       269
       +
         return _inner_transform(node);

     

       219
       270
        
       };

     

       220
       271
        
       

     

       221
       272
        
       const transform = x => x;

     

       222
       273
        
       

     

       223
       223
       -
       const second = function _node(state) {

     

       224
       224
       -
         var last_index = state.index;

     

       225
       225
       -
         var match,

     

       226
       226
       -
             node = [];

     

       227
       227
       -
         return transform(_tag(node, 'node'));

     

       274
       274
       +
       const second = function (state) {

     

       275
       275
       +
         var index_1 = state.index;

     

       276
       276
       +
         var node = [];

     

       277
       277
       +
         var match;

     

       278
       278
       +
         node.tag = 'node';

     

       279
       279
       +
         return transform(node);

     

       228
       280
        
       };"

     

       229
       281
        
       `;

+3 -40

src/babel/__tests__/suite.js src/core.test.js

···

       1
       1
       -
       import * as reghex from '../../..';

     

       2
       2
       -
       import * as types from '@babel/types';

     

       3
       3
       -
       import { transform } from '@babel/core';

     

       4
       4
       -
       import { makeHelpers } from '../transform';

     

       5
       5
       -
       

     

       6
       6
       -
       const match = (name) => (quasis, ...expressions) => {

     

       7
       7
       -
         const helpers = makeHelpers(types);

     

       8
       8
       -
       

     

       9
       9
       -
         let str = '';

     

       10
       10
       -
         for (let i = 0; i < quasis.length; i++) {

     

       11
       11
       -
           str += quasis[i];

     

       12
       12
       -
           if (i < expressions.length) str += '${' + expressions[i].toString() + '}';

     

       13
       13
       -
         }

     

       14
       14
       -
       

     

       15
       15
       -
         const template = `(function () { return match('${name}')\`${str}\`; })()`;

     

       16
       16
       -
       

     

       17
       17
       -
         const testPlugin = () => ({

     

       18
       18
       -
           visitor: {

     

       19
       19
       -
             TaggedTemplateExpression(path) {

     

       20
       20
       -
               helpers.transformMatch(path);

     

       21
       21
       -
             },

     

       22
       22
       -
           },

     

       23
       23
       -
         });

     

       24
       24
       -
       

     

       25
       25
       -
         const { code } = transform(template, {

     

       26
       26
       -
           babelrc: false,

     

       27
       27
       -
           presets: [],

     

       28
       28
       -
           plugins: [testPlugin],

     

       29
       29
       -
         });

     

       30
       30
       -
       

     

       31
       31
       -
         const argKeys = Object.keys(reghex).filter((x) => {

     

       32
       32
       -
           return x.startsWith('_') || x === 'tag';

     

       33
       33
       -
         });

     

       34
       34
       -
       

     

       35
       35
       -
         const args = argKeys.map((key) => reghex[key]);

     

       36
       36
       -
         return new Function(...argKeys, 'return ' + code)(...args);

     

       37
       37
       -
       };

     

       1
       1
       +
       import { match } from './core';

     

       38
       2
        
       

     

       39
       3
        
       const expectToParse = (node, input, result, lastIndex = 0) => {

     

       40
       4
        
         const state = { input, index: 0 };

     

       41
       41
       -
         expect(node(state)).toEqual(

     

       42
       42
       -
           result === undefined ? result : reghex.tag(result, 'node')

     

       43
       43
       -
         );

     

       5
       5
       +
         if (result) result.tag = 'node';

     

       6
       6
       +
         expect(node(state)).toEqual(result);

     

       44
       7
        
       

     

       45
       8
        
         // NOTE: After parsing we expect the current index to exactly match the

     

       46
       9
        
         // sum amount of matched characters

-411

src/babel/generator.js

···

       1
       1
       -
       let t;

     

       2
       2
       -
       let ids = {};

     

       3
       3
       -
       

     

       4
       4
       -
       export function initGenerator(_ids, _t) {

     

       5
       5
       -
         ids = _ids;

     

       6
       6
       -
         t = _t;

     

       7
       7
       -
       }

     

       8
       8
       -
       

     

       9
       9
       -
       /** var id = state.index; */

     

       10
       10
       -
       class AssignIndexNode {

     

       11
       11
       -
         constructor(id) {

     

       12
       12
       -
           this.id = id;

     

       13
       13
       -
         }

     

       14
       14
       -
       

     

       15
       15
       -
         statement() {

     

       16
       16
       -
           const member = t.memberExpression(ids.state, t.identifier('index'));

     

       17
       17
       -
           return t.variableDeclaration('var', [

     

       18
       18
       -
             t.variableDeclarator(this.id, member),

     

       19
       19
       -
           ]);

     

       20
       20
       -
         }

     

       21
       21
       -
       }

     

       22
       22
       -
       

     

       23
       23
       -
       /** state.index = id; */

     

       24
       24
       -
       class RestoreIndexNode {

     

       25
       25
       -
         constructor(id) {

     

       26
       26
       -
           this.id = id;

     

       27
       27
       -
         }

     

       28
       28
       -
       

     

       29
       29
       -
         statement() {

     

       30
       30
       -
           const expression = t.assignmentExpression(

     

       31
       31
       -
             '=',

     

       32
       32
       -
             t.memberExpression(ids.state, t.identifier('index')),

     

       33
       33
       -
             this.id

     

       34
       34
       -
           );

     

       35
       35
       -
       

     

       36
       36
       -
           return t.expressionStatement(expression);

     

       37
       37
       -
         }

     

       38
       38
       -
       }

     

       39
       39
       -
       

     

       40
       40
       -
       /** var id = node.length; */

     

       41
       41
       -
       class AssignLengthNode {

     

       42
       42
       -
         constructor(id) {

     

       43
       43
       -
           this.id = id;

     

       44
       44
       -
         }

     

       45
       45
       -
       

     

       46
       46
       -
         statement() {

     

       47
       47
       -
           return t.variableDeclaration('var', [

     

       48
       48
       -
             t.variableDeclarator(

     

       49
       49
       -
               this.id,

     

       50
       50
       -
               t.memberExpression(ids.node, t.identifier('length'))

     

       51
       51
       -
             ),

     

       52
       52
       -
           ]);

     

       53
       53
       -
         }

     

       54
       54
       -
       }

     

       55
       55
       -
       

     

       56
       56
       -
       /** node.length = id; */

     

       57
       57
       -
       class RestoreLengthNode {

     

       58
       58
       -
         constructor(id) {

     

       59
       59
       -
           this.id = id;

     

       60
       60
       -
         }

     

       61
       61
       -
       

     

       62
       62
       -
         statement() {

     

       63
       63
       -
           const expression = t.assignmentExpression(

     

       64
       64
       -
             '=',

     

       65
       65
       -
             t.memberExpression(ids.node, t.identifier('length')),

     

       66
       66
       -
             this.id

     

       67
       67
       -
           );

     

       68
       68
       -
       

     

       69
       69
       -
           return t.expressionStatement(expression);

     

       70
       70
       -
         }

     

       71
       71
       -
       }

     

       72
       72
       -
       

     

       73
       73
       -
       /** return; break id; */

     

       74
       74
       -
       class AbortNode {

     

       75
       75
       -
         constructor(id) {

     

       76
       76
       -
           this.id = id || null;

     

       77
       77
       -
         }

     

       78
       78
       -
       

     

       79
       79
       -
         statement() {

     

       80
       80
       -
           const statement = this.id ? t.breakStatement(this.id) : t.returnStatement();

     

       81
       81
       -
           return statement;

     

       82
       82
       -
         }

     

       83
       83
       -
       }

     

       84
       84
       -
       

     

       85
       85
       -
       /** if (condition) { return; break id; } */

     

       86
       86
       -
       class AbortConditionNode {

     

       87
       87
       -
         constructor(condition, opts) {

     

       88
       88
       -
           this.condition = condition || null;

     

       89
       89
       -
       

     

       90
       90
       -
           this.abort = opts.abort;

     

       91
       91
       -
           this.abortCondition = opts.abortCondition || null;

     

       92
       92
       -
           this.restoreIndex = opts.restoreIndex;

     

       93
       93
       -
         }

     

       94
       94
       -
       

     

       95
       95
       -
         statement() {

     

       96
       96
       -
           return t.ifStatement(

     

       97
       97
       -
             this.condition,

     

       98
       98
       -
             t.blockStatement(

     

       99
       99
       -
               [this.restoreIndex.statement(), this.abort.statement()].filter(Boolean)

     

       100
       100
       -
             ),

     

       101
       101
       -
             this.abortCondition ? this.abortCondition.statement() : null

     

       102
       102
       -
           );

     

       103
       103
       -
         }

     

       104
       104
       -
       }

     

       105
       105
       -
       

     

       106
       106
       -
       /** Generates a full matcher for an expression */

     

       107
       107
       -
       class ExpressionNode {

     

       108
       108
       -
         constructor(ast, depth, opts) {

     

       109
       109
       -
           this.ast = ast;

     

       110
       110
       -
           this.depth = depth || 0;

     

       111
       111
       -
           this.capturing = !!opts.capturing;

     

       112
       112
       -
           this.restoreIndex = opts.restoreIndex;

     

       113
       113
       -
           this.restoreLength = opts.restoreLength || null;

     

       114
       114
       -
           this.abortCondition = opts.abortCondition || null;

     

       115
       115
       -
           this.abort = opts.abort || null;

     

       116
       116
       -
         }

     

       117
       117
       -
       

     

       118
       118
       -
         statements() {

     

       119
       119
       -
           const execMatch = this.ast.expression;

     

       120
       120
       -
           const assignMatch = t.assignmentExpression('=', ids.match, execMatch);

     

       121
       121
       -
       

     

       122
       122
       -
           const successNodes = t.blockStatement([

     

       123
       123
       -
             t.expressionStatement(

     

       124
       124
       -
               t.callExpression(t.memberExpression(ids.node, t.identifier('push')), [

     

       125
       125
       -
                 ids.match,

     

       126
       126
       -
               ])

     

       127
       127
       -
             ),

     

       128
       128
       -
           ]);

     

       129
       129
       -
       

     

       130
       130
       -
           const abortNodes = t.blockStatement(

     

       131
       131
       -
             [

     

       132
       132
       -
               this.abortCondition && this.abortCondition.statement(),

     

       133
       133
       -
               this.abort && this.restoreLength && this.restoreLength.statement(),

     

       134
       134
       -
               this.restoreIndex && this.restoreIndex.statement(),

     

       135
       135
       -
               this.abort && this.abort.statement(),

     

       136
       136
       -
             ].filter(Boolean)

     

       137
       137
       -
           );

     

       138
       138
       -
       

     

       139
       139
       -
           return [

     

       140
       140
       -
             !this.capturing

     

       141
       141
       -
               ? t.ifStatement(t.unaryExpression('!', execMatch), abortNodes)

     

       142
       142
       -
               : t.ifStatement(assignMatch, successNodes, abortNodes),

     

       143
       143
       -
           ];

     

       144
       144
       -
         }

     

       145
       145
       -
       }

     

       146
       146
       -
       

     

       147
       147
       -
       /** Generates a full matcher for a group */

     

       148
       148
       -
       class GroupNode {

     

       149
       149
       -
         constructor(ast, depth, opts) {

     

       150
       150
       -
           this.ast = ast;

     

       151
       151
       -
           this.depth = depth || 0;

     

       152
       152
       -
           if (ast.sequence.length === 1) {

     

       153
       153
       -
             return new ExpressionNode(ast.sequence[0], depth, opts);

     

       154
       154
       -
           }

     

       155
       155
       -
       

     

       156
       156
       -
           const lengthId = t.identifier(`length_${depth}`);

     

       157
       157
       -
           const childOpts = {

     

       158
       158
       -
             ...opts,

     

       159
       159
       -
             capturing: !!opts.capturing && !!ast.capturing,

     

       160
       160
       -
           };

     

       161
       161
       -
       

     

       162
       162
       -
           this.assignLength = null;

     

       163
       163
       -
           if (!childOpts.restoreLength && childOpts.capturing) {

     

       164
       164
       -
             this.assignLength = new AssignLengthNode(lengthId);

     

       165
       165
       -
             childOpts.restoreLength = new RestoreLengthNode(lengthId);

     

       166
       166
       -
           }

     

       167
       167
       -
       

     

       168
       168
       -
           this.alternation = new AlternationNode(ast.sequence, depth + 1, childOpts);

     

       169
       169
       -
         }

     

       170
       170
       -
       

     

       171
       171
       -
         statements() {

     

       172
       172
       -
           return [

     

       173
       173
       -
             this.assignLength && this.assignLength.statement(),

     

       174
       174
       -
             ...this.alternation.statements(),

     

       175
       175
       -
           ].filter(Boolean);

     

       176
       176
       -
         }

     

       177
       177
       -
       }

     

       178
       178
       -
       

     

       179
       179
       -
       /** Generates looping logic around another group or expression matcher */

     

       180
       180
       -
       class QuantifierNode {

     

       181
       181
       -
         constructor(ast, depth, opts) {

     

       182
       182
       -
           const { quantifier } = ast;

     

       183
       183
       -
           this.ast = ast;

     

       184
       184
       -
           this.depth = depth || 0;

     

       185
       185
       -
       

     

       186
       186
       -
           const invertId = t.identifier(`invert_${this.depth}`);

     

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

     

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

     

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

     

       190
       190
       -
           const ChildNode = ast.type === 'group' ? GroupNode : ExpressionNode;

     

       191
       191
       -
           const childOpts = { ...opts };

     

       192
       192
       -
       

     

       193
       193
       -
           this.assignIndex = null;

     

       194
       194
       -
           this.restoreIndex = null;

     

       195
       195
       -
           this.blockId = null;

     

       196
       196
       -
           this.abort = null;

     

       197
       197
       -
       

     

       198
       198
       -
           if (ast.type === 'group' && !!ast.lookahead) {

     

       199
       199
       -
             this.restoreIndex = new RestoreIndexNode(indexId);

     

       200
       200
       -
             this.assignIndex = new AssignIndexNode(indexId);

     

       201
       201
       -
           }

     

       202
       202
       -
       

     

       203
       203
       -
           if (ast.type === 'group' && ast.lookahead === 'negative') {

     

       204
       204
       -
             childOpts.abort = new AbortNode(invertId);

     

       205
       205
       -
             childOpts.restoreIndex = this.restoreIndex;

     

       206
       206
       -
             this.restoreIndex = opts.restoreIndex;

     

       207
       207
       -
             this.blockId = invertId;

     

       208
       208
       -
             this.abort = opts.abort;

     

       209
       209
       -
           }

     

       210
       210
       -
       

     

       211
       211
       -
           if (quantifier && !quantifier.singular && quantifier.required) {

     

       212
       212
       -
             childOpts.abortCondition = new AbortConditionNode(iterId, {

     

       213
       213
       -
               ...opts,

     

       214
       214
       -
               restoreIndex: new RestoreIndexNode(indexId),

     

       215
       215
       -
               abort: new AbortNode(loopId),

     

       216
       216
       -
             });

     

       217
       217
       -
           } else if (quantifier && !quantifier.singular) {

     

       218
       218
       -
             childOpts.restoreLength = null;

     

       219
       219
       -
             childOpts.restoreIndex = new RestoreIndexNode(indexId);

     

       220
       220
       -
             childOpts.abort = new AbortNode(loopId);

     

       221
       221
       -
             childOpts.abortCondition = null;

     

       222
       222
       -
           } else if (quantifier && !quantifier.required) {

     

       223
       223
       -
             childOpts.restoreIndex = new RestoreIndexNode(indexId);

     

       224
       224
       -
             childOpts.abortCondition = null;

     

       225
       225
       -
             childOpts.abort = null;

     

       226
       226
       -
           }

     

       227
       227
       -
       

     

       228
       228
       -
           this.childNode = new ChildNode(ast, depth, childOpts);

     

       229
       229
       -
         }

     

       230
       230
       -
       

     

       231
       231
       -
         statements() {

     

       232
       232
       -
           const { quantifier } = this.ast;

     

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

     

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

     

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

     

       236
       236
       -
           const assignIndex = new AssignIndexNode(indexId);

     

       237
       237
       -
       

     

       238
       238
       -
           let statements;

     

       239
       239
       -
           if (quantifier && !quantifier.singular && quantifier.required) {

     

       240
       240
       -
             statements = [

     

       241
       241
       -
               t.labeledStatement(

     

       242
       242
       -
                 loopId,

     

       243
       243
       -
                 t.forStatement(

     

       244
       244
       -
                   t.variableDeclaration('var', [

     

       245
       245
       -
                     t.variableDeclarator(iterId, t.numericLiteral(0)),

     

       246
       246
       -
                   ]),

     

       247
       247
       -
                   t.booleanLiteral(true),

     

       248
       248
       -
                   t.updateExpression('++', iterId),

     

       249
       249
       -
                   t.blockStatement([

     

       250
       250
       -
                     assignIndex.statement(),

     

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

     

       252
       252
       -
                   ])

     

       253
       253
       -
                 )

     

       254
       254
       -
               ),

     

       255
       255
       -
             ];

     

       256
       256
       -
           } else if (quantifier && !quantifier.singular) {

     

       257
       257
       -
             statements = [

     

       258
       258
       -
               t.labeledStatement(

     

       259
       259
       -
                 loopId,

     

       260
       260
       -
                 t.whileStatement(

     

       261
       261
       -
                   t.booleanLiteral(true),

     

       262
       262
       -
                   t.blockStatement([

     

       263
       263
       -
                     assignIndex.statement(),

     

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

     

       265
       265
       -
                   ])

     

       266
       266
       -
                 )

     

       267
       267
       -
               ),

     

       268
       268
       -
             ];

     

       269
       269
       -
           } else if (quantifier && !quantifier.required) {

     

       270
       270
       -
             statements = [assignIndex.statement(), ...this.childNode.statements()];

     

       271
       271
       -
           } else {

     

       272
       272
       -
             statements = this.childNode.statements();

     

       273
       273
       -
           }

     

       274
       274
       -
       

     

       275
       275
       -
           if (this.blockId && this.assignIndex && this.restoreIndex) {

     

       276
       276
       -
             statements = [

     

       277
       277
       -
               t.labeledStatement(

     

       278
       278
       -
                 this.blockId,

     

       279
       279
       -
                 t.blockStatement(

     

       280
       280
       -
                   [

     

       281
       281
       -
                     this.assignIndex.statement(),

     

       282
       282
       -
                     ...statements,

     

       283
       283
       -
                     this.restoreIndex.statement(),

     

       284
       284
       -
                     this.abort.statement(),

     

       285
       285
       -
                   ].filter(Boolean)

     

       286
       286
       -
                 )

     

       287
       287
       -
               ),

     

       288
       288
       -
             ].filter(Boolean);

     

       289
       289
       -
           } else if (this.assignIndex && this.restoreIndex) {

     

       290
       290
       -
             statements.unshift(this.assignIndex.statement());

     

       291
       291
       -
             statements.push(this.restoreIndex.statement());

     

       292
       292
       -
           }

     

       293
       293
       -
       

     

       294
       294
       -
           return statements;

     

       295
       295
       -
         }

     

       296
       296
       -
       }

     

       297
       297
       -
       

     

       298
       298
       -
       /** Generates a matcher of a sequence of sub-matchers for a single sequence */

     

       299
       299
       -
       class SequenceNode {

     

       300
       300
       -
         constructor(ast, depth, opts) {

     

       301
       301
       -
           this.ast = ast;

     

       302
       302
       -
           this.depth = depth || 0;

     

       303
       303
       -
       

     

       304
       304
       -
           const indexId = t.identifier(`index_${depth}`);

     

       305
       305
       -
           const blockId = t.identifier(`block_${this.depth}`);

     

       306
       306
       -
       

     

       307
       307
       -
           this.returnStatement = opts.returnStatement;

     

       308
       308
       -
           this.assignIndex = ast.alternation ? new AssignIndexNode(indexId) : null;

     

       309
       309
       -
       

     

       310
       310
       -
           this.quantifiers = ast.sequence.map((childAst) => {

     

       311
       311
       -
             return new QuantifierNode(childAst, depth, {

     

       312
       312
       -
               ...opts,

     

       313
       313
       -
               restoreIndex: ast.alternation

     

       314
       314
       -
                 ? new RestoreIndexNode(indexId)

     

       315
       315
       -
                 : opts.restoreIndex,

     

       316
       316
       -
               abortCondition: ast.alternation ? null : opts.abortCondition,

     

       317
       317
       -
               abort: ast.alternation ? new AbortNode(blockId) : opts.abort,

     

       318
       318
       -
             });

     

       319
       319
       -
           });

     

       320
       320
       -
         }

     

       321
       321
       -
       

     

       322
       322
       -
         statements() {

     

       323
       323
       -
           const blockId = t.identifier(`block_${this.depth}`);

     

       324
       324
       -
           const alternationId = t.identifier(`alternation_${this.depth}`);

     

       325
       325
       -
           const statements = this.quantifiers.reduce((block, node) => {

     

       326
       326
       -
             block.push(...node.statements());

     

       327
       327
       -
             return block;

     

       328
       328
       -
           }, []);

     

       329
       329
       -
       

     

       330
       330
       -
           if (!this.ast.alternation) {

     

       331
       331
       -
             return statements;

     

       332
       332
       -
           }

     

       333
       333
       -
       

     

       334
       334
       -
           const abortNode =

     

       335
       335
       -
             this.depth === 0 ? this.returnStatement : t.breakStatement(alternationId);

     

       336
       336
       -
       

     

       337
       337
       -
           return [

     

       338
       338
       -
             t.labeledStatement(

     

       339
       339
       -
               blockId,

     

       340
       340
       -
               t.blockStatement([

     

       341
       341
       -
                 this.assignIndex && this.assignIndex.statement(),

     

       342
       342
       -
                 ...statements,

     

       343
       343
       -
                 abortNode,

     

       344
       344
       -
               ])

     

       345
       345
       -
             ),

     

       346
       346
       -
           ];

     

       347
       347
       -
         }

     

       348
       348
       -
       }

     

       349
       349
       -
       

     

       350
       350
       -
       /** Generates matchers for sequences with (or without) alternations */

     

       351
       351
       -
       class AlternationNode {

     

       352
       352
       -
         constructor(ast, depth, opts) {

     

       353
       353
       -
           this.ast = ast;

     

       354
       354
       -
           this.depth = depth || 0;

     

       355
       355
       -
           this.sequences = [];

     

       356
       356
       -
           for (let current = ast; current; current = current.alternation) {

     

       357
       357
       -
             this.sequences.push(new SequenceNode(current, depth, opts));

     

       358
       358
       -
           }

     

       359
       359
       -
         }

     

       360
       360
       -
       

     

       361
       361
       -
         statements() {

     

       362
       362
       -
           if (this.sequences.length === 1) {

     

       363
       363
       -
             return this.sequences[0].statements();

     

       364
       364
       -
           }

     

       365
       365
       -
       

     

       366
       366
       -
           const statements = [];

     

       367
       367
       -
           for (let i = 0; i < this.sequences.length; i++) {

     

       368
       368
       -
             statements.push(...this.sequences[i].statements());

     

       369
       369
       -
           }

     

       370
       370
       -
       

     

       371
       371
       -
           if (this.depth === 0) {

     

       372
       372
       -
             return statements;

     

       373
       373
       -
           }

     

       374
       374
       -
       

     

       375
       375
       -
           const alternationId = t.identifier(`alternation_${this.depth}`);

     

       376
       376
       -
           return [t.labeledStatement(alternationId, t.blockStatement(statements))];

     

       377
       377
       -
         }

     

       378
       378
       -
       }

     

       379
       379
       -
       

     

       380
       380
       -
       export class RootNode {

     

       381
       381
       -
         constructor(ast, nameNode, transformNode) {

     

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

     

       383
       383
       -
           const node = t.callExpression(ids.tag, [ids.node, nameNode]);

     

       384
       384
       -
       

     

       385
       385
       -
           this.returnStatement = t.returnStatement(

     

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

     

       387
       387
       -
           );

     

       388
       388
       -
       

     

       389
       389
       -
           this.assignIndex = new AssignIndexNode(indexId);

     

       390
       390
       -
           this.node = new AlternationNode(ast, 0, {

     

       391
       391
       -
             returnStatement: this.returnStatement,

     

       392
       392
       -
             restoreIndex: new RestoreIndexNode(indexId, true),

     

       393
       393
       -
             restoreLength: null,

     

       394
       394
       -
             abortCondition: null,

     

       395
       395
       -
             abort: new AbortNode(),

     

       396
       396
       -
             capturing: true,

     

       397
       397
       -
           });

     

       398
       398
       -
         }

     

       399
       399
       -
       

     

       400
       400
       -
         statements() {

     

       401
       401
       -
           return [

     

       402
       402
       -
             this.assignIndex.statement(),

     

       403
       403
       -
             t.variableDeclaration('var', [

     

       404
       404
       -
               t.variableDeclarator(ids.match),

     

       405
       405
       -
               t.variableDeclarator(ids.node, t.arrayExpression()),

     

       406
       406
       -
             ]),

     

       407
       407
       -
             ...this.node.statements(),

     

       408
       408
       -
             this.returnStatement,

     

       409
       409
       -
           ];

     

       410
       410
       -
         }

     

       411
       411
       -
       }

+2 -2

src/babel/macro.js

···

       1
       1
        
       import { createMacro } from 'babel-plugin-macros';

     

       2
       2
        
       import { makeHelpers } from './transform';

     

       3
       3
        
       

     

       4
       4
       -
       function reghexMacro({ references, babel: { types: t } }) {

     

       5
       5
       -
         const helpers = makeHelpers(t);

     

       4
       4
       +
       function reghexMacro({ references, babel }) {

     

       5
       5
       +
         const helpers = makeHelpers(babel);

     

       6
       6
        
         const defaultRefs = references.default || [];

     

       7
       7
        
       

     

       8
       8
        
         defaultRefs.forEach((ref) => {

+8 -3

src/babel/plugin.js

···

       1
       1
        
       import { makeHelpers } from './transform';

     

       2
       2
        
       

     

       3
       3
       -
       export default function reghexPlugin({ types }) {

     

       3
       3
       +
       export default function reghexPlugin(babel, opts = {}) {

     

       4
       4
        
         let helpers;

     

       5
       5
        
       

     

       6
       6
        
         return {

     

       7
       7
        
           name: 'reghex',

     

       8
       8
        
           visitor: {

     

       9
       9
        
             Program() {

     

       10
       10
       -
               helpers = makeHelpers(types);

     

       10
       10
       +
               helpers = makeHelpers(babel);

     

       11
       11
        
             },

     

       12
       12
        
             ImportDeclaration(path) {

     

       13
       13
       +
               if (opts.codegen === false) return;

     

       13
       14
        
               helpers.updateImport(path);

     

       14
       15
        
             },

     

       15
       16
        
             TaggedTemplateExpression(path) {

     

       16
       17
        
               if (helpers.isMatch(path) && helpers.getMatchImport(path)) {

     

       17
       17
       -
                 helpers.transformMatch(path);

     

       18
       18
       +
                 if (opts.codegen === false) {

     

       19
       19
       +
                   helpers.minifyMatch(path);

     

       20
       20
       +
                 } else {

     

       21
       21
       +
                   helpers.transformMatch(path);

     

       22
       22
       +
                 }

     

       18
       23
        
               }

     

       19
       24
        
             },

     

       20
       25
        
           },

+44 -7

src/babel/plugin.test.js

···

       3
       3
        
       

     

       4
       4
        
       it('works with standard features', () => {

     

       5
       5
        
         const code = `

     

       6
       6
       -
           import match from 'reghex/macro';

     

       6
       6
       +
           import { match } from 'reghex/macro';

     

       7
       7
        
       

     

       8
       8
        
           const node = match('node')\`

     

       9
       9
        
             \${1}+ | \${2}+ (\${3} ( \${4}? \${5} ) )*

     
···

       16
       16
        
         ).toMatchSnapshot();

     

       17
       17
        
       });

     

       18
       18
        
       

     

       19
       19
       +
       it('works while only minifying', () => {

     

       20
       20
       +
         const code = `

     

       21
       21
       +
           import { match } from 'reghex/macro';

     

       22
       22
       +
       

     

       23
       23
       +
           const node = match('node')\`

     

       24
       24
       +
             \${1}+ | \${2}+ (\${3} ( \${4}? \${5} ) )*

     

       25
       25
       +
           \`;

     

       26
       26
       +
         `;

     

       27
       27
       +
       

     

       28
       28
       +
         expect(

     

       29
       29
       +
           transform(code, {

     

       30
       30
       +
             babelrc: false,

     

       31
       31
       +
             presets: [],

     

       32
       32
       +
             plugins: [[reghexPlugin, { codegen: false }]],

     

       33
       33
       +
           }).code

     

       34
       34
       +
         ).toMatchSnapshot();

     

       35
       35
       +
       });

     

       36
       36
       +
       

     

       19
       37
        
       it('works with local recursion', () => {

     

       20
       38
        
         // NOTE: A different default name is allowed

     

       21
       39
        
         const code = `

     

       22
       22
       -
           import match_rec, { tag } from 'reghex';

     

       40
       40
       +
           import { match as m, tag } from 'reghex';

     

       23
       41
        
       

     

       24
       24
       -
           const inner = match_rec('inner')\`

     

       42
       42
       +
           const inner = m('inner')\`

     

       25
       43
        
             \${/inner/}

     

       26
       44
        
           \`;

     

       27
       45
        
       

     

       28
       28
       -
           const node = match_rec('node')\`

     

       46
       46
       +
           const node = m('node')\`

     

       47
       47
       +
             \${inner}

     

       48
       48
       +
           \`;

     

       49
       49
       +
         `;

     

       50
       50
       +
       

     

       51
       51
       +
         expect(

     

       52
       52
       +
           transform(code, { babelrc: false, presets: [], plugins: [reghexPlugin] })

     

       53
       53
       +
             .code

     

       54
       54
       +
         ).toMatchSnapshot();

     

       55
       55
       +
       });

     

       56
       56
       +
       

     

       57
       57
       +
       it('works with self-referential thunks', () => {

     

       58
       58
       +
         const code = `

     

       59
       59
       +
           import { match, tag } from 'reghex';

     

       60
       60
       +
       

     

       61
       61
       +
           const inner = match('inner')\`

     

       62
       62
       +
             \${() => node}

     

       63
       63
       +
           \`;

     

       64
       64
       +
       

     

       65
       65
       +
           const node = match('node')\`

     

       29
       66
        
             \${inner}

     

       30
       67
        
           \`;

     

       31
       68
        
         `;

     
···

       38
       75
        
       

     

       39
       76
        
       it('works with transform functions', () => {

     

       40
       77
        
         const code = `

     

       41
       41
       -
           import match from 'reghex';

     

       78
       78
       +
           import { match } from 'reghex';

     

       42
       79
        
       

     

       43
       80
        
           const first = match('inner', x => x)\`\`;

     

       44
       81
        
       

     
···

       54
       91
        
       

     

       55
       92
        
       it('works with non-capturing groups', () => {

     

       56
       93
        
         const code = `

     

       57
       57
       -
           import match from 'reghex';

     

       94
       94
       +
           import { match } from 'reghex';

     

       58
       95
        
       

     

       59
       96
        
           const node = match('node')\`

     

       60
       97
        
             \${1} (\${2} | (?: \${3})+)

     
···

       69
       106
        
       

     

       70
       107
        
       it('works together with @babel/plugin-transform-modules-commonjs', () => {

     

       71
       108
        
         const code = `

     

       72
       72
       -
           import match from 'reghex';

     

       109
       109
       +
           import { match } from 'reghex';

     

       73
       110
        
       

     

       74
       111
        
           const node = match('node')\`

     

       75
       112
        
             \${1} \${2}

-17

src/babel/sharedIds.js

···

       2
       2
        
         constructor(t) {

     

       3
       3
        
           this.t = t;

     

       4
       4
        
           this.execId = t.identifier('_exec');

     

       5
       5
       -
           this.substrId = t.identifier('_substr');

     

       6
       5
        
           this.patternId = t.identifier('_pattern');

     

       7
       6
        
           this.tagId = t.identifier('tag');

     

       8
       7
        
         }

     

       9
       8
        
       

     

       10
       10
       -
         get node() {

     

       11
       11
       -
           return this.t.identifier('node');

     

       12
       12
       -
         }

     

       13
       13
       -
       

     

       14
       14
       -
         get match() {

     

       15
       15
       -
           return this.t.identifier('match');

     

       16
       16
       -
         }

     

       17
       17
       -
       

     

       18
       18
       -
         get state() {

     

       19
       19
       -
           return this.t.identifier('state');

     

       20
       20
       -
         }

     

       21
       21
       -
       

     

       22
       9
        
         get exec() {

     

       23
       10
        
           return this.t.identifier(this.execId.name);

     

       24
       24
       -
         }

     

       25
       25
       -
       

     

       26
       26
       -
         get substr() {

     

       27
       27
       -
           return this.t.identifier(this.substrId.name);

     

       28
       11
        
         }

     

       29
       12
        
       

     

       30
       13
        
         get pattern() {

+58 -48

src/babel/transform.js

···

       1
       1
        
       import { parse } from '../parser';

     

       2
       2
       +
       import { astRoot } from '../codegen';

     

       2
       3
        
       import { SharedIds } from './sharedIds';

     

       3
       3
       -
       import { initGenerator, RootNode } from './generator';

     

       4
       4
        
       

     

       5
       5
       -
       export function makeHelpers(t) {

     

       5
       5
       +
       export function makeHelpers({ types: t, template }) {

     

       6
       6
        
         const regexPatternsRe = /^[()\[\]|.+?*]|[^\\][()\[\]|.+?*$^]|\\[wdsWDS]/;

     

       7
       7
        
         const importSourceRe = /reghex$|^reghex\/macro/;

     

       8
       8
        
         const importName = 'reghex';

     

       9
       9
        
         const ids = new SharedIds(t);

     

       10
       10
       -
         initGenerator(ids, t);

     

       11
       10
        
       

     

       12
       11
        
         let _hasUpdatedImport = false;

     

       13
       12
        
       

     
···

       18
       17
        
             if (!importSourceRe.test(path.node.source.value)) return;

     

       19
       18
        
             _hasUpdatedImport = true;

     

       20
       19
        
       

     

       21
       21
       -
             const defaultSpecifierIndex = path.node.specifiers.findIndex((node) => {

     

       22
       22
       -
               return t.isImportDefaultSpecifier(node);

     

       23
       23
       -
             });

     

       24
       24
       -
       

     

       25
       25
       -
             if (defaultSpecifierIndex > -1) {

     

       26
       26
       -
               path.node.specifiers.splice(defaultSpecifierIndex, 1);

     

       27
       27
       -
             }

     

       28
       28
       -
       

     

       29
       20
        
             if (path.node.source.value !== importName) {

     

       30
       21
        
               path.node.source = t.stringLiteral(importName);

     

       31
       22
        
             }

     
···

       36
       27
        
                 t.identifier('_exec')

     

       37
       28
        
               ),

     

       38
       29
        
               t.importSpecifier(

     

       39
       39
       -
                 (ids.substrId = path.scope.generateUidIdentifier('substr')),

     

       40
       40
       -
                 t.identifier('_substr')

     

       41
       41
       -
               ),

     

       42
       42
       -
               t.importSpecifier(

     

       43
       30
        
                 (ids.patternId = path.scope.generateUidIdentifier('pattern')),

     

       44
       31
        
                 t.identifier('_pattern')

     

       45
       32
        
               )

     
···

       48
       35
        
             const tagImport = path.node.specifiers.find((node) => {

     

       49
       36
        
               return t.isImportSpecifier(node) && node.imported.name === 'tag';

     

       50
       37
        
             });

     

       38
       38
       +
       

     

       51
       39
        
             if (!tagImport) {

     

       52
       40
        
               path.node.specifiers.push(

     

       53
       41
        
                 t.importSpecifier(

     
···

       87
       75
        
               binding.kind !== 'module' ||

     

       88
       76
        
               !t.isImportDeclaration(binding.path.parent) ||

     

       89
       77
        
               !importSourceRe.test(binding.path.parent.source.value) ||

     

       90
       90
       -
               !t.isImportDefaultSpecifier(binding.path.node)

     

       78
       78
       +
               !t.isImportSpecifier(binding.path.node)

     

       91
       79
        
             ) {

     

       92
       80
        
               return null;

     

       93
       81
        
             }

     
···

       119
       107
        
             const hoistedExpressions = path.node.quasi.expressions.map(

     

       120
       108
        
               (expression, i) => {

     

       121
       109
        
                 if (

     

       110
       110
       +
                   t.isArrowFunctionExpression(expression) &&

     

       111
       111
       +
                   t.isIdentifier(expression.body)

     

       112
       112
       +
                 ) {

     

       113
       113
       +
                   expression = expression.body;

     

       114
       114
       +
                 } else if (

     

       115
       115
       +
                   (t.isFunctionExpression(expression) ||

     

       116
       116
       +
                     t.isArrowFunctionExpression(expression)) &&

     

       117
       117
       +
                   t.isBlockStatement(expression.body) &&

     

       118
       118
       +
                   expression.body.body.length === 1 &&

     

       119
       119
       +
                   t.isReturnStatement(expression.body.body[0]) &&

     

       120
       120
       +
                   t.isIdentifier(expression.body.body[0].argument)

     

       121
       121
       +
                 ) {

     

       122
       122
       +
                   expression = expression.body.body[0].argument;

     

       123
       123
       +
                 }

     

       124
       124
       +
       

     

       125
       125
       +
                 if (

     

       122
       126
        
                   t.isIdentifier(expression) &&

     

       123
       127
        
                   path.scope.hasBinding(expression.name)

     

       124
       128
        
                 ) {

     
···

       127
       131
        
                     const matchPath = binding.path.get('init');

     

       128
       132
        
                     if (this.isMatch(matchPath)) return expression;

     

       129
       133
        
                   }

     

       130
       130
       -
                 } else if (

     

       131
       131
       -
                   t.isRegExpLiteral(expression) &&

     

       132
       132
       -
                   !regexPatternsRe.test(expression.pattern)

     

       133
       133
       -
                 ) {

     

       134
       134
       -
                   // NOTE: This is an optimisation path, where the pattern regex is inlined

     

       135
       135
       -
                   // and has determined to be "simple" enough to be turned into a string

     

       136
       136
       -
                   return t.stringLiteral(

     

       137
       137
       -
                     expression.pattern.replace(/\\./g, (x) => x[1])

     

       138
       138
       -
                   );

     

       139
       134
        
                 }

     

       140
       135
        
       

     

       141
       136
        
                 const id = path.scope.generateUidIdentifier(

     
···

       160
       155
        
             }

     

       161
       156
        
       

     

       162
       157
        
             return hoistedExpressions.map((id) => {

     

       163
       163
       -
               // Use _substr helper instead if the expression is a string

     

       164
       164
       -
               if (t.isStringLiteral(id)) {

     

       165
       165
       -
                 return t.callExpression(ids.substr, [ids.state, id]);

     

       166
       166
       -
               }

     

       167
       167
       -
       

     

       168
       168
       -
               // Directly call expression if it's sure to be another matcher

     

       169
       158
        
               const binding = path.scope.getBinding(id.name);

     

       170
       159
        
               if (binding && t.isVariableDeclarator(binding.path.node)) {

     

       171
       160
        
                 const matchPath = binding.path.get('init');

     

       172
       172
       -
                 if (this.isMatch(matchPath)) {

     

       173
       173
       -
                   return t.callExpression(id, [ids.state]);

     

       174
       174
       -
                 }

     

       161
       161
       +
                 if (this.isMatch(matchPath)) return `${id.name}(state)`;

     

       175
       162
        
               }

     

       176
       163
        
       

     

       177
       177
       -
               return t.callExpression(ids.exec, [ids.state, id]);

     

       164
       164
       +
               const input = t.isStringLiteral(id)

     

       165
       165
       +
                 ? JSON.stringify(id.value)

     

       166
       166
       +
                 : id.name;

     

       167
       167
       +
               return `${ids.exec.name}(state, ${input})`;

     

       178
       168
        
             });

     

       179
       169
        
           },

     

       180
       170
        
       

     

       181
       171
        
           _prepareTransform(path) {

     

       182
       172
        
             const transformNode = path.node.tag.arguments[1];

     

       173
       173
       +
       

     

       183
       174
        
             if (!transformNode) return null;

     

       184
       184
       -
             if (t.isIdentifier(transformNode)) return transformNode;

     

       175
       175
       +
             if (t.isIdentifier(transformNode)) return transformNode.name;

     

       185
       176
        
       

     

       186
       177
        
             const matchName = this.getMatchName(path);

     

       187
       178
        
             const id = path.scope.generateUidIdentifier(`${matchName}_transform`);

     
···

       190
       181
        
             path

     

       191
       182
        
               .getStatementParent()

     

       192
       183
        
               .insertBefore(t.variableDeclaration('var', [declarator]));

     

       193
       193
       -
             return id;

     

       184
       184
       +
       

     

       185
       185
       +
             return id.name;

     

       186
       186
       +
           },

     

       187
       187
       +
       

     

       188
       188
       +
           minifyMatch(path) {

     

       189
       189
       +
             if (!path.node.tag.arguments.length) {

     

       190
       190
       +
               throw path

     

       191
       191
       +
                 .get('tag')

     

       192
       192
       +
                 .buildCodeFrameError(

     

       193
       193
       +
                   'match() must at least be called with a node name'

     

       194
       194
       +
                 );

     

       195
       195
       +
             }

     

       196
       196
       +
       

     

       197
       197
       +
             const quasis = path.node.quasi.quasis.map((x) =>

     

       198
       198
       +
               t.stringLiteral(x.value.cooked.replace(/\s*/g, ''))

     

       199
       199
       +
             );

     

       200
       200
       +
             const expressions = path.node.quasi.expressions;

     

       201
       201
       +
             const transform = this._prepareTransform(path);

     

       202
       202
       +
       

     

       203
       203
       +
             path.replaceWith(

     

       204
       204
       +
               t.callExpression(path.node.tag, [

     

       205
       205
       +
                 t.arrayExpression(quasis),

     

       206
       206
       +
                 ...expressions,

     

       207
       207
       +
               ])

     

       208
       208
       +
             );

     

       194
       209
        
           },

     

       195
       210
        
       

     

       196
       211
        
           transformMatch(path) {

     
···

       202
       217
        
                 );

     

       203
       218
        
             }

     

       204
       219
        
       

     

       205
       205
       -
             const matchName = this.getMatchName(path);

     

       206
       206
       -
             const nameNode = path.node.tag.arguments[0];

     

       220
       220
       +
             const name = path.node.tag.arguments[0];

     

       207
       221
        
             const quasis = path.node.quasi.quasis.map((x) => x.value.cooked);

     

       208
       222
        
       

     

       209
       223
        
             const expressions = this._prepareExpressions(path);

     

       210
       210
       -
             const transformNode = this._prepareTransform(path);

     

       224
       224
       +
             const transform = this._prepareTransform(path);

     

       211
       225
        
       

     

       212
       226
        
             let ast;

     

       213
       227
        
             try {

     
···

       217
       231
        
               throw path.get('quasi').buildCodeFrameError(error.message);

     

       218
       232
        
             }

     

       219
       233
        
       

     

       220
       220
       -
             const generator = new RootNode(ast, nameNode, transformNode);

     

       221
       221
       -
             const body = t.blockStatement(generator.statements());

     

       222
       222
       -
             const matchFunctionId = path.scope.generateUidIdentifier(matchName);

     

       223
       223
       -
             const matchFunction = t.functionExpression(

     

       224
       224
       -
               matchFunctionId,

     

       225
       225
       -
               [ids.state],

     

       226
       226
       -
               body

     

       234
       234
       +
             const code = astRoot(ast, '%%name%%', transform && '%%transform%%');

     

       235
       235
       +
       

     

       236
       236
       +
             path.replaceWith(

     

       237
       237
       +
               template.expression(code)(transform ? { name, transform } : { name })

     

       227
       238
        
             );

     

       228
       228
       -
             path.replaceWith(matchFunction);

     

       229
       239
        
           },

     

       230
       240
        
         };

     

       231
       241
        
       }

+252

src/codegen.js

···

       1
       1
       +
       const _state = 'state';

     

       2
       2
       +
       const _match = 'match';

     

       3
       3
       +
       const _node = 'node';

     

       4
       4
       +
       

     

       5
       5
       +
       function js(/* arguments */) {

     

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

     

       7
       7
       +
         for (let i = 1; i < arguments.length; i++)

     

       8
       8
       +
           body = body + arguments[i] + arguments[0][i];

     

       9
       9
       +
         return body.trim();

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       const newOpts = (prev, next) => ({

     

       13
       13
       +
         index: next.index != null ? next.index : prev.index,

     

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

     

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

     

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

     

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

     

       18
       18
       +
       });

     

       19
       19
       +
       

     

       20
       20
       +
       const assignIndex = (depth) =>

     

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

     

       22
       22
       +
       

     

       23
       23
       +
       const restoreIndex = (depth) =>

     

       24
       24
       +
         depth ? js`${_state}.index = index_${depth};` : '';

     

       25
       25
       +
       

     

       26
       26
       +
       const abortOnCondition = (condition, hooks) => js`

     

       27
       27
       +
         if (${condition}) {

     

       28
       28
       +
           ${restoreIndex(opts.index)}

     

       29
       29
       +
           ${opts.abort || ''}

     

       30
       30
       +
         } else {

     

       31
       31
       +
           ${opts.onAbort || ''}

     

       32
       32
       +
         }

     

       33
       33
       +
       `;

     

       34
       34
       +
       

     

       35
       35
       +
       const astExpression = (ast, depth, opts) => {

     

       36
       36
       +
         const restoreLength =

     

       37
       37
       +
           opts.length &&

     

       38
       38
       +
           opts.abort &&

     

       39
       39
       +
           js`

     

       40
       40
       +
           ${_node}.length = length_${opts.length};

     

       41
       41
       +
         `;

     

       42
       42
       +
       

     

       43
       43
       +
         const abort = js`

     

       44
       44
       +
           ${opts.onAbort || ''}

     

       45
       45
       +
           ${restoreIndex(opts.index)}

     

       46
       46
       +
           ${restoreLength || ''}

     

       47
       47
       +
           ${opts.abort || ''}

     

       48
       48
       +
         `;

     

       49
       49
       +
       

     

       50
       50
       +
         if (!opts.capture) {

     

       51
       51
       +
           return js`

     

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

     

       53
       53
       +
               ${abort}

     

       54
       54
       +
             }

     

       55
       55
       +
           `;

     

       56
       56
       +
         }

     

       57
       57
       +
       

     

       58
       58
       +
         return js`

     

       59
       59
       +
           if (${_match} = ${ast.expression}) {

     

       60
       60
       +
             ${_node}.push(${_match});

     

       61
       61
       +
           } else {

     

       62
       62
       +
             ${abort}

     

       63
       63
       +
           }

     

       64
       64
       +
         `;

     

       65
       65
       +
       };

     

       66
       66
       +
       

     

       67
       67
       +
       const astGroup = (ast, depth, opts) => {

     

       68
       68
       +
         const capture = !!opts.capture && !ast.capture;

     

       69
       69
       +
       

     

       70
       70
       +
         let group = '';

     

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

     

       72
       72
       +
           return js`

     

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

     

       74
       74
       +
             ${astSequence(

     

       75
       75
       +
               ast.sequence,

     

       76
       76
       +
               depth + 1,

     

       77
       77
       +
               newOpts(opts, {

     

       78
       78
       +
                 length: depth,

     

       79
       79
       +
                 capture,

     

       80
       80
       +
               })

     

       81
       81
       +
             )}

     

       82
       82
       +
           `;

     

       83
       83
       +
         }

     

       84
       84
       +
       

     

       85
       85
       +
         return astSequence(

     

       86
       86
       +
           ast.sequence,

     

       87
       87
       +
           depth + 1,

     

       88
       88
       +
           newOpts(opts, {

     

       89
       89
       +
             capture,

     

       90
       90
       +
           })

     

       91
       91
       +
         );

     

       92
       92
       +
       };

     

       93
       93
       +
       

     

       94
       94
       +
       const astChild = (ast, depth, opts) =>

     

       95
       95
       +
         ast.expression ? astExpression(ast, depth, opts) : astGroup(ast, depth, opts);

     

       96
       96
       +
       

     

       97
       97
       +
       const astRepeating = (ast, depth, opts) => {

     

       98
       98
       +
         const label = `loop_${depth}`;

     

       99
       99
       +
         const count = `count_${depth}`;

     

       100
       100
       +
         return js`

     

       101
       101
       +
           ${label}: for (var ${count} = 0; true; ${count}++) {

     

       102
       102
       +
             ${assignIndex(depth)}

     

       103
       103
       +
             ${astChild(

     

       104
       104
       +
               ast,

     

       105
       105
       +
               depth,

     

       106
       106
       +
               newOpts(opts, {

     

       107
       107
       +
                 onAbort: js`

     

       108
       108
       +
                 if (${count}) {

     

       109
       109
       +
                   ${restoreIndex(depth)}

     

       110
       110
       +
                   break ${label};

     

       111
       111
       +
                 } else {

     

       112
       112
       +
                   ${opts.onAbort || ''}

     

       113
       113
       +
                 }

     

       114
       114
       +
               `,

     

       115
       115
       +
               })

     

       116
       116
       +
             )}

     

       117
       117
       +
           }

     

       118
       118
       +
         `;

     

       119
       119
       +
       };

     

       120
       120
       +
       

     

       121
       121
       +
       const astMultiple = (ast, depth, opts) => {

     

       122
       122
       +
         const label = `loop_${depth}`;

     

       123
       123
       +
         return js`

     

       124
       124
       +
           ${label}: while (true) {

     

       125
       125
       +
             ${assignIndex(depth)}

     

       126
       126
       +
             ${astChild(

     

       127
       127
       +
               ast,

     

       128
       128
       +
               depth,

     

       129
       129
       +
               newOpts(opts, {

     

       130
       130
       +
                 length: 0,

     

       131
       131
       +
                 index: depth,

     

       132
       132
       +
                 abort: js`break ${label};`,

     

       133
       133
       +
                 onAbort: '',

     

       134
       134
       +
               })

     

       135
       135
       +
             )}

     

       136
       136
       +
           }

     

       137
       137
       +
         `;

     

       138
       138
       +
       };

     

       139
       139
       +
       

     

       140
       140
       +
       const astOptional = (ast, depth, opts) => js`

     

       141
       141
       +
         ${assignIndex(depth)}

     

       142
       142
       +
         ${astChild(

     

       143
       143
       +
           ast,

     

       144
       144
       +
           depth,

     

       145
       145
       +
           newOpts(opts, {

     

       146
       146
       +
             index: depth,

     

       147
       147
       +
             abort: '',

     

       148
       148
       +
             onAbort: '',

     

       149
       149
       +
           })

     

       150
       150
       +
         )}

     

       151
       151
       +
       `;

     

       152
       152
       +
       

     

       153
       153
       +
       const astQuantifier = (ast, depth, opts) => {

     

       154
       154
       +
         const { index, abort } = opts;

     

       155
       155
       +
         const label = `invert_${depth}`;

     

       156
       156
       +
       

     

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

     

       158
       158
       +
           opts = newOpts(opts, {

     

       159
       159
       +
             index: depth,

     

       160
       160
       +
             abort: js`break ${label};`,

     

       161
       161
       +
           });

     

       162
       162
       +
         }

     

       163
       163
       +
       

     

       164
       164
       +
         let child;

     

       165
       165
       +
         if (ast.quantifier === '+') {

     

       166
       166
       +
           child = astRepeating(ast, depth, opts);

     

       167
       167
       +
         } else if (ast.quantifier === '*') child = astMultiple(ast, depth, opts);

     

       168
       168
       +
         else if (ast.quantifier === '?') child = astOptional(ast, depth, opts);

     

       169
       169
       +
         else child = astChild(ast, depth, opts);

     

       170
       170
       +
       

     

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

     

       172
       172
       +
           return js`

     

       173
       173
       +
             ${label}: {

     

       174
       174
       +
               ${assignIndex(depth)}

     

       175
       175
       +
               ${child}

     

       176
       176
       +
               ${restoreIndex(index)}

     

       177
       177
       +
               ${abort}

     

       178
       178
       +
             }

     

       179
       179
       +
           `;

     

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

     

       181
       181
       +
           return js`

     

       182
       182
       +
             ${assignIndex(depth)}

     

       183
       183
       +
             ${child}

     

       184
       184
       +
             ${restoreIndex(depth)}

     

       185
       185
       +
           `;

     

       186
       186
       +
         } else {

     

       187
       187
       +
           return child;

     

       188
       188
       +
         }

     

       189
       189
       +
       };

     

       190
       190
       +
       

     

       191
       191
       +
       const astSequence = (ast, depth, opts) => {

     

       192
       192
       +
         const alternation = ast.alternation ? `alternation_${depth}` : '';

     

       193
       193
       +
       

     

       194
       194
       +
         let body = '';

     

       195
       195
       +
         for (; ast; ast = ast.alternation) {

     

       196
       196
       +
           const block = `block_${depth}`;

     

       197
       197
       +
       

     

       198
       198
       +
           let childOpts = opts;

     

       199
       199
       +
           if (ast.alternation) {

     

       200
       200
       +
             childOpts = newOpts(opts, {

     

       201
       201
       +
               index: depth,

     

       202
       202
       +
               abort: js`break ${block};`,

     

       203
       203
       +
               onAbort: '',

     

       204
       204
       +
             });

     

       205
       205
       +
           }

     

       206
       206
       +
       

     

       207
       207
       +
           let sequence = '';

     

       208
       208
       +
           for (let i = 0; i < ast.length; i++)

     

       209
       209
       +
             sequence += astQuantifier(ast[i], depth, childOpts);

     

       210
       210
       +
       

     

       211
       211
       +
           if (!ast.alternation) {

     

       212
       212
       +
             body += sequence;

     

       213
       213
       +
           } else {

     

       214
       214
       +
             body += js`

     

       215
       215
       +
               ${block}: {

     

       216
       216
       +
                 ${assignIndex(depth)}

     

       217
       217
       +
                 ${sequence}

     

       218
       218
       +
                 break ${alternation};

     

       219
       219
       +
               }

     

       220
       220
       +
             `;

     

       221
       221
       +
           }

     

       222
       222
       +
         }

     

       223
       223
       +
       

     

       224
       224
       +
         if (!alternation) return body;

     

       225
       225
       +
       

     

       226
       226
       +
         return js`

     

       227
       227
       +
           ${alternation}: {

     

       228
       228
       +
             ${body}

     

       229
       229
       +
           }

     

       230
       230
       +
         `;

     

       231
       231
       +
       };

     

       232
       232
       +
       

     

       233
       233
       +
       const astRoot = (ast, name, transform) => js`

     

       234
       234
       +
         (function (${_state}) {

     

       235
       235
       +
           ${assignIndex(1)}

     

       236
       236
       +
           var ${_node} = [];

     

       237
       237
       +
           var ${_match};

     

       238
       238
       +
       

     

       239
       239
       +
           ${astSequence(ast, 2, {

     

       240
       240
       +
             index: 1,

     

       241
       241
       +
             length: 0,

     

       242
       242
       +
             onAbort: '',

     

       243
       243
       +
             abort: js`return;`,

     

       244
       244
       +
             capture: true,

     

       245
       245
       +
           })}

     

       246
       246
       +
       

     

       247
       247
       +
           ${_node}.tag = ${name};

     

       248
       248
       +
           return ${transform ? js`(${transform})(${_node})` : _node};

     

       249
       249
       +
         })

     

       250
       250
       +
       `;

     

       251
       251
       +
       

     

       252
       252
       +
       export { astRoot };

+29 -31

src/core.js

···

       1
       1
       +
       import { astRoot } from './codegen';

     

       2
       2
       +
       import { parse as parseDSL } from './parser';

     

       3
       3
       +
       

     

       1
       4
        
       const isStickySupported = typeof /./g.sticky === 'boolean';

     

       2
       5
        
       

     

       3
       6
        
       export const _pattern = (input) => {

     

       4
       7
        
         if (typeof input === 'function') return input;

     

       5
       5
       -
       

     

       6
       8
        
         const source = typeof input !== 'string' ? input.source : input;

     

       7
       9
        
         return isStickySupported

     

       8
       10
        
           ? new RegExp(source, 'y')

     

       9
       9
       -
           : new RegExp(`^(?:${source})`, 'g');

     

       11
       11
       +
           : new RegExp(source + '|()', 'g');

     

       10
       12
        
       };

     

       11
       13
        
       

     

       12
       12
       -
       export const _substr = (state, pattern) => {

     

       13
       13
       -
         const end = state.index + pattern.length;

     

       14
       14
       -
         const sub = state.input.slice(state.index, end);

     

       15
       15
       -
         if (sub === pattern) {

     

       16
       16
       -
           state.index = end;

     

       17
       17
       -
           return sub;

     

       14
       14
       +
       export const _exec = (state, pattern) => {

     

       15
       15
       +
         let match;

     

       16
       16
       +
       

     

       17
       17
       +
         if (typeof pattern === 'function') {

     

       18
       18
       +
           if (!pattern.length) pattern = pattern();

     

       19
       19
       +
           return pattern(state);

     

       18
       20
        
         }

     

       19
       19
       -
       };

     

       20
       21
        
       

     

       21
       21
       -
       export const _exec = (state, pattern) => {

     

       22
       22
       -
         if (typeof pattern === 'function') return pattern();

     

       22
       22
       +
         pattern.lastIndex = state.index;

     

       23
       23
        
       

     

       24
       24
       -
         let match;

     

       25
       24
        
         if (isStickySupported) {

     

       26
       26
       -
           pattern.lastIndex = state.index;

     

       27
       27
       -
           if (pattern.test(state.input)) {

     

       25
       25
       +
           if (pattern.test(state.input))

     

       28
       26
        
             match = state.input.slice(state.index, pattern.lastIndex);

     

       29
       29
       -
             state.index = pattern.lastIndex;

     

       30
       30
       -
           }

     

       31
       27
        
         } else {

     

       32
       32
       -
           pattern.lastIndex = 0;

     

       33
       33
       -
           if (pattern.test(state.input.slice(state.index))) {

     

       34
       34
       -
             const lastIndex = state.index + pattern.lastIndex;

     

       35
       35
       -
             match = state.input.slice(state.index, lastIndex);

     

       36
       36
       -
             state.index = lastIndex;

     

       37
       37
       -
           }

     

       28
       28
       +
           match = pattern.exec(state.input)[0] || match;

     

       38
       29
        
         }

     

       39
       30
        
       

     

       31
       31
       +
         state.index = pattern.lastIndex;

     

       40
       32
        
         return match;

     

       41
       33
        
       };

     

       42
       34
        
       

     

       43
       43
       -
       export const tag = (array, tag) => {

     

       44
       44
       -
         array.tag = tag;

     

       45
       45
       -
         return array;

     

       46
       46
       -
       };

     

       47
       47
       -
       

     

       48
       35
        
       export const parse = (pattern) => (input) => {

     

       49
       36
        
         const state = { input, index: 0 };

     

       50
       37
        
         return pattern(state);

     

       51
       38
        
       };

     

       52
       39
        
       

     

       53
       53
       -
       export const match = (_name) => {

     

       54
       54
       -
         throw new TypeError(

     

       55
       55
       -
           'This match() function was not transformed. ' +

     

       56
       56
       -
             'Ensure that the Babel plugin is set up correctly and try again.'

     

       40
       40
       +
       export const match = (name, transform) => (quasis, ...expressions) => {

     

       41
       41
       +
         const ast = parseDSL(

     

       42
       42
       +
           quasis,

     

       43
       43
       +
           expressions.map((expression, i) =>

     

       44
       44
       +
             typeof expression === 'function' && expression.length

     

       45
       45
       +
               ? `_${i}(state)`

     

       46
       46
       +
               : `_e(state, _${i})`

     

       47
       47
       +
           )

     

       57
       48
        
         );

     

       49
       49
       +
       

     

       50
       50
       +
         const makeMatcher = new Function(

     

       51
       51
       +
           '_e,_n,_t,' + expressions.map((_expression, i) => `_${i}`).join(','),

     

       52
       52
       +
           'return ' + astRoot(ast, '_n', transform ? '_t' : null)

     

       53
       53
       +
         );

     

       54
       54
       +
       

     

       55
       55
       +
         return makeMatcher(_exec, name, transform, ...expressions.map(_pattern));

     

       58
       56
        
       };

+27 -77

src/parser.js

···

       1
       1
       +
       const syntaxError = (char) => {

     

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

     

       3
       3
       +
       };

     

       4
       4
       +
       

     

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

     

       2
       6
        
         let quasiIndex = 0;

     

       3
       7
        
         let stackIndex = 0;

     

       4
       8
        
       

     

       5
       9
        
         const sequenceStack = [];

     

       6
       6
       -
         const rootSequence = {

     

       7
       7
       -
           type: 'sequence',

     

       8
       8
       -
           sequence: [],

     

       9
       9
       -
           alternation: null,

     

       10
       10
       -
         };

     

       10
       10
       +
         const rootSequence = [];

     

       11
       11
        
       

     

       12
       12
        
         let currentGroup = null;

     

       13
       13
        
         let lastMatch;

     

       14
       14
        
         let currentSequence = rootSequence;

     

       15
       15
        
       

     

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

     

       16
       16
       +
         for (

     

       17
       17
       +
           let quasiIndex = 0, stackIndex = 0;

     

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

     

       19
       19
       +
           stackIndex++

     

       20
       20
       +
         ) {

     

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

     

       18
       18
       -
             const expression = expressions[stackIndex++ >> 1];

     

       19
       19
       -
       

     

       20
       20
       -
             currentSequence.sequence.push({

     

       21
       21
       -
               type: 'expression',

     

       22
       22
       -
               expression,

     

       23
       23
       -
               quantifier: null,

     

       22
       22
       +
             currentSequence.push({

     

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

     

       24
       24
        
             });

     

       25
       25
        
           }

     

       26
       26
        
       

     

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

     

       28
       28
       -
           while (quasiIndex < quasi.length) {

     

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

     

       29
       29
        
             const char = quasi[quasiIndex++];

     

       30
       30
       -
       

     

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

     

       32
       32
       -
               continue;

     

       33
       33
       -
             } else if (char === '|' && currentSequence.sequence.length > 0) {

     

       34
       34
       -
               currentSequence = currentSequence.alternation = {

     

       35
       35
       -
                 type: 'sequence',

     

       36
       36
       -
                 sequence: [],

     

       37
       37
       -
                 alternation: null,

     

       38
       38
       -
               };

     

       39
       39
       -
       

     

       40
       40
       -
               continue;

     

       41
       41
       -
             } else if (char === ')' && currentSequence.sequence.length > 0) {

     

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

     

       32
       32
       +
               currentSequence = currentSequence.alternation = [];

     

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

     

       42
       34
        
               currentGroup = null;

     

       43
       35
        
               currentSequence = sequenceStack.pop();

     

       44
       44
       -
               if (currentSequence) continue;

     

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

     

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

     

       46
       46
       -
               currentGroup = {

     

       47
       47
       -
                 type: 'group',

     

       48
       48
       -
                 sequence: {

     

       49
       49
       -
                   type: 'sequence',

     

       50
       50
       -
                   sequence: [],

     

       51
       51
       -
                   alternation: null,

     

       52
       52
       -
                 },

     

       53
       53
       -
                 capturing: true,

     

       54
       54
       -
                 lookahead: null,

     

       55
       55
       -
                 quantifier: null,

     

       56
       56
       -
               };

     

       57
       57
       -
       

     

       58
       38
        
               sequenceStack.push(currentSequence);

     

       59
       59
       -
               currentSequence.sequence.push(currentGroup);

     

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

     

       60
       40
        
               currentSequence = currentGroup.sequence;

     

       61
       61
       -
               continue;

     

       62
       62
       -
             } else if (

     

       63
       63
       -
               char === '?' &&

     

       64
       64
       -
               currentSequence.sequence.length === 0 &&

     

       65
       65
       -
               currentGroup

     

       66
       66
       -
             ) {

     

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

     

       67
       42
        
               const nextChar = quasi[quasiIndex++];

     

       68
       68
       -
               if (!nextChar) {

     

       69
       69
       -
                 throw new SyntaxError('Unexpected end of input after ' + char);

     

       70
       70
       -
               }

     

       71
       71
       -
       

     

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

     

       73
       73
       -
                 currentGroup.capturing = false;

     

       74
       74
       -
                 continue;

     

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

     

       76
       76
       -
                 currentGroup.capturing = false;

     

       77
       77
       -
                 currentGroup.lookahead = 'positive';

     

       78
       78
       -
                 continue;

     

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

     

       80
       80
       -
                 currentGroup.capturing = false;

     

       81
       81
       -
                 currentGroup.lookahead = 'negative';

     

       82
       82
       -
                 continue;

     

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

     

       44
       44
       +
                 currentGroup.capture = nextChar;

     

       45
       45
       +
               } else {

     

       46
       46
       +
                 syntaxError(char);

     

       83
       47
        
               }

     

       84
       48
        
             } else if (

     

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

     

       86
       86
       -
               (lastMatch =

     

       87
       87
       -
                 currentSequence.sequence[currentSequence.sequence.length - 1])

     

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

     

       88
       51
        
             ) {

     

       89
       89
       -
               if (lastMatch.type === 'group' && lastMatch.lookahead) {

     

       90
       90
       -
                 throw new SyntaxError('Unexpected quantifier on lookahead group');

     

       91
       91
       -
               }

     

       92
       92
       -
       

     

       93
       93
       -
               lastMatch.quantifier = {

     

       94
       94
       -
                 type: 'quantifier',

     

       95
       95
       -
                 required: char === '+',

     

       96
       96
       -
                 singular: char === '?',

     

       97
       97
       -
               };

     

       98
       98
       -
       

     

       99
       99
       -
               continue;

     

       52
       52
       +
               lastMatch.quantifier = char;

     

       53
       53
       +
             } else {

     

       54
       54
       +
               syntaxError(char);

     

       100
       55
        
             }

     

       101
       101
       -
       

     

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

     

       103
       56
        
           }

     

       104
       104
       -
       

     

       105
       105
       -
           stackIndex++;

     

       106
       106
       -
           quasiIndex = 0;

     

       107
       57
        
         }

     

       108
       58
        
       

     

       109
       59
        
         return rootSequence;

+34 -113

src/parser.test.js

···

       2
       2
        
       

     

       3
       3
        
       const parseTag = (quasis, ...expressions) => parse(quasis, expressions);

     

       4
       4
        
       

     

       5
       5
       -
       it('supports parsing expressions', () => {

     

       6
       6
       -
         expect(parseTag`${1}`).toEqual({

     

       7
       7
       -
           type: 'sequence',

     

       8
       8
       -
           sequence: [

     

       9
       9
       -
             {

     

       10
       10
       -
               type: 'expression',

     

       11
       11
       -
               expression: 1,

     

       12
       12
       -
               quantifier: null,

     

       13
       13
       -
             },

     

       14
       14
       -
           ],

     

       15
       15
       -
           alternation: null,

     

       16
       16
       -
         });

     

       17
       17
       -
       });

     

       18
       18
       -
       

     

       19
       5
        
       it('supports parsing expressions with quantifiers', () => {

     

       20
       6
        
         let ast;

     

       21
       7
        
       

     

       22
       8
        
         ast = parseTag`${1}?`;

     

       23
       23
       -
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       24
       24
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       25
       25
       -
           type: 'quantifier',

     

       26
       26
       -
           required: false,

     

       27
       27
       -
           singular: true,

     

       28
       28
       -
         });

     

       9
       9
       +
         expect(ast).toHaveProperty('0.quantifier', '?');

     

       29
       10
        
       

     

       30
       11
        
         ast = parseTag`${1}+`;

     

       31
       31
       -
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       32
       32
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       33
       33
       -
           type: 'quantifier',

     

       34
       34
       -
           required: true,

     

       35
       35
       -
           singular: false,

     

       36
       36
       -
         });

     

       12
       12
       +
         expect(ast).toHaveProperty('0.quantifier', '+');

     

       37
       13
        
       

     

       38
       14
        
         ast = parseTag`${1}*`;

     

       39
       39
       -
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       40
       40
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       41
       41
       -
           type: 'quantifier',

     

       42
       42
       -
           required: false,

     

       43
       43
       -
           singular: false,

     

       44
       44
       -
         });

     

       15
       15
       +
         expect(ast).toHaveProperty('0.quantifier', '*');

     

       45
       16
        
       });

     

       46
       17
        
       

     

       47
       18
        
       it('supports top-level alternations', () => {

     

       48
       19
        
         let ast;

     

       49
       20
        
       

     

       50
       21
        
         ast = parseTag`${1} | ${2}`;

     

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

     

       52
       52
       -
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       53
       53
       -
         expect(ast).toHaveProperty('sequence.0.expression', 1);

     

       54
       54
       -
         expect(ast).toHaveProperty('alternation.type', 'sequence');

     

       55
       55
       -
         expect(ast).toHaveProperty('alternation.sequence.0.expression', 2);

     

       22
       22
       +
         expect(ast).toHaveProperty('length', 1);

     

       23
       23
       +
         expect(ast).toHaveProperty('0.expression', 1);

     

       24
       24
       +
         expect(ast).toHaveProperty('alternation.0.expression', 2);

     

       56
       25
        
       

     

       57
       26
        
         ast = parseTag`${1}? | ${2}?`;

     

       58
       58
       -
         expect(ast).toHaveProperty('sequence.0.quantifier.type', 'quantifier');

     

       59
       59
       -
         expect(ast).toHaveProperty(

     

       60
       60
       -
           'alternation.sequence.0.quantifier.type',

     

       61
       61
       -
           'quantifier'

     

       62
       62
       -
         );

     

       27
       27
       +
         expect(ast).toHaveProperty('0.quantifier', '?');

     

       63
       28
        
       });

     

       64
       29
        
       

     

       65
       30
        
       it('supports groups with quantifiers', () => {

     

       66
       31
        
         let ast;

     

       67
       32
        
       

     

       68
       33
        
         ast = parseTag`(${1} ${2})`;

     

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

     

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

     

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

     

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

     

       73
       73
       -
         expect(ast).toHaveProperty('sequence.0.sequence.sequence.1.expression', 2);

     

       34
       34
       +
         expect(ast).toHaveProperty('length', 1);

     

       35
       35
       +
         expect(ast).toHaveProperty('0.sequence.length', 2);

     

       36
       36
       +
         expect(ast).toHaveProperty('0.sequence.0.expression', 1);

     

       37
       37
       +
         expect(ast).toHaveProperty('0.sequence.1.expression', 2);

     

       74
       38
        
       

     

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

     

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

     

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

     

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

     

       79
       79
       -
         expect(ast).toHaveProperty('sequence.0.sequence.sequence.0.quantifier', null);

     

       80
       80
       -
         expect(ast).toHaveProperty(

     

       81
       81
       -
           'sequence.0.sequence.sequence.1.quantifier.type',

     

       82
       82
       -
           'quantifier'

     

       83
       83
       -
         );

     

       40
       40
       +
         expect(ast).toHaveProperty('length', 1);

     

       41
       41
       +
         expect(ast).toHaveProperty('0.quantifier', '?');

     

       42
       42
       +
         expect(ast).toHaveProperty('0.sequence.0.quantifier', undefined);

     

       84
       43
        
       });

     

       85
       44
        
       

     

       86
       45
        
       it('supports non-capturing groups', () => {

     

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

     

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

     

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

     

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

     

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

     

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

     

       47
       47
       +
         expect(ast).toHaveProperty('length', 1);

     

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

     

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

     

       93
       50
        
       });

     

       94
       51
        
       

     

       95
       52
        
       it('supports positive lookahead groups', () => {

     

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

     

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

     

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

     

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

     

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

     

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

     

       54
       54
       +
         expect(ast).toHaveProperty('length', 1);

     

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

     

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

     

       102
       57
        
       });

     

       103
       58
        
       

     

       104
       59
        
       it('supports negative lookahead groups', () => {

     

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

     

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

     

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

     

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

     

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

     

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

     

       111
       111
       -
       });

     

       112
       112
       -
       

     

       113
       113
       -
       it('throws when a quantifier is combined with a lookahead', () => {

     

       114
       114
       -
         expect(() => parseTag`(?! ${1})+`).toThrow();

     

       115
       115
       -
         expect(() => parseTag`(?! ${1})?`).toThrow();

     

       116
       116
       -
         expect(() => parseTag`(?! ${1})*`).toThrow();

     

       61
       61
       +
         expect(ast).toHaveProperty('length', 1);

     

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

     

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

     

       117
       64
        
       });

     

       118
       65
        
       

     

       119
       66
        
       it('supports groups with alternates', () => {

     

       120
       67
        
         expect(parseTag`(${1} | ${2}) ${3}`).toMatchInlineSnapshot(`

     

       121
       121
       -
           Object {

     

       122
       122
       -
             "alternation": null,

     

       123
       123
       -
             "sequence": Array [

     

       124
       124
       -
               Object {

     

       125
       125
       -
                 "capturing": true,

     

       126
       126
       -
                 "lookahead": null,

     

       127
       127
       -
                 "quantifier": null,

     

       128
       128
       -
                 "sequence": Object {

     

       129
       129
       -
                   "alternation": Object {

     

       130
       130
       -
                     "alternation": null,

     

       131
       131
       -
                     "sequence": Array [

     

       132
       132
       -
                       Object {

     

       133
       133
       -
                         "expression": 2,

     

       134
       134
       -
                         "quantifier": null,

     

       135
       135
       -
                         "type": "expression",

     

       136
       136
       -
                       },

     

       137
       137
       -
                     ],

     

       138
       138
       -
                     "type": "sequence",

     

       139
       139
       -
                   },

     

       140
       140
       -
                   "sequence": Array [

     

       141
       141
       -
                     Object {

     

       142
       142
       -
                       "expression": 1,

     

       143
       143
       -
                       "quantifier": null,

     

       144
       144
       -
                       "type": "expression",

     

       145
       145
       -
                     },

     

       146
       146
       -
                   ],

     

       147
       147
       -
                   "type": "sequence",

     

       68
       68
       +
           Array [

     

       69
       69
       +
             Object {

     

       70
       70
       +
               "sequence": Array [

     

       71
       71
       +
                 Object {

     

       72
       72
       +
                   "expression": 1,

     

       148
       73
        
                 },

     

       149
       149
       -
                 "type": "group",

     

       150
       150
       -
               },

     

       151
       151
       -
               Object {

     

       152
       152
       -
                 "expression": 3,

     

       153
       153
       -
                 "quantifier": null,

     

       154
       154
       -
                 "type": "expression",

     

       155
       155
       -
               },

     

       156
       156
       -
             ],

     

       157
       157
       -
             "type": "sequence",

     

       158
       158
       -
           }

     

       74
       74
       +
               ],

     

       75
       75
       +
             },

     

       76
       76
       +
             Object {

     

       77
       77
       +
               "expression": 3,

     

       78
       78
       +
             },

     

       79
       79
       +
           ]

     

       159
       80
        
         `);

     

       160
       81
        
       });

+178 -22

yarn.lock

···

       2
       2
        
       # yarn lockfile v1

     

       3
       3
        
       

     

       4
       4
        
       

     

       5
       5
       +
       "@ampproject/remapping@0.2.0":

     

       6
       6
       +
         version "0.2.0"

     

       7
       7
       +
         resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-0.2.0.tgz#07290a5c0f5eac8a4c33d38aa0d15a3416db432e"

     

       8
       8
       +
         integrity sha512-a4EztS9/GOVQjX5Ol+Iz33TFhaXvYBF7aB6D8+Qz0/SCIxOm3UNRhGZiwcCuJ8/Ifc6NCogp3S48kc5hFxRpUw==

     

       9
       9
       +
         dependencies:

     

       10
       10
       +
           "@jridgewell/resolve-uri" "1.0.0"

     

       11
       11
       +
           sourcemap-codec "1.4.8"

     

       12
       12
       +
       

     

       13
       13
       +
       "@ampproject/rollup-plugin-closure-compiler@^0.26.0":

     

       14
       14
       +
         version "0.26.0"

     

       15
       15
       +
         resolved "https://registry.yarnpkg.com/@ampproject/rollup-plugin-closure-compiler/-/rollup-plugin-closure-compiler-0.26.0.tgz#69f8265e5fdbf3e26905eaaedc60cb5982bd6be0"

     

       16
       16
       +
         integrity sha512-wuHzGE6BDhDR0L7nUPlpQDPGiGnMw+b0B+cDPG0S5TatOmFNQva8KSNdBHan3L9RbvNyYXOXicuCrZtSoBfrBg==

     

       17
       17
       +
         dependencies:

     

       18
       18
       +
           "@ampproject/remapping" "0.2.0"

     

       19
       19
       +
           acorn "7.2.0"

     

       20
       20
       +
           acorn-walk "7.1.1"

     

       21
       21
       +
           estree-walker "2.0.1"

     

       22
       22
       +
           google-closure-compiler "20200517.0.0"

     

       23
       23
       +
           magic-string "0.25.7"

     

       24
       24
       +
           uuid "8.1.0"

     

       25
       25
       +
       

     

       5
       26
        
       "@babel/code-frame@^7.0.0", "@babel/code-frame@^7.8.3":

     

       6
       27
        
         version "7.8.3"

     

       7
       28
        
         resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.8.3.tgz#33e25903d7481181534e12ec0a25f16b6fcf419e"

     
···

       229
       250
        
           "@babel/helper-simple-access" "^7.8.3"

     

       230
       251
        
           babel-plugin-dynamic-import-node "^2.3.3"

     

       231
       252
        
       

     

       232
       232
       -
       "@babel/plugin-transform-object-assign@^7.8.3":

     

       233
       233
       -
         version "7.8.3"

     

       234
       234
       -
         resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-assign/-/plugin-transform-object-assign-7.8.3.tgz#dc3b8dd50ef03837868a37b7df791f64f288538e"

     

       235
       235
       -
         integrity sha512-i3LuN8tPDqUCRFu3dkzF2r1Nx0jp4scxtm7JxtIqI9he9Vk20YD+/zshdzR9JLsoBMlJlNR82a62vQExNEVx/Q==

     

       236
       236
       -
         dependencies:

     

       237
       237
       -
           "@babel/helper-plugin-utils" "^7.8.3"

     

       238
       238
       -
       

     

       239
       253
        
       "@babel/template@^7.3.3", "@babel/template@^7.8.3", "@babel/template@^7.8.6":

     

       240
       254
        
         version "7.8.6"

     

       241
       255
        
         resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.8.6.tgz#86b22af15f828dfb086474f964dcc3e39c43ce2b"

     
···

       463
       477
        
           "@types/yargs" "^15.0.0"

     

       464
       478
        
           chalk "^4.0.0"

     

       465
       479
        
       

     

       480
       480
       +
       "@jridgewell/resolve-uri@1.0.0":

     

       481
       481
       +
         version "1.0.0"

     

       482
       482
       +
         resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-1.0.0.tgz#3fdf5798f0b49e90155896f6291df186eac06c83"

     

       483
       483
       +
         integrity sha512-9oLAnygRMi8Q5QkYEU4XWK04B+nuoXoxjRvRxgjuChkLZFBja0YPSgdZ7dZtwhncLBcQe/I/E+fLuk5qxcYVJA==

     

       484
       484
       +
       

     

       466
       485
        
       "@rollup/plugin-buble@^0.21.3":

     

       467
       486
        
         version "0.21.3"

     

       468
       487
        
         resolved "https://registry.yarnpkg.com/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz#1649a915b1d051a4f430d40e7734a7f67a69b33e"

     
···

       505
       524
        
           estree-walker "^1.0.1"

     

       506
       525
        
           picomatch "^2.2.2"

     

       507
       526
        
       

     

       527
       527
       +
       "@rollup/pluginutils@^4.1.0":

     

       528
       528
       +
         version "4.1.0"

     

       529
       529
       +
         resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.1.0.tgz#0dcc61c780e39257554feb7f77207dceca13c838"

     

       530
       530
       +
         integrity sha512-TrBhfJkFxA+ER+ew2U2/fHbebhLT/l/2pRk0hfj9KusXUuRXd2v0R58AfaZK9VXDQ4TogOSEmICVrQAA3zFnHQ==

     

       531
       531
       +
         dependencies:

     

       532
       532
       +
           estree-walker "^2.0.1"

     

       533
       533
       +
           picomatch "^2.2.2"

     

       534
       534
       +
       

     

       508
       535
        
       "@samverschueren/stream-to-observable@^0.3.0":

     

       509
       536
        
         version "0.3.0"

     

       510
       537
        
         resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz#ecdf48d532c58ea477acfcab80348424f8d0662f"

     
···

       670
       697
        
         resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.2.0.tgz#4c66069173d6fdd68ed85239fc256226182b2ebe"

     

       671
       698
        
         integrity sha512-HiUX/+K2YpkpJ+SzBffkM/AQ2YE03S0U1kjTLVpoJdhZMOWy8qvXVN9JdLqv2QsaQ6MPYQIuNmwD8zOiYUofLQ==

     

       672
       699
        
       

     

       673
       673
       -
       acorn-walk@^7.1.1:

     

       700
       700
       +
       acorn-walk@7.1.1, acorn-walk@^7.1.1:

     

       674
       701
        
         version "7.1.1"

     

       675
       702
        
         resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-7.1.1.tgz#345f0dffad5c735e7373d2fec9a1023e6a44b83e"

     

       676
       703
        
         integrity sha512-wdlPY2tm/9XBr7QkKlq0WQVgiuGTX6YWPyRyBviSoScBuLfTVQhvwg6wJ369GJ/1nPfTLMfnrFIfjqVg6d+jQQ==

     

       677
       704
        
       

     

       705
       705
       +
       acorn@7.2.0, acorn@^7.1.1:

     

       706
       706
       +
         version "7.2.0"

     

       707
       707
       +
         resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.2.0.tgz#17ea7e40d7c8640ff54a694c889c26f31704effe"

     

       708
       708
       +
         integrity sha512-apwXVmYVpQ34m/i71vrApRrRKCWQnZZF1+npOD0WV5xZFfwWOmKGQ2RWlfdy9vWITsenisM8M0Qeq8agcFHNiQ==

     

       709
       709
       +
       

     

       678
       710
        
       acorn@^6.4.1:

     

       679
       711
        
         version "6.4.1"

     

       680
       712
        
         resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.1.tgz#531e58ba3f51b9dacb9a6646ca4debf5b14ca474"

     

       681
       713
        
         integrity sha512-ZVA9k326Nwrj3Cj9jlh3wGFutC2ZornPNARZwsNYqQYgN0EsV2d53w5RN/co65Ohn4sUAUtb1rSUAOD6XN9idA==

     

       682
       714
        
       

     

       683
       683
       -
       acorn@^7.1.1:

     

       684
       684
       -
         version "7.2.0"

     

       685
       685
       -
         resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.2.0.tgz#17ea7e40d7c8640ff54a694c889c26f31704effe"

     

       686
       686
       -
         integrity sha512-apwXVmYVpQ34m/i71vrApRrRKCWQnZZF1+npOD0WV5xZFfwWOmKGQ2RWlfdy9vWITsenisM8M0Qeq8agcFHNiQ==

     

       687
       687
       -
       

     

       688
       715
        
       aggregate-error@^3.0.0:

     

       689
       716
        
         version "3.0.1"

     

       690
       717
        
         resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.0.1.tgz#db2fe7246e536f40d9b5442a39e117d7dd6a24e0"

     
···

       1028
       1055
        
         resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"

     

       1029
       1056
        
         integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=

     

       1030
       1057
        
       

     

       1031
       1031
       -
       chalk@^2.0.0, chalk@^2.4.1, chalk@^2.4.2:

     

       1058
       1058
       +
       chalk@2.x, chalk@^2.0.0, chalk@^2.4.1, chalk@^2.4.2:

     

       1032
       1059
        
         version "2.4.2"

     

       1033
       1060
        
         resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"

     

       1034
       1061
        
         integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==

     
···

       1102
       1129
        
           strip-ansi "^6.0.0"

     

       1103
       1130
        
           wrap-ansi "^6.2.0"

     

       1104
       1131
        
       

     

       1132
       1132
       +
       clone-buffer@^1.0.0:

     

       1133
       1133
       +
         version "1.0.0"

     

       1134
       1134
       +
         resolved "https://registry.yarnpkg.com/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"

     

       1135
       1135
       +
         integrity sha1-4+JbIHrE5wGvch4staFnksrD3Fg=

     

       1136
       1136
       +
       

     

       1137
       1137
       +
       clone-stats@^1.0.0:

     

       1138
       1138
       +
         version "1.0.0"

     

       1139
       1139
       +
         resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-1.0.0.tgz#b3782dff8bb5474e18b9b6bf0fdfe782f8777680"

     

       1140
       1140
       +
         integrity sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=

     

       1141
       1141
       +
       

     

       1105
       1142
        
       clone@^1.0.2:

     

       1106
       1143
        
         version "1.0.4"

     

       1107
       1144
        
         resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"

     

       1108
       1145
        
         integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=

     

       1109
       1146
        
       

     

       1147
       1147
       +
       clone@^2.1.1:

     

       1148
       1148
       +
         version "2.1.2"

     

       1149
       1149
       +
         resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"

     

       1150
       1150
       +
         integrity sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=

     

       1151
       1151
       +
       

     

       1152
       1152
       +
       cloneable-readable@^1.0.0:

     

       1153
       1153
       +
         version "1.1.3"

     

       1154
       1154
       +
         resolved "https://registry.yarnpkg.com/cloneable-readable/-/cloneable-readable-1.1.3.tgz#120a00cb053bfb63a222e709f9683ea2e11d8cec"

     

       1155
       1155
       +
         integrity sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==

     

       1156
       1156
       +
         dependencies:

     

       1157
       1157
       +
           inherits "^2.0.1"

     

       1158
       1158
       +
           process-nextick-args "^2.0.0"

     

       1159
       1159
       +
           readable-stream "^2.3.5"

     

       1160
       1160
       +
       

     

       1110
       1161
        
       co@^4.6.0:

     

       1111
       1162
        
         version "4.6.0"

     

       1112
       1163
        
         resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"

     
···

       1193
       1244
        
         resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"

     

       1194
       1245
        
         integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=

     

       1195
       1246
        
       

     

       1196
       1196
       -
       core-util-is@1.0.2:

     

       1247
       1247
       +
       core-util-is@1.0.2, core-util-is@~1.0.0:

     

       1197
       1248
        
         version "1.0.2"

     

       1198
       1249
        
         resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"

     

       1199
       1250
        
         integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=

     
···

       1461
       1512
        
         resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"

     

       1462
       1513
        
         integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==

     

       1463
       1514
        
       

     

       1515
       1515
       +
       estree-walker@2.0.1, estree-walker@^2.0.1:

     

       1516
       1516
       +
         version "2.0.1"

     

       1517
       1517
       +
         resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.1.tgz#f8e030fb21cefa183b44b7ad516b747434e7a3e0"

     

       1518
       1518
       +
         integrity sha512-tF0hv+Yi2Ot1cwj9eYHtxC0jB9bmjacjQs6ZBTj82H8JwUywFuc+7E83NWfNMwHXZc11mjfFcVXPe9gEP4B8dg==

     

       1519
       1519
       +
       

     

       1464
       1520
        
       estree-walker@^0.6.1:

     

       1465
       1521
        
         version "0.6.1"

     

       1466
       1522
        
         resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.6.1.tgz#53049143f40c6eb918b23671d1fe3219f3a1b362"

     
···

       1743
       1799
        
         resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"

     

       1744
       1800
        
         integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==

     

       1745
       1801
        
       

     

       1802
       1802
       +
       google-closure-compiler-java@^20200517.0.0:

     

       1803
       1803
       +
         version "20200517.0.0"

     

       1804
       1804
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler-java/-/google-closure-compiler-java-20200517.0.0.tgz#778370c22273c9085f4cf959ce063f8f112c02ac"

     

       1805
       1805
       +
         integrity sha512-JVZBiyyXwcYi6Yc3lO6dF2hMLJA4OzPm4/mgsem/tF1vk2HsWTnL3GTaBsPB2ENVZp0hoqsd4KgpPiG9ssNWxw==

     

       1806
       1806
       +
       

     

       1807
       1807
       +
       google-closure-compiler-js@^20200517.0.0:

     

       1808
       1808
       +
         version "20200517.0.0"

     

       1809
       1809
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler-js/-/google-closure-compiler-js-20200517.0.0.tgz#9cb0861f764073d1c4d3b7453b74073ccb1ecfb1"

     

       1810
       1810
       +
         integrity sha512-dz6dOUHx5nhdIqMRXacAYS8aJfLvw4IKxGg28Hq/zeeDPHlX3P3iBK20NgFDfT8zdushThymtMqChSy7C5eyfA==

     

       1811
       1811
       +
       

     

       1812
       1812
       +
       google-closure-compiler-linux@^20200517.0.0:

     

       1813
       1813
       +
         version "20200517.0.0"

     

       1814
       1814
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler-linux/-/google-closure-compiler-linux-20200517.0.0.tgz#2b9ecb634130060174aff5c52329a694ea4be68b"

     

       1815
       1815
       +
         integrity sha512-S5xPh6TtP+ESzZrmQLcDDqtZAsCVTbdI4VS98wQlN6IMZTd94nAnOCg9mrxQNAgop2t4sdsv/KuH0BGPUWEZ+w==

     

       1816
       1816
       +
       

     

       1817
       1817
       +
       google-closure-compiler-osx@^20200517.0.0:

     

       1818
       1818
       +
         version "20200517.0.0"

     

       1819
       1819
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler-osx/-/google-closure-compiler-osx-20200517.0.0.tgz#9394e9a2fd97e3729fc3bd2abcffff6aab2cfcaa"

     

       1820
       1820
       +
         integrity sha512-FWIcsKqLllLjdOBZd7azijVaObydgRd0obVNi63eUfC5MX6T4qxKumGCyor2UCNY6by2ESz+PlGqCFzFhZ6b2g==

     

       1821
       1821
       +
       

     

       1822
       1822
       +
       google-closure-compiler-windows@^20200517.0.0:

     

       1823
       1823
       +
         version "20200517.0.0"

     

       1824
       1824
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler-windows/-/google-closure-compiler-windows-20200517.0.0.tgz#c5cdde438c29458666a83358567b12072924ed6c"

     

       1825
       1825
       +
         integrity sha512-UXhjRGwS8deTkRla/riyVq3psscgMuw78lepEPtq5NgbumgJzY2+IQP9q+4MVOfJW58Rv0JUWKAFOnBBSZWcAQ==

     

       1826
       1826
       +
       

     

       1827
       1827
       +
       google-closure-compiler@20200517.0.0:

     

       1828
       1828
       +
         version "20200517.0.0"

     

       1829
       1829
       +
         resolved "https://registry.yarnpkg.com/google-closure-compiler/-/google-closure-compiler-20200517.0.0.tgz#6c47f99fc1be59bd4f9e23c5a8f2e66d64b54143"

     

       1830
       1830
       +
         integrity sha512-80W9zBS9Ajk1T5InWCfsoPohDmo5T1AAyw1rHh5+dgb/jPgwC65KhY+oJozTncf+/7tyQHJXozTARwhSlBUcMg==

     

       1831
       1831
       +
         dependencies:

     

       1832
       1832
       +
           chalk "2.x"

     

       1833
       1833
       +
           google-closure-compiler-java "^20200517.0.0"

     

       1834
       1834
       +
           google-closure-compiler-js "^20200517.0.0"

     

       1835
       1835
       +
           minimist "1.x"

     

       1836
       1836
       +
           vinyl "2.x"

     

       1837
       1837
       +
           vinyl-sourcemaps-apply "^0.2.0"

     

       1838
       1838
       +
         optionalDependencies:

     

       1839
       1839
       +
           google-closure-compiler-linux "^20200517.0.0"

     

       1840
       1840
       +
           google-closure-compiler-osx "^20200517.0.0"

     

       1841
       1841
       +
           google-closure-compiler-windows "^20200517.0.0"

     

       1842
       1842
       +
       

     

       1746
       1843
        
       graceful-fs@^4.1.2, graceful-fs@^4.2.4:

     

       1747
       1844
        
         version "4.2.4"

     

       1748
       1845
        
         resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb"

     
···

       1907
       2004
        
           once "^1.3.0"

     

       1908
       2005
        
           wrappy "1"

     

       1909
       2006
        
       

     

       1910
       1910
       -
       inherits@2:

     

       2007
       2007
       +
       inherits@2, inherits@^2.0.1, inherits@~2.0.3:

     

       1911
       2008
        
         version "2.0.4"

     

       1912
       2009
        
         resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"

     

       1913
       2010
        
         integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==

     
···

       2104
       2201
        
         dependencies:

     

       2105
       2202
        
           is-docker "^2.0.0"

     

       2106
       2203
        
       

     

       2107
       2107
       -
       isarray@1.0.0:

     

       2204
       2204
       +
       isarray@1.0.0, isarray@~1.0.0:

     

       2108
       2205
        
         version "1.0.0"

     

       2109
       2206
        
         resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"

     

       2110
       2207
        
         integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=

     
···

       2759
       2856
        
           slice-ansi "^4.0.0"

     

       2760
       2857
        
           wrap-ansi "^6.2.0"

     

       2761
       2858
        
       

     

       2762
       2762
       -
       magic-string@^0.25.0, magic-string@^0.25.2, magic-string@^0.25.7:

     

       2859
       2859
       +
       magic-string@0.25.7, magic-string@^0.25.0, magic-string@^0.25.2, magic-string@^0.25.7:

     

       2763
       2860
        
         version "0.25.7"

     

       2764
       2861
        
         resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051"

     

       2765
       2862
        
         integrity sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==

     
···

       2853
       2950
        
         dependencies:

     

       2854
       2951
        
           brace-expansion "^1.1.7"

     

       2855
       2952
        
       

     

       2856
       2856
       -
       minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5:

     

       2953
       2953
       +
       minimist@1.x, minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5:

     

       2857
       2954
        
         version "1.2.5"

     

       2858
       2955
        
         resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"

     

       2859
       2956
        
         integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==

     
···

       3241
       3338
        
           ansi-styles "^4.0.0"

     

       3242
       3339
        
           react-is "^16.12.0"

     

       3243
       3340
        
       

     

       3341
       3341
       +
       process-nextick-args@^2.0.0, process-nextick-args@~2.0.0:

     

       3342
       3342
       +
         version "2.0.1"

     

       3343
       3343
       +
         resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"

     

       3344
       3344
       +
         integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==

     

       3345
       3345
       +
       

     

       3244
       3346
        
       prompts@^2.0.1:

     

       3245
       3347
        
         version "2.3.2"

     

       3246
       3348
        
         resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.3.2.tgz#480572d89ecf39566d2bd3fe2c9fccb7c4c0b068"

     
···

       3305
       3407
        
           parse-json "^5.0.0"

     

       3306
       3408
        
           type-fest "^0.6.0"

     

       3307
       3409
        
       

     

       3410
       3410
       +
       readable-stream@^2.3.5:

     

       3411
       3411
       +
         version "2.3.7"

     

       3412
       3412
       +
         resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"

     

       3413
       3413
       +
         integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==

     

       3414
       3414
       +
         dependencies:

     

       3415
       3415
       +
           core-util-is "~1.0.0"

     

       3416
       3416
       +
           inherits "~2.0.3"

     

       3417
       3417
       +
           isarray "~1.0.0"

     

       3418
       3418
       +
           process-nextick-args "~2.0.0"

     

       3419
       3419
       +
           safe-buffer "~5.1.1"

     

       3420
       3420
       +
           string_decoder "~1.1.1"

     

       3421
       3421
       +
           util-deprecate "~1.0.1"

     

       3422
       3422
       +
       

     

       3308
       3423
        
       regenerate-unicode-properties@^8.0.2:

     

       3309
       3424
        
         version "8.2.0"

     

       3310
       3425
        
         resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"

     
···

       3364
       3479
        
         resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"

     

       3365
       3480
        
         integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=

     

       3366
       3481
        
       

     

       3482
       3482
       +
       replace-ext@^1.0.0:

     

       3483
       3483
       +
         version "1.0.1"

     

       3484
       3484
       +
         resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-1.0.1.tgz#2d6d996d04a15855d967443631dd5f77825b016a"

     

       3485
       3485
       +
         integrity sha512-yD5BHCe7quCgBph4rMQ+0KkIRKwWCrHDOX1p1Gp6HwjPM5kVoCdKGNhN7ydqqsX6lJEnQDKZ/tFMiEdQ1dvPEw==

     

       3486
       3486
       +
       

     

       3367
       3487
        
       request-promise-core@1.1.3:

     

       3368
       3488
        
         version "1.1.3"

     

       3369
       3489
        
         resolved "https://registry.yarnpkg.com/request-promise-core/-/request-promise-core-1.1.3.tgz#e9a3c081b51380dfea677336061fea879a829ee9"

     
···

       3504
       3624
        
         resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"

     

       3505
       3625
        
         integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==

     

       3506
       3626
        
       

     

       3507
       3507
       -
       safe-buffer@~5.1.1:

     

       3627
       3627
       +
       safe-buffer@~5.1.0, safe-buffer@~5.1.1:

     

       3508
       3628
        
         version "5.1.2"

     

       3509
       3629
        
         resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"

     

       3510
       3630
        
         integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==

     
···

       3704
       3824
        
         resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"

     

       3705
       3825
        
         integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=

     

       3706
       3826
        
       

     

       3707
       3707
       -
       source-map@^0.5.0, source-map@^0.5.6:

     

       3827
       3827
       +
       source-map@^0.5.0, source-map@^0.5.1, source-map@^0.5.6:

     

       3708
       3828
        
         version "0.5.7"

     

       3709
       3829
        
         resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"

     

       3710
       3830
        
         integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=

     
···

       3719
       3839
        
         resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"

     

       3720
       3840
        
         integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==

     

       3721
       3841
        
       

     

       3722
       3722
       -
       sourcemap-codec@^1.4.4:

     

       3842
       3842
       +
       sourcemap-codec@1.4.8, sourcemap-codec@^1.4.4:

     

       3723
       3843
        
         version "1.4.8"

     

       3724
       3844
        
         resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"

     

       3725
       3845
        
         integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==

     
···

       3860
       3980
        
         dependencies:

     

       3861
       3981
        
           define-properties "^1.1.3"

     

       3862
       3982
        
           es-abstract "^1.17.5"

     

       3983
       3983
       +
       

     

       3984
       3984
       +
       string_decoder@~1.1.1:

     

       3985
       3985
       +
         version "1.1.1"

     

       3986
       3986
       +
         resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"

     

       3987
       3987
       +
         integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==

     

       3988
       3988
       +
         dependencies:

     

       3989
       3989
       +
           safe-buffer "~5.1.0"

     

       3863
       3990
        
       

     

       3864
       3991
        
       stringify-object@^3.3.0:

     

       3865
       3992
        
         version "3.3.0"

     
···

       4126
       4253
        
         resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"

     

       4127
       4254
        
         integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==

     

       4128
       4255
        
       

     

       4256
       4256
       +
       util-deprecate@~1.0.1:

     

       4257
       4257
       +
         version "1.0.2"

     

       4258
       4258
       +
         resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"

     

       4259
       4259
       +
         integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=

     

       4260
       4260
       +
       

     

       4261
       4261
       +
       uuid@8.1.0:

     

       4262
       4262
       +
         version "8.1.0"

     

       4263
       4263
       +
         resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.1.0.tgz#6f1536eb43249f473abc6bd58ff983da1ca30d8d"

     

       4264
       4264
       +
         integrity sha512-CI18flHDznR0lq54xBycOVmphdCYnQLKn8abKn7PXUiKUGdEd+/l9LWNJmugXel4hXq7S+RMNl34ecyC9TntWg==

     

       4265
       4265
       +
       

     

       4129
       4266
        
       uuid@^3.3.2:

     

       4130
       4267
        
         version "3.4.0"

     

       4131
       4268
        
         resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"

     
···

       4161
       4298
        
           assert-plus "^1.0.0"

     

       4162
       4299
        
           core-util-is "1.0.2"

     

       4163
       4300
        
           extsprintf "^1.2.0"

     

       4301
       4301
       +
       

     

       4302
       4302
       +
       vinyl-sourcemaps-apply@^0.2.0:

     

       4303
       4303
       +
         version "0.2.1"

     

       4304
       4304
       +
         resolved "https://registry.yarnpkg.com/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz#ab6549d61d172c2b1b87be5c508d239c8ef87705"

     

       4305
       4305
       +
         integrity sha1-q2VJ1h0XLCsbh75cUI0jnI74dwU=

     

       4306
       4306
       +
         dependencies:

     

       4307
       4307
       +
           source-map "^0.5.1"

     

       4308
       4308
       +
       

     

       4309
       4309
       +
       vinyl@2.x:

     

       4310
       4310
       +
         version "2.2.1"

     

       4311
       4311
       +
         resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-2.2.1.tgz#23cfb8bbab5ece3803aa2c0a1eb28af7cbba1974"

     

       4312
       4312
       +
         integrity sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==

     

       4313
       4313
       +
         dependencies:

     

       4314
       4314
       +
           clone "^2.1.1"

     

       4315
       4315
       +
           clone-buffer "^1.0.0"

     

       4316
       4316
       +
           clone-stats "^1.0.0"

     

       4317
       4317
       +
           cloneable-readable "^1.0.0"

     

       4318
       4318
       +
           remove-trailing-separator "^1.0.1"

     

       4319
       4319
       +
           replace-ext "^1.0.0"

     

       4164
       4320
        
       

     

       4165
       4321
        
       w3c-hr-time@^1.0.2:

     

       4166
       4322
        
         version "1.0.2"