solc-typed-ast 18.2.4 → 18.2.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (30) hide show
  1. package/dist/ast/ast_node_factory.d.ts.map +1 -1
  2. package/dist/ast/ast_node_factory.js +1 -0
  3. package/dist/ast/ast_node_factory.js.map +1 -1
  4. package/dist/ast/implementation/declaration/contract_definition.d.ts +6 -1
  5. package/dist/ast/implementation/declaration/contract_definition.d.ts.map +1 -1
  6. package/dist/ast/implementation/declaration/contract_definition.js +2 -1
  7. package/dist/ast/implementation/declaration/contract_definition.js.map +1 -1
  8. package/dist/ast/legacy/contract_definition_processor.d.ts.map +1 -1
  9. package/dist/ast/legacy/contract_definition_processor.js +1 -0
  10. package/dist/ast/legacy/contract_definition_processor.js.map +1 -1
  11. package/dist/ast/modern/contract_definition_processor.d.ts.map +1 -1
  12. package/dist/ast/modern/contract_definition_processor.js +6 -0
  13. package/dist/ast/modern/contract_definition_processor.js.map +1 -1
  14. package/dist/ast/writing/ast_mapping.d.ts.map +1 -1
  15. package/dist/ast/writing/ast_mapping.js +3 -0
  16. package/dist/ast/writing/ast_mapping.js.map +1 -1
  17. package/dist/compile/constants.d.ts.map +1 -1
  18. package/dist/compile/constants.js +2 -1
  19. package/dist/compile/constants.js.map +1 -1
  20. package/dist/compile/inference/file_level_definitions_parser.d.ts.map +1 -1
  21. package/dist/compile/inference/file_level_definitions_parser.js +1023 -636
  22. package/dist/compile/inference/file_level_definitions_parser.js.map +1 -1
  23. package/dist/misc/utils.d.ts +1 -0
  24. package/dist/misc/utils.d.ts.map +1 -1
  25. package/dist/misc/utils.js +9 -1
  26. package/dist/misc/utils.js.map +1 -1
  27. package/dist/types/infer.d.ts.map +1 -1
  28. package/dist/types/infer.js +13 -4
  29. package/dist/types/infer.js.map +1 -1
  30. package/package.json +1 -1
package/dist/compile/inference/file_level_definitions_parser.js CHANGED
@@ -209,7 +209,8 @@ function peg$parse(input, options) {
209
209
  const peg$c15 = ".";
210
210
  const peg$c16 = peg$literalExpectation(".", false);
211
211
  const peg$c17 = function (head, tail) { return text(); };
212
- const peg$c18 = function (abstract, kind, name, bases, body) {
212
+ const peg$c18 = function (loc) { return loc; };
213
+ const peg$c19 = function (abstract, kind, name, bases, layout, body) {
213
214
  return {
214
215
  abstract: abstract !== null,
215
216
  kind: FileLevelNodeKind.Contract,
@@ -220,7 +221,7 @@ function peg$parse(input, options) {
220
221
  body
221
222
  };
222
223
  };
223
- const peg$c19 = function (name, body) {
224
+ const peg$c20 = function (name, body) {
224
225
  return {
225
226
  kind: FileLevelNodeKind.Struct,
226
227
  location: location(),
@@ -228,7 +229,7 @@ function peg$parse(input, options) {
228
229
  body
229
230
  };
230
231
  };
231
- const peg$c20 = function (name, body) {
232
+ const peg$c21 = function (name, body) {
232
233
  return {
233
234
  kind: FileLevelNodeKind.Enum,
234
235
  location: location(),
@@ -236,7 +237,7 @@ function peg$parse(input, options) {
236
237
  body
237
238
  };
238
239
  };
239
- const peg$c21 = function (name, args, isAnonymous) {
240
+ const peg$c22 = function (name, args, isAnonymous) {
240
241
  return {
241
242
  kind: FileLevelNodeKind.Event,
242
243
  location: location(),
@@ -245,7 +246,7 @@ function peg$parse(input, options) {
245
246
  anonymous: isAnonymous !== null
246
247
  };
247
248
  };
248
- const peg$c22 = function (name, args) {
249
+ const peg$c23 = function (name, args) {
249
250
  return {
250
251
  kind: FileLevelNodeKind.Error,
251
252
  location: location(),
@@ -253,7 +254,7 @@ function peg$parse(input, options) {
253
254
  args
254
255
  };
255
256
  };
256
- const peg$c23 = function (name, valueType) {
257
+ const peg$c24 = function (name, valueType) {
257
258
  return {
258
259
  kind: FileLevelNodeKind.UserValueType,
259
260
  location: location(),
@@ -261,53 +262,53 @@ function peg$parse(input, options) {
261
262
  valueType
262
263
  };
263
264
  };
264
- const peg$c24 = "&";
265
- const peg$c25 = peg$literalExpectation("&", false);
266
- const peg$c26 = "|";
267
- const peg$c27 = peg$literalExpectation("|", false);
268
- const peg$c28 = "^";
269
- const peg$c29 = peg$literalExpectation("^", false);
270
- const peg$c30 = "~";
271
- const peg$c31 = peg$literalExpectation("~", false);
272
- const peg$c32 = "+";
273
- const peg$c33 = peg$literalExpectation("+", false);
274
- const peg$c34 = "-";
275
- const peg$c35 = peg$literalExpectation("-", false);
276
- const peg$c36 = "*";
277
- const peg$c37 = peg$literalExpectation("*", false);
278
- const peg$c38 = "/";
279
- const peg$c39 = peg$literalExpectation("/", false);
280
- const peg$c40 = "%";
281
- const peg$c41 = peg$literalExpectation("%", false);
282
- const peg$c42 = "==";
283
- const peg$c43 = peg$literalExpectation("==", false);
284
- const peg$c44 = "!=";
285
- const peg$c45 = peg$literalExpectation("!=", false);
286
- const peg$c46 = "<=";
287
- const peg$c47 = peg$literalExpectation("<=", false);
288
- const peg$c48 = ">=";
289
- const peg$c49 = peg$literalExpectation(">=", false);
290
- const peg$c50 = "<";
291
- const peg$c51 = peg$literalExpectation("<", false);
292
- const peg$c52 = ">";
293
- const peg$c53 = peg$literalExpectation(">", false);
294
- const peg$c54 = function (name, operator) {
265
+ const peg$c25 = "&";
266
+ const peg$c26 = peg$literalExpectation("&", false);
267
+ const peg$c27 = "|";
268
+ const peg$c28 = peg$literalExpectation("|", false);
269
+ const peg$c29 = "^";
270
+ const peg$c30 = peg$literalExpectation("^", false);
271
+ const peg$c31 = "~";
272
+ const peg$c32 = peg$literalExpectation("~", false);
273
+ const peg$c33 = "+";
274
+ const peg$c34 = peg$literalExpectation("+", false);
275
+ const peg$c35 = "-";
276
+ const peg$c36 = peg$literalExpectation("-", false);
277
+ const peg$c37 = "*";
278
+ const peg$c38 = peg$literalExpectation("*", false);
279
+ const peg$c39 = "/";
280
+ const peg$c40 = peg$literalExpectation("/", false);
281
+ const peg$c41 = "%";
282
+ const peg$c42 = peg$literalExpectation("%", false);
283
+ const peg$c43 = "==";
284
+ const peg$c44 = peg$literalExpectation("==", false);
285
+ const peg$c45 = "!=";
286
+ const peg$c46 = peg$literalExpectation("!=", false);
287
+ const peg$c47 = "<=";
288
+ const peg$c48 = peg$literalExpectation("<=", false);
289
+ const peg$c49 = ">=";
290
+ const peg$c50 = peg$literalExpectation(">=", false);
291
+ const peg$c51 = "<";
292
+ const peg$c52 = peg$literalExpectation("<", false);
293
+ const peg$c53 = ">";
294
+ const peg$c54 = peg$literalExpectation(">", false);
295
+ const peg$c55 = function (name, operator) {
295
296
  if (operator === null) {
296
297
  return name;
297
298
  }
298
299
  return { name, operator: operator[3] };
299
300
  };
300
- const peg$c55 = function (head, tail) {
301
+ const peg$c56 = function (head, tail) {
301
302
  return tail.reduce((acc, el) => {
302
303
  acc.push(el[3]);
303
304
  return acc;
304
305
  }, [head]);
305
306
  };
306
- const peg$c56 = "{";
307
- const peg$c57 = peg$literalExpectation("{", false);
308
- const peg$c58 = "}";
309
- const peg$c59 = peg$literalExpectation("}", false);
310
- const peg$c60 = function (utils, typeName, isGlobal) {
307
+ const peg$c57 = "{";
308
+ const peg$c58 = peg$literalExpectation("{", false);
309
+ const peg$c59 = "}";
310
+ const peg$c60 = peg$literalExpectation("}", false);
311
+ const peg$c61 = function (utils, typeName, isGlobal) {
311
312
  const node = {
312
313
  kind: FileLevelNodeKind.UsingForDirective,
313
314
  location: location(),
@@ -322,168 +323,174 @@ function peg$parse(input, options) {
322
323
  }
323
324
  return node;
324
325
  };
325
- const peg$c61 = /^[^"'\/;]/;
326
- const peg$c62 = peg$classExpectation(["\"", "'", "/", ";"], true, false);
327
- const peg$c63 = /^[^\/'"*;]/;
328
- const peg$c64 = peg$classExpectation(["/", "'", "\"", "*", ";"], true, false);
329
- const peg$c65 = /^[^"'()\/]/;
330
- const peg$c66 = peg$classExpectation(["\"", "'", "(", ")", "/"], true, false);
331
- const peg$c67 = /^[^\/*"'()]/;
332
- const peg$c68 = peg$classExpectation(["/", "*", "\"", "'", "(", ")"], true, false);
333
- const peg$c69 = /^[^"'{}\/]/;
334
- const peg$c70 = peg$classExpectation(["\"", "'", "{", "}", "/"], true, false);
335
- const peg$c71 = /^[^\/*'"{}]/;
336
- const peg$c72 = peg$classExpectation(["/", "*", "'", "\"", "{", "}"], true, false);
337
- const peg$c73 = "\t";
338
- const peg$c74 = peg$literalExpectation("\t", false);
339
- const peg$c75 = "\v";
340
- const peg$c76 = peg$literalExpectation("\v", false);
341
- const peg$c77 = "\f";
342
- const peg$c78 = peg$literalExpectation("\f", false);
343
- const peg$c79 = " ";
344
- const peg$c80 = peg$literalExpectation(" ", false);
345
- const peg$c81 = "\xA0";
346
- const peg$c82 = peg$literalExpectation("\xA0", false);
347
- const peg$c83 = "\uFEFF";
348
- const peg$c84 = peg$literalExpectation("\uFEFF", false);
349
- const peg$c85 = /^[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
350
- const peg$c86 = peg$classExpectation([" ", "\xA0", "\u1680", ["\u2000", "\u200A"], "\u202F", "\u205F", "\u3000"], false, false);
351
- const peg$c87 = /^[\n\r\u2028\u2029]/;
352
- const peg$c88 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], false, false);
353
- const peg$c89 = "\n";
354
- const peg$c90 = peg$literalExpectation("\n", false);
355
- const peg$c91 = "\r\n";
356
- const peg$c92 = peg$literalExpectation("\r\n", false);
357
- const peg$c93 = "\r";
358
- const peg$c94 = peg$literalExpectation("\r", false);
359
- const peg$c95 = "\u2028";
360
- const peg$c96 = peg$literalExpectation("\u2028", false);
361
- const peg$c97 = "\u2029";
362
- const peg$c98 = peg$literalExpectation("\u2029", false);
363
- const peg$c99 = /^[^\n\r\u2028\u2029]/;
364
- const peg$c100 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], true, false);
365
- const peg$c101 = "//";
366
- const peg$c102 = peg$literalExpectation("//", false);
367
- const peg$c103 = function () { return text(); };
368
- const peg$c104 = "/*";
369
- const peg$c105 = peg$literalExpectation("/*", false);
370
- const peg$c106 = /^[^*]/;
371
- const peg$c107 = peg$classExpectation(["*"], true, false);
372
- const peg$c108 = /^[^\/*]/;
373
- const peg$c109 = peg$classExpectation(["/", "*"], true, false);
374
- const peg$c110 = "import";
375
- const peg$c111 = peg$literalExpectation("import", false);
376
- const peg$c112 = "as";
377
- const peg$c113 = peg$literalExpectation("as", false);
378
- const peg$c114 = "from";
379
- const peg$c115 = peg$literalExpectation("from", false);
380
- const peg$c116 = "(";
381
- const peg$c117 = peg$literalExpectation("(", false);
382
- const peg$c118 = ")";
383
- const peg$c119 = peg$literalExpectation(")", false);
384
- const peg$c120 = "[";
385
- const peg$c121 = peg$literalExpectation("[", false);
386
- const peg$c122 = "]";
387
- const peg$c123 = peg$literalExpectation("]", false);
388
- const peg$c124 = ",";
389
- const peg$c125 = peg$literalExpectation(",", false);
390
- const peg$c126 = "=";
391
- const peg$c127 = peg$literalExpectation("=", false);
392
- const peg$c128 = "address";
393
- const peg$c129 = peg$literalExpectation("address", false);
394
- const peg$c130 = "payable";
395
- const peg$c131 = peg$literalExpectation("payable", false);
396
- const peg$c132 = "abstract";
397
- const peg$c133 = peg$literalExpectation("abstract", false);
398
- const peg$c134 = "contract";
399
- const peg$c135 = peg$literalExpectation("contract", false);
400
- const peg$c136 = "library";
401
- const peg$c137 = peg$literalExpectation("library", false);
402
- const peg$c138 = "interface";
403
- const peg$c139 = peg$literalExpectation("interface", false);
404
- const peg$c140 = "struct";
405
- const peg$c141 = peg$literalExpectation("struct", false);
406
- const peg$c142 = "enum";
407
- const peg$c143 = peg$literalExpectation("enum", false);
408
- const peg$c144 = "constant";
409
- const peg$c145 = peg$literalExpectation("constant", false);
410
- const peg$c146 = "function";
411
- const peg$c147 = peg$literalExpectation("function", false);
412
- const peg$c148 = "is";
413
- const peg$c149 = peg$literalExpectation("is", false);
414
- const peg$c150 = "type";
415
- const peg$c151 = peg$literalExpectation("type", false);
416
- const peg$c152 = "returns";
417
- const peg$c153 = peg$literalExpectation("returns", false);
418
- const peg$c154 = "pragma";
419
- const peg$c155 = peg$literalExpectation("pragma", false);
420
- const peg$c156 = "error";
421
- const peg$c157 = peg$literalExpectation("error", false);
422
- const peg$c158 = "event";
423
- const peg$c159 = peg$literalExpectation("event", false);
424
- const peg$c160 = "using";
425
- const peg$c161 = peg$literalExpectation("using", false);
426
- const peg$c162 = "for";
427
- const peg$c163 = peg$literalExpectation("for", false);
428
- const peg$c164 = "global";
429
- const peg$c165 = peg$literalExpectation("global", false);
430
- const peg$c166 = "anonymous";
431
- const peg$c167 = peg$literalExpectation("anonymous", false);
432
- const peg$c168 = "'";
433
- const peg$c169 = peg$literalExpectation("'", false);
434
- const peg$c170 = function (chars) { return chars.join(""); };
435
- const peg$c171 = "\"";
436
- const peg$c172 = peg$literalExpectation("\"", false);
437
- const peg$c173 = peg$anyExpectation();
438
- const peg$c174 = "\\";
439
- const peg$c175 = peg$literalExpectation("\\", false);
440
- const peg$c176 = function (sequence) { return sequence; };
441
- const peg$c177 = function () { return ""; };
442
- const peg$c178 = "0";
443
- const peg$c179 = peg$literalExpectation("0", false);
444
- const peg$c180 = function () { return "\0"; };
445
- const peg$c181 = "b";
446
- const peg$c182 = peg$literalExpectation("b", false);
447
- const peg$c183 = function () { return "\b"; };
448
- const peg$c184 = "f";
449
- const peg$c185 = peg$literalExpectation("f", false);
450
- const peg$c186 = function () { return "\f"; };
451
- const peg$c187 = "n";
452
- const peg$c188 = peg$literalExpectation("n", false);
453
- const peg$c189 = function () { return "\n"; };
454
- const peg$c190 = "r";
455
- const peg$c191 = peg$literalExpectation("r", false);
456
- const peg$c192 = function () { return "\r"; };
457
- const peg$c193 = "t";
458
- const peg$c194 = peg$literalExpectation("t", false);
459
- const peg$c195 = function () { return "\t"; };
460
- const peg$c196 = "v";
461
- const peg$c197 = peg$literalExpectation("v", false);
462
- const peg$c198 = function () { return "\v"; };
463
- const peg$c199 = /^[0-9a-f]/i;
464
- const peg$c200 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true);
465
- const peg$c201 = /^[0-9]/;
466
- const peg$c202 = peg$classExpectation([["0", "9"]], false, false);
467
- const peg$c203 = "x";
468
- const peg$c204 = peg$literalExpectation("x", false);
469
- const peg$c205 = "u";
470
- const peg$c206 = peg$literalExpectation("u", false);
471
- const peg$c207 = function (digits) {
326
+ const peg$c62 = /^[^"'\/;]/;
327
+ const peg$c63 = peg$classExpectation(["\"", "'", "/", ";"], true, false);
328
+ const peg$c64 = /^[^\/'"*;]/;
329
+ const peg$c65 = peg$classExpectation(["/", "'", "\"", "*", ";"], true, false);
330
+ const peg$c66 = /^[^"'()\/]/;
331
+ const peg$c67 = peg$classExpectation(["\"", "'", "(", ")", "/"], true, false);
332
+ const peg$c68 = /^[^\/*"'()]/;
333
+ const peg$c69 = peg$classExpectation(["/", "*", "\"", "'", "(", ")"], true, false);
334
+ const peg$c70 = /^[^"'()\/{]/;
335
+ const peg$c71 = peg$classExpectation(["\"", "'", "(", ")", "/", "{"], true, false);
336
+ const peg$c72 = /^[^"'{}\/]/;
337
+ const peg$c73 = peg$classExpectation(["\"", "'", "{", "}", "/"], true, false);
338
+ const peg$c74 = /^[^\/*'"{}]/;
339
+ const peg$c75 = peg$classExpectation(["/", "*", "'", "\"", "{", "}"], true, false);
340
+ const peg$c76 = "\t";
341
+ const peg$c77 = peg$literalExpectation("\t", false);
342
+ const peg$c78 = "\v";
343
+ const peg$c79 = peg$literalExpectation("\v", false);
344
+ const peg$c80 = "\f";
345
+ const peg$c81 = peg$literalExpectation("\f", false);
346
+ const peg$c82 = " ";
347
+ const peg$c83 = peg$literalExpectation(" ", false);
348
+ const peg$c84 = "\xA0";
349
+ const peg$c85 = peg$literalExpectation("\xA0", false);
350
+ const peg$c86 = "\uFEFF";
351
+ const peg$c87 = peg$literalExpectation("\uFEFF", false);
352
+ const peg$c88 = /^[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
353
+ const peg$c89 = peg$classExpectation([" ", "\xA0", "\u1680", ["\u2000", "\u200A"], "\u202F", "\u205F", "\u3000"], false, false);
354
+ const peg$c90 = /^[\n\r\u2028\u2029]/;
355
+ const peg$c91 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], false, false);
356
+ const peg$c92 = "\n";
357
+ const peg$c93 = peg$literalExpectation("\n", false);
358
+ const peg$c94 = "\r\n";
359
+ const peg$c95 = peg$literalExpectation("\r\n", false);
360
+ const peg$c96 = "\r";
361
+ const peg$c97 = peg$literalExpectation("\r", false);
362
+ const peg$c98 = "\u2028";
363
+ const peg$c99 = peg$literalExpectation("\u2028", false);
364
+ const peg$c100 = "\u2029";
365
+ const peg$c101 = peg$literalExpectation("\u2029", false);
366
+ const peg$c102 = /^[^\n\r\u2028\u2029]/;
367
+ const peg$c103 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], true, false);
368
+ const peg$c104 = "//";
369
+ const peg$c105 = peg$literalExpectation("//", false);
370
+ const peg$c106 = function () { return text(); };
371
+ const peg$c107 = "/*";
372
+ const peg$c108 = peg$literalExpectation("/*", false);
373
+ const peg$c109 = /^[^*]/;
374
+ const peg$c110 = peg$classExpectation(["*"], true, false);
375
+ const peg$c111 = /^[^\/*]/;
376
+ const peg$c112 = peg$classExpectation(["/", "*"], true, false);
377
+ const peg$c113 = "import";
378
+ const peg$c114 = peg$literalExpectation("import", false);
379
+ const peg$c115 = "as";
380
+ const peg$c116 = peg$literalExpectation("as", false);
381
+ const peg$c117 = "from";
382
+ const peg$c118 = peg$literalExpectation("from", false);
383
+ const peg$c119 = "(";
384
+ const peg$c120 = peg$literalExpectation("(", false);
385
+ const peg$c121 = ")";
386
+ const peg$c122 = peg$literalExpectation(")", false);
387
+ const peg$c123 = "[";
388
+ const peg$c124 = peg$literalExpectation("[", false);
389
+ const peg$c125 = "]";
390
+ const peg$c126 = peg$literalExpectation("]", false);
391
+ const peg$c127 = ",";
392
+ const peg$c128 = peg$literalExpectation(",", false);
393
+ const peg$c129 = "=";
394
+ const peg$c130 = peg$literalExpectation("=", false);
395
+ const peg$c131 = "address";
396
+ const peg$c132 = peg$literalExpectation("address", false);
397
+ const peg$c133 = "payable";
398
+ const peg$c134 = peg$literalExpectation("payable", false);
399
+ const peg$c135 = "abstract";
400
+ const peg$c136 = peg$literalExpectation("abstract", false);
401
+ const peg$c137 = "contract";
402
+ const peg$c138 = peg$literalExpectation("contract", false);
403
+ const peg$c139 = "library";
404
+ const peg$c140 = peg$literalExpectation("library", false);
405
+ const peg$c141 = "interface";
406
+ const peg$c142 = peg$literalExpectation("interface", false);
407
+ const peg$c143 = "struct";
408
+ const peg$c144 = peg$literalExpectation("struct", false);
409
+ const peg$c145 = "enum";
410
+ const peg$c146 = peg$literalExpectation("enum", false);
411
+ const peg$c147 = "constant";
412
+ const peg$c148 = peg$literalExpectation("constant", false);
413
+ const peg$c149 = "function";
414
+ const peg$c150 = peg$literalExpectation("function", false);
415
+ const peg$c151 = "is";
416
+ const peg$c152 = peg$literalExpectation("is", false);
417
+ const peg$c153 = "type";
418
+ const peg$c154 = peg$literalExpectation("type", false);
419
+ const peg$c155 = "returns";
420
+ const peg$c156 = peg$literalExpectation("returns", false);
421
+ const peg$c157 = "pragma";
422
+ const peg$c158 = peg$literalExpectation("pragma", false);
423
+ const peg$c159 = "error";
424
+ const peg$c160 = peg$literalExpectation("error", false);
425
+ const peg$c161 = "event";
426
+ const peg$c162 = peg$literalExpectation("event", false);
427
+ const peg$c163 = "using";
428
+ const peg$c164 = peg$literalExpectation("using", false);
429
+ const peg$c165 = "for";
430
+ const peg$c166 = peg$literalExpectation("for", false);
431
+ const peg$c167 = "global";
432
+ const peg$c168 = peg$literalExpectation("global", false);
433
+ const peg$c169 = "anonymous";
434
+ const peg$c170 = peg$literalExpectation("anonymous", false);
435
+ const peg$c171 = "layout";
436
+ const peg$c172 = peg$literalExpectation("layout", false);
437
+ const peg$c173 = "at";
438
+ const peg$c174 = peg$literalExpectation("at", false);
439
+ const peg$c175 = "'";
440
+ const peg$c176 = peg$literalExpectation("'", false);
441
+ const peg$c177 = function (chars) { return chars.join(""); };
442
+ const peg$c178 = "\"";
443
+ const peg$c179 = peg$literalExpectation("\"", false);
444
+ const peg$c180 = peg$anyExpectation();
445
+ const peg$c181 = "\\";
446
+ const peg$c182 = peg$literalExpectation("\\", false);
447
+ const peg$c183 = function (sequence) { return sequence; };
448
+ const peg$c184 = function () { return ""; };
449
+ const peg$c185 = "0";
450
+ const peg$c186 = peg$literalExpectation("0", false);
451
+ const peg$c187 = function () { return "\0"; };
452
+ const peg$c188 = "b";
453
+ const peg$c189 = peg$literalExpectation("b", false);
454
+ const peg$c190 = function () { return "\b"; };
455
+ const peg$c191 = "f";
456
+ const peg$c192 = peg$literalExpectation("f", false);
457
+ const peg$c193 = function () { return "\f"; };
458
+ const peg$c194 = "n";
459
+ const peg$c195 = peg$literalExpectation("n", false);
460
+ const peg$c196 = function () { return "\n"; };
461
+ const peg$c197 = "r";
462
+ const peg$c198 = peg$literalExpectation("r", false);
463
+ const peg$c199 = function () { return "\r"; };
464
+ const peg$c200 = "t";
465
+ const peg$c201 = peg$literalExpectation("t", false);
466
+ const peg$c202 = function () { return "\t"; };
467
+ const peg$c203 = "v";
468
+ const peg$c204 = peg$literalExpectation("v", false);
469
+ const peg$c205 = function () { return "\v"; };
470
+ const peg$c206 = /^[0-9a-f]/i;
471
+ const peg$c207 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true);
472
+ const peg$c208 = /^[0-9]/;
473
+ const peg$c209 = peg$classExpectation([["0", "9"]], false, false);
474
+ const peg$c210 = "x";
475
+ const peg$c211 = peg$literalExpectation("x", false);
476
+ const peg$c212 = "u";
477
+ const peg$c213 = peg$literalExpectation("u", false);
478
+ const peg$c214 = function (digits) {
472
479
  return String.fromCharCode(parseInt(digits, 16));
473
480
  };
474
- const peg$c208 = "0x";
475
- const peg$c209 = peg$literalExpectation("0x", true);
476
- const peg$c210 = "e";
477
- const peg$c211 = peg$literalExpectation("e", false);
478
- const peg$c212 = "E";
479
- const peg$c213 = peg$literalExpectation("E", false);
480
- const peg$c214 = /^[+\-]/;
481
- const peg$c215 = peg$classExpectation(["+", "-"], false, false);
482
- const peg$c216 = /^[a-zA-Z$_]/;
483
- const peg$c217 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_"], false, false);
484
- const peg$c218 = /^[a-zA-Z$0-9_]/;
485
- const peg$c219 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", ["0", "9"], "_"], false, false);
486
- const peg$c220 = function (id) { return text(); };
481
+ const peg$c215 = "0x";
482
+ const peg$c216 = peg$literalExpectation("0x", true);
483
+ const peg$c217 = "e";
484
+ const peg$c218 = peg$literalExpectation("e", false);
485
+ const peg$c219 = "E";
486
+ const peg$c220 = peg$literalExpectation("E", false);
487
+ const peg$c221 = /^[+\-]/;
488
+ const peg$c222 = peg$classExpectation(["+", "-"], false, false);
489
+ const peg$c223 = /^[a-zA-Z$_]/;
490
+ const peg$c224 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_"], false, false);
491
+ const peg$c225 = /^[a-zA-Z$0-9_]/;
492
+ const peg$c226 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", ["0", "9"], "_"], false, false);
493
+ const peg$c227 = function (id) { return text(); };
487
494
  let peg$currPos = 0;
488
495
  let peg$savedPos = 0;
489
496
  const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -596,7 +603,7 @@ function peg$parse(input, options) {
596
603
  }
597
604
  function peg$parseSourceUnit() {
598
605
  let s0, s1, s2, s3, s4, s5;
599
- const key = peg$currPos * 98 + 0;
606
+ const key = peg$currPos * 102 + 0;
600
607
  const cached = peg$resultsCache[key];
601
608
  if (cached) {
602
609
  peg$currPos = cached.nextPos;
@@ -664,7 +671,7 @@ function peg$parse(input, options) {
664
671
  }
665
672
  function peg$parseFileLevelDefinition() {
666
673
  let s0;
667
- const key = peg$currPos * 98 + 1;
674
+ const key = peg$currPos * 102 + 1;
668
675
  const cached = peg$resultsCache[key];
669
676
  if (cached) {
670
677
  peg$currPos = cached.nextPos;
@@ -706,7 +713,7 @@ function peg$parse(input, options) {
706
713
  }
707
714
  function peg$parsePragmaValue() {
708
715
  let s0, s1;
709
- const key = peg$currPos * 98 + 2;
716
+ const key = peg$currPos * 102 + 2;
710
717
  const cached = peg$resultsCache[key];
711
718
  if (cached) {
712
719
  peg$currPos = cached.nextPos;
@@ -724,7 +731,7 @@ function peg$parse(input, options) {
724
731
  }
725
732
  function peg$parsePragmaDirective() {
726
733
  let s0, s1, s2, s3, s4, s5, s6, s7;
727
- const key = peg$currPos * 98 + 3;
734
+ const key = peg$currPos * 102 + 3;
728
735
  const cached = peg$resultsCache[key];
729
736
  if (cached) {
730
737
  peg$currPos = cached.nextPos;
@@ -797,7 +804,7 @@ function peg$parse(input, options) {
797
804
  }
798
805
  function peg$parseSymbol() {
799
806
  let s0, s1, s2, s3, s4, s5, s6;
800
- const key = peg$currPos * 98 + 4;
807
+ const key = peg$currPos * 102 + 4;
801
808
  const cached = peg$resultsCache[key];
802
809
  if (cached) {
803
810
  peg$currPos = cached.nextPos;
@@ -859,7 +866,7 @@ function peg$parse(input, options) {
859
866
  }
860
867
  function peg$parseSymbolList() {
861
868
  let s0, s1, s2, s3, s4, s5, s6, s7;
862
- const key = peg$currPos * 98 + 5;
869
+ const key = peg$currPos * 102 + 5;
863
870
  const cached = peg$resultsCache[key];
864
871
  if (cached) {
865
872
  peg$currPos = cached.nextPos;
@@ -953,7 +960,7 @@ function peg$parse(input, options) {
953
960
  }
954
961
  function peg$parseImportDirective() {
955
962
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
956
- const key = peg$currPos * 98 + 6;
963
+ const key = peg$currPos * 102 + 6;
957
964
  const cached = peg$resultsCache[key];
958
965
  if (cached) {
959
966
  peg$currPos = cached.nextPos;
@@ -1266,7 +1273,7 @@ function peg$parse(input, options) {
1266
1273
  }
1267
1274
  function peg$parseConstantType() {
1268
1275
  let s0, s1, s2, s3, s4, s5, s6, s7, s8;
1269
- const key = peg$currPos * 98 + 7;
1276
+ const key = peg$currPos * 102 + 7;
1270
1277
  const cached = peg$resultsCache[key];
1271
1278
  if (cached) {
1272
1279
  peg$currPos = cached.nextPos;
@@ -1409,7 +1416,7 @@ function peg$parse(input, options) {
1409
1416
  }
1410
1417
  function peg$parseConstant() {
1411
1418
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1412
- const key = peg$currPos * 98 + 8;
1419
+ const key = peg$currPos * 102 + 8;
1413
1420
  const cached = peg$resultsCache[key];
1414
1421
  if (cached) {
1415
1422
  peg$currPos = cached.nextPos;
@@ -1501,7 +1508,7 @@ function peg$parse(input, options) {
1501
1508
  }
1502
1509
  function peg$parseFreeFunArgs() {
1503
1510
  let s0, s1, s2, s3, s4, s5;
1504
- const key = peg$currPos * 98 + 9;
1511
+ const key = peg$currPos * 102 + 9;
1505
1512
  const cached = peg$resultsCache[key];
1506
1513
  if (cached) {
1507
1514
  peg$currPos = cached.nextPos;
@@ -1551,7 +1558,7 @@ function peg$parse(input, options) {
1551
1558
  }
1552
1559
  function peg$parseFreeFunMut() {
1553
1560
  let s0, s1, s2, s3, s4, s5;
1554
- const key = peg$currPos * 98 + 10;
1561
+ const key = peg$currPos * 102 + 10;
1555
1562
  const cached = peg$resultsCache[key];
1556
1563
  if (cached) {
1557
1564
  peg$currPos = cached.nextPos;
@@ -1640,7 +1647,7 @@ function peg$parse(input, options) {
1640
1647
  }
1641
1648
  function peg$parseFreeFunBody() {
1642
1649
  let s0, s1, s2, s3, s4, s5;
1643
- const key = peg$currPos * 98 + 11;
1650
+ const key = peg$currPos * 102 + 11;
1644
1651
  const cached = peg$resultsCache[key];
1645
1652
  if (cached) {
1646
1653
  peg$currPos = cached.nextPos;
@@ -1690,7 +1697,7 @@ function peg$parse(input, options) {
1690
1697
  }
1691
1698
  function peg$parseFreeFunReturns() {
1692
1699
  let s0, s1, s2, s3;
1693
- const key = peg$currPos * 98 + 12;
1700
+ const key = peg$currPos * 102 + 12;
1694
1701
  const cached = peg$resultsCache[key];
1695
1702
  if (cached) {
1696
1703
  peg$currPos = cached.nextPos;
@@ -1726,7 +1733,7 @@ function peg$parse(input, options) {
1726
1733
  }
1727
1734
  function peg$parseFreeFunction() {
1728
1735
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1729
- const key = peg$currPos * 98 + 13;
1736
+ const key = peg$currPos * 102 + 13;
1730
1737
  const cached = peg$resultsCache[key];
1731
1738
  if (cached) {
1732
1739
  peg$currPos = cached.nextPos;
@@ -1814,7 +1821,7 @@ function peg$parse(input, options) {
1814
1821
  }
1815
1822
  function peg$parseIdentifierPath() {
1816
1823
  let s0, s1, s2, s3, s4, s5;
1817
- const key = peg$currPos * 98 + 14;
1824
+ const key = peg$currPos * 102 + 14;
1818
1825
  const cached = peg$resultsCache[key];
1819
1826
  if (cached) {
1820
1827
  peg$currPos = cached.nextPos;
@@ -1898,7 +1905,7 @@ function peg$parse(input, options) {
1898
1905
  }
1899
1906
  function peg$parseBaseArgs() {
1900
1907
  let s0, s1, s2, s3, s4, s5;
1901
- const key = peg$currPos * 98 + 15;
1908
+ const key = peg$currPos * 102 + 15;
1902
1909
  const cached = peg$resultsCache[key];
1903
1910
  if (cached) {
1904
1911
  peg$currPos = cached.nextPos;
@@ -1947,7 +1954,7 @@ function peg$parse(input, options) {
1947
1954
  }
1948
1955
  function peg$parseBaseClassList() {
1949
1956
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1950
- const key = peg$currPos * 98 + 16;
1957
+ const key = peg$currPos * 102 + 16;
1951
1958
  const cached = peg$resultsCache[key];
1952
1959
  if (cached) {
1953
1960
  peg$currPos = cached.nextPos;
@@ -2092,7 +2099,7 @@ function peg$parse(input, options) {
2092
2099
  }
2093
2100
  function peg$parseContractBody() {
2094
2101
  let s0, s1, s2, s3, s4, s5;
2095
- const key = peg$currPos * 98 + 17;
2102
+ const key = peg$currPos * 102 + 17;
2096
2103
  const cached = peg$resultsCache[key];
2097
2104
  if (cached) {
2098
2105
  peg$currPos = cached.nextPos;
@@ -2140,9 +2147,59 @@ function peg$parse(input, options) {
2140
2147
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2141
2148
  return s0;
2142
2149
  }
2150
+ function peg$parseContractLayout() {
2151
+ let s0, s1, s2, s3, s4, s5;
2152
+ const key = peg$currPos * 102 + 18;
2153
+ const cached = peg$resultsCache[key];
2154
+ if (cached) {
2155
+ peg$currPos = cached.nextPos;
2156
+ return cached.result;
2157
+ }
2158
+ s0 = peg$currPos;
2159
+ s1 = peg$parseLAYOUT();
2160
+ if (s1 !== peg$FAILED) {
2161
+ s2 = peg$parse__();
2162
+ if (s2 !== peg$FAILED) {
2163
+ s3 = peg$parseAT();
2164
+ if (s3 !== peg$FAILED) {
2165
+ s4 = peg$parse__();
2166
+ if (s4 !== peg$FAILED) {
2167
+ s5 = peg$parseLayoutExprSoup();
2168
+ if (s5 !== peg$FAILED) {
2169
+ peg$savedPos = s0;
2170
+ s1 = peg$c18(s5);
2171
+ s0 = s1;
2172
+ }
2173
+ else {
2174
+ peg$currPos = s0;
2175
+ s0 = peg$FAILED;
2176
+ }
2177
+ }
2178
+ else {
2179
+ peg$currPos = s0;
2180
+ s0 = peg$FAILED;
2181
+ }
2182
+ }
2183
+ else {
2184
+ peg$currPos = s0;
2185
+ s0 = peg$FAILED;
2186
+ }
2187
+ }
2188
+ else {
2189
+ peg$currPos = s0;
2190
+ s0 = peg$FAILED;
2191
+ }
2192
+ }
2193
+ else {
2194
+ peg$currPos = s0;
2195
+ s0 = peg$FAILED;
2196
+ }
2197
+ peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2198
+ return s0;
2199
+ }
2143
2200
  function peg$parseContractDefinition() {
2144
2201
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2145
- const key = peg$currPos * 98 + 18;
2202
+ const key = peg$currPos * 102 + 19;
2146
2203
  const cached = peg$resultsCache[key];
2147
2204
  if (cached) {
2148
2205
  peg$currPos = cached.nextPos;
@@ -2219,11 +2276,28 @@ function peg$parse(input, options) {
2219
2276
  if (s5 !== peg$FAILED) {
2220
2277
  s6 = peg$parse__();
2221
2278
  if (s6 !== peg$FAILED) {
2222
- s7 = peg$parseContractBody();
2279
+ s7 = peg$parseContractLayout();
2280
+ if (s7 === peg$FAILED) {
2281
+ s7 = null;
2282
+ }
2223
2283
  if (s7 !== peg$FAILED) {
2224
- peg$savedPos = s0;
2225
- s1 = peg$c18(s1, s2, s4, s5, s7);
2226
- s0 = s1;
2284
+ s8 = peg$parse__();
2285
+ if (s8 !== peg$FAILED) {
2286
+ s9 = peg$parseContractBody();
2287
+ if (s9 !== peg$FAILED) {
2288
+ peg$savedPos = s0;
2289
+ s1 = peg$c19(s1, s2, s4, s5, s7, s9);
2290
+ s0 = s1;
2291
+ }
2292
+ else {
2293
+ peg$currPos = s0;
2294
+ s0 = peg$FAILED;
2295
+ }
2296
+ }
2297
+ else {
2298
+ peg$currPos = s0;
2299
+ s0 = peg$FAILED;
2300
+ }
2227
2301
  }
2228
2302
  else {
2229
2303
  peg$currPos = s0;
@@ -2264,7 +2338,7 @@ function peg$parse(input, options) {
2264
2338
  }
2265
2339
  function peg$parseStructBody() {
2266
2340
  let s0, s1, s2, s3, s4, s5;
2267
- const key = peg$currPos * 98 + 19;
2341
+ const key = peg$currPos * 102 + 20;
2268
2342
  const cached = peg$resultsCache[key];
2269
2343
  if (cached) {
2270
2344
  peg$currPos = cached.nextPos;
@@ -2314,7 +2388,7 @@ function peg$parse(input, options) {
2314
2388
  }
2315
2389
  function peg$parseStructDef() {
2316
2390
  let s0, s1, s2, s3, s4, s5;
2317
- const key = peg$currPos * 98 + 20;
2391
+ const key = peg$currPos * 102 + 21;
2318
2392
  const cached = peg$resultsCache[key];
2319
2393
  if (cached) {
2320
2394
  peg$currPos = cached.nextPos;
@@ -2332,7 +2406,7 @@ function peg$parse(input, options) {
2332
2406
  s5 = peg$parseStructBody();
2333
2407
  if (s5 !== peg$FAILED) {
2334
2408
  peg$savedPos = s0;
2335
- s1 = peg$c19(s3, s5);
2409
+ s1 = peg$c20(s3, s5);
2336
2410
  s0 = s1;
2337
2411
  }
2338
2412
  else {
@@ -2364,7 +2438,7 @@ function peg$parse(input, options) {
2364
2438
  }
2365
2439
  function peg$parseEnumDefBody() {
2366
2440
  let s0, s1, s2, s3, s4, s5;
2367
- const key = peg$currPos * 98 + 21;
2441
+ const key = peg$currPos * 102 + 22;
2368
2442
  const cached = peg$resultsCache[key];
2369
2443
  if (cached) {
2370
2444
  peg$currPos = cached.nextPos;
@@ -2414,7 +2488,7 @@ function peg$parse(input, options) {
2414
2488
  }
2415
2489
  function peg$parseEnumDef() {
2416
2490
  let s0, s1, s2, s3, s4, s5;
2417
- const key = peg$currPos * 98 + 22;
2491
+ const key = peg$currPos * 102 + 23;
2418
2492
  const cached = peg$resultsCache[key];
2419
2493
  if (cached) {
2420
2494
  peg$currPos = cached.nextPos;
@@ -2432,7 +2506,7 @@ function peg$parse(input, options) {
2432
2506
  s5 = peg$parseEnumDefBody();
2433
2507
  if (s5 !== peg$FAILED) {
2434
2508
  peg$savedPos = s0;
2435
- s1 = peg$c20(s3, s5);
2509
+ s1 = peg$c21(s3, s5);
2436
2510
  s0 = s1;
2437
2511
  }
2438
2512
  else {
@@ -2464,7 +2538,7 @@ function peg$parse(input, options) {
2464
2538
  }
2465
2539
  function peg$parseEventArgs() {
2466
2540
  let s0, s1, s2, s3, s4, s5;
2467
- const key = peg$currPos * 98 + 23;
2541
+ const key = peg$currPos * 102 + 24;
2468
2542
  const cached = peg$resultsCache[key];
2469
2543
  if (cached) {
2470
2544
  peg$currPos = cached.nextPos;
@@ -2514,7 +2588,7 @@ function peg$parse(input, options) {
2514
2588
  }
2515
2589
  function peg$parseEventDef() {
2516
2590
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2517
- const key = peg$currPos * 98 + 24;
2591
+ const key = peg$currPos * 102 + 25;
2518
2592
  const cached = peg$resultsCache[key];
2519
2593
  if (cached) {
2520
2594
  peg$currPos = cached.nextPos;
@@ -2543,7 +2617,7 @@ function peg$parse(input, options) {
2543
2617
  s9 = peg$parseSEMICOLON();
2544
2618
  if (s9 !== peg$FAILED) {
2545
2619
  peg$savedPos = s0;
2546
- s1 = peg$c21(s3, s5, s7);
2620
+ s1 = peg$c22(s3, s5, s7);
2547
2621
  s0 = s1;
2548
2622
  }
2549
2623
  else {
@@ -2595,7 +2669,7 @@ function peg$parse(input, options) {
2595
2669
  }
2596
2670
  function peg$parseErrorArgs() {
2597
2671
  let s0, s1, s2, s3, s4, s5;
2598
- const key = peg$currPos * 98 + 25;
2672
+ const key = peg$currPos * 102 + 26;
2599
2673
  const cached = peg$resultsCache[key];
2600
2674
  if (cached) {
2601
2675
  peg$currPos = cached.nextPos;
@@ -2645,7 +2719,7 @@ function peg$parse(input, options) {
2645
2719
  }
2646
2720
  function peg$parseErrorDef() {
2647
2721
  let s0, s1, s2, s3, s4, s5, s6, s7;
2648
- const key = peg$currPos * 98 + 26;
2722
+ const key = peg$currPos * 102 + 27;
2649
2723
  const cached = peg$resultsCache[key];
2650
2724
  if (cached) {
2651
2725
  peg$currPos = cached.nextPos;
@@ -2667,7 +2741,7 @@ function peg$parse(input, options) {
2667
2741
  s7 = peg$parseSEMICOLON();
2668
2742
  if (s7 !== peg$FAILED) {
2669
2743
  peg$savedPos = s0;
2670
- s1 = peg$c22(s3, s5);
2744
+ s1 = peg$c23(s3, s5);
2671
2745
  s0 = s1;
2672
2746
  }
2673
2747
  else {
@@ -2709,7 +2783,7 @@ function peg$parse(input, options) {
2709
2783
  }
2710
2784
  function peg$parseUserValueTypeDef() {
2711
2785
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2712
- const key = peg$currPos * 98 + 27;
2786
+ const key = peg$currPos * 102 + 28;
2713
2787
  const cached = peg$resultsCache[key];
2714
2788
  if (cached) {
2715
2789
  peg$currPos = cached.nextPos;
@@ -2735,7 +2809,7 @@ function peg$parse(input, options) {
2735
2809
  s9 = peg$parseSEMICOLON();
2736
2810
  if (s9 !== peg$FAILED) {
2737
2811
  peg$savedPos = s0;
2738
- s1 = peg$c23(s3, s7);
2812
+ s1 = peg$c24(s3, s7);
2739
2813
  s0 = s1;
2740
2814
  }
2741
2815
  else {
@@ -2787,174 +2861,174 @@ function peg$parse(input, options) {
2787
2861
  }
2788
2862
  function peg$parseCustomizableOperator() {
2789
2863
  let s0;
2790
- const key = peg$currPos * 98 + 28;
2864
+ const key = peg$currPos * 102 + 29;
2791
2865
  const cached = peg$resultsCache[key];
2792
2866
  if (cached) {
2793
2867
  peg$currPos = cached.nextPos;
2794
2868
  return cached.result;
2795
2869
  }
2796
2870
  if (input.charCodeAt(peg$currPos) === 38) {
2797
- s0 = peg$c24;
2871
+ s0 = peg$c25;
2798
2872
  peg$currPos++;
2799
2873
  }
2800
2874
  else {
2801
2875
  s0 = peg$FAILED;
2802
2876
  if (peg$silentFails === 0) {
2803
- peg$fail(peg$c25);
2877
+ peg$fail(peg$c26);
2804
2878
  }
2805
2879
  }
2806
2880
  if (s0 === peg$FAILED) {
2807
2881
  if (input.charCodeAt(peg$currPos) === 124) {
2808
- s0 = peg$c26;
2882
+ s0 = peg$c27;
2809
2883
  peg$currPos++;
2810
2884
  }
2811
2885
  else {
2812
2886
  s0 = peg$FAILED;
2813
2887
  if (peg$silentFails === 0) {
2814
- peg$fail(peg$c27);
2888
+ peg$fail(peg$c28);
2815
2889
  }
2816
2890
  }
2817
2891
  if (s0 === peg$FAILED) {
2818
2892
  if (input.charCodeAt(peg$currPos) === 94) {
2819
- s0 = peg$c28;
2893
+ s0 = peg$c29;
2820
2894
  peg$currPos++;
2821
2895
  }
2822
2896
  else {
2823
2897
  s0 = peg$FAILED;
2824
2898
  if (peg$silentFails === 0) {
2825
- peg$fail(peg$c29);
2899
+ peg$fail(peg$c30);
2826
2900
  }
2827
2901
  }
2828
2902
  if (s0 === peg$FAILED) {
2829
2903
  if (input.charCodeAt(peg$currPos) === 126) {
2830
- s0 = peg$c30;
2904
+ s0 = peg$c31;
2831
2905
  peg$currPos++;
2832
2906
  }
2833
2907
  else {
2834
2908
  s0 = peg$FAILED;
2835
2909
  if (peg$silentFails === 0) {
2836
- peg$fail(peg$c31);
2910
+ peg$fail(peg$c32);
2837
2911
  }
2838
2912
  }
2839
2913
  if (s0 === peg$FAILED) {
2840
2914
  if (input.charCodeAt(peg$currPos) === 43) {
2841
- s0 = peg$c32;
2915
+ s0 = peg$c33;
2842
2916
  peg$currPos++;
2843
2917
  }
2844
2918
  else {
2845
2919
  s0 = peg$FAILED;
2846
2920
  if (peg$silentFails === 0) {
2847
- peg$fail(peg$c33);
2921
+ peg$fail(peg$c34);
2848
2922
  }
2849
2923
  }
2850
2924
  if (s0 === peg$FAILED) {
2851
2925
  if (input.charCodeAt(peg$currPos) === 45) {
2852
- s0 = peg$c34;
2926
+ s0 = peg$c35;
2853
2927
  peg$currPos++;
2854
2928
  }
2855
2929
  else {
2856
2930
  s0 = peg$FAILED;
2857
2931
  if (peg$silentFails === 0) {
2858
- peg$fail(peg$c35);
2932
+ peg$fail(peg$c36);
2859
2933
  }
2860
2934
  }
2861
2935
  if (s0 === peg$FAILED) {
2862
2936
  if (input.charCodeAt(peg$currPos) === 42) {
2863
- s0 = peg$c36;
2937
+ s0 = peg$c37;
2864
2938
  peg$currPos++;
2865
2939
  }
2866
2940
  else {
2867
2941
  s0 = peg$FAILED;
2868
2942
  if (peg$silentFails === 0) {
2869
- peg$fail(peg$c37);
2943
+ peg$fail(peg$c38);
2870
2944
  }
2871
2945
  }
2872
2946
  if (s0 === peg$FAILED) {
2873
2947
  if (input.charCodeAt(peg$currPos) === 47) {
2874
- s0 = peg$c38;
2948
+ s0 = peg$c39;
2875
2949
  peg$currPos++;
2876
2950
  }
2877
2951
  else {
2878
2952
  s0 = peg$FAILED;
2879
2953
  if (peg$silentFails === 0) {
2880
- peg$fail(peg$c39);
2954
+ peg$fail(peg$c40);
2881
2955
  }
2882
2956
  }
2883
2957
  if (s0 === peg$FAILED) {
2884
2958
  if (input.charCodeAt(peg$currPos) === 37) {
2885
- s0 = peg$c40;
2959
+ s0 = peg$c41;
2886
2960
  peg$currPos++;
2887
2961
  }
2888
2962
  else {
2889
2963
  s0 = peg$FAILED;
2890
2964
  if (peg$silentFails === 0) {
2891
- peg$fail(peg$c41);
2965
+ peg$fail(peg$c42);
2892
2966
  }
2893
2967
  }
2894
2968
  if (s0 === peg$FAILED) {
2895
- if (input.substr(peg$currPos, 2) === peg$c42) {
2896
- s0 = peg$c42;
2969
+ if (input.substr(peg$currPos, 2) === peg$c43) {
2970
+ s0 = peg$c43;
2897
2971
  peg$currPos += 2;
2898
2972
  }
2899
2973
  else {
2900
2974
  s0 = peg$FAILED;
2901
2975
  if (peg$silentFails === 0) {
2902
- peg$fail(peg$c43);
2976
+ peg$fail(peg$c44);
2903
2977
  }
2904
2978
  }
2905
2979
  if (s0 === peg$FAILED) {
2906
- if (input.substr(peg$currPos, 2) === peg$c44) {
2907
- s0 = peg$c44;
2980
+ if (input.substr(peg$currPos, 2) === peg$c45) {
2981
+ s0 = peg$c45;
2908
2982
  peg$currPos += 2;
2909
2983
  }
2910
2984
  else {
2911
2985
  s0 = peg$FAILED;
2912
2986
  if (peg$silentFails === 0) {
2913
- peg$fail(peg$c45);
2987
+ peg$fail(peg$c46);
2914
2988
  }
2915
2989
  }
2916
2990
  if (s0 === peg$FAILED) {
2917
- if (input.substr(peg$currPos, 2) === peg$c46) {
2918
- s0 = peg$c46;
2991
+ if (input.substr(peg$currPos, 2) === peg$c47) {
2992
+ s0 = peg$c47;
2919
2993
  peg$currPos += 2;
2920
2994
  }
2921
2995
  else {
2922
2996
  s0 = peg$FAILED;
2923
2997
  if (peg$silentFails === 0) {
2924
- peg$fail(peg$c47);
2998
+ peg$fail(peg$c48);
2925
2999
  }
2926
3000
  }
2927
3001
  if (s0 === peg$FAILED) {
2928
- if (input.substr(peg$currPos, 2) === peg$c48) {
2929
- s0 = peg$c48;
3002
+ if (input.substr(peg$currPos, 2) === peg$c49) {
3003
+ s0 = peg$c49;
2930
3004
  peg$currPos += 2;
2931
3005
  }
2932
3006
  else {
2933
3007
  s0 = peg$FAILED;
2934
3008
  if (peg$silentFails === 0) {
2935
- peg$fail(peg$c49);
3009
+ peg$fail(peg$c50);
2936
3010
  }
2937
3011
  }
2938
3012
  if (s0 === peg$FAILED) {
2939
3013
  if (input.charCodeAt(peg$currPos) === 60) {
2940
- s0 = peg$c50;
3014
+ s0 = peg$c51;
2941
3015
  peg$currPos++;
2942
3016
  }
2943
3017
  else {
2944
3018
  s0 = peg$FAILED;
2945
3019
  if (peg$silentFails === 0) {
2946
- peg$fail(peg$c51);
3020
+ peg$fail(peg$c52);
2947
3021
  }
2948
3022
  }
2949
3023
  if (s0 === peg$FAILED) {
2950
3024
  if (input.charCodeAt(peg$currPos) === 62) {
2951
- s0 = peg$c52;
3025
+ s0 = peg$c53;
2952
3026
  peg$currPos++;
2953
3027
  }
2954
3028
  else {
2955
3029
  s0 = peg$FAILED;
2956
3030
  if (peg$silentFails === 0) {
2957
- peg$fail(peg$c53);
3031
+ peg$fail(peg$c54);
2958
3032
  }
2959
3033
  }
2960
3034
  }
@@ -2976,7 +3050,7 @@ function peg$parse(input, options) {
2976
3050
  }
2977
3051
  function peg$parseUsingEntry() {
2978
3052
  let s0, s1, s2, s3, s4, s5, s6;
2979
- const key = peg$currPos * 98 + 29;
3053
+ const key = peg$currPos * 102 + 30;
2980
3054
  const cached = peg$resultsCache[key];
2981
3055
  if (cached) {
2982
3056
  peg$currPos = cached.nextPos;
@@ -3021,7 +3095,7 @@ function peg$parse(input, options) {
3021
3095
  }
3022
3096
  if (s2 !== peg$FAILED) {
3023
3097
  peg$savedPos = s0;
3024
- s1 = peg$c54(s1, s2);
3098
+ s1 = peg$c55(s1, s2);
3025
3099
  s0 = s1;
3026
3100
  }
3027
3101
  else {
@@ -3038,7 +3112,7 @@ function peg$parse(input, options) {
3038
3112
  }
3039
3113
  function peg$parseUsingEntryList() {
3040
3114
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3041
- const key = peg$currPos * 98 + 30;
3115
+ const key = peg$currPos * 102 + 31;
3042
3116
  const cached = peg$resultsCache[key];
3043
3117
  if (cached) {
3044
3118
  peg$currPos = cached.nextPos;
@@ -3131,7 +3205,7 @@ function peg$parse(input, options) {
3131
3205
  }
3132
3206
  if (s3 !== peg$FAILED) {
3133
3207
  peg$savedPos = s0;
3134
- s1 = peg$c55(s1, s3);
3208
+ s1 = peg$c56(s1, s3);
3135
3209
  s0 = s1;
3136
3210
  }
3137
3211
  else {
@@ -3153,7 +3227,7 @@ function peg$parse(input, options) {
3153
3227
  }
3154
3228
  function peg$parseUsingForDirective() {
3155
3229
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
3156
- const key = peg$currPos * 98 + 31;
3230
+ const key = peg$currPos * 102 + 32;
3157
3231
  const cached = peg$resultsCache[key];
3158
3232
  if (cached) {
3159
3233
  peg$currPos = cached.nextPos;
@@ -3168,13 +3242,13 @@ function peg$parse(input, options) {
3168
3242
  if (s3 === peg$FAILED) {
3169
3243
  s3 = peg$currPos;
3170
3244
  if (input.charCodeAt(peg$currPos) === 123) {
3171
- s4 = peg$c56;
3245
+ s4 = peg$c57;
3172
3246
  peg$currPos++;
3173
3247
  }
3174
3248
  else {
3175
3249
  s4 = peg$FAILED;
3176
3250
  if (peg$silentFails === 0) {
3177
- peg$fail(peg$c57);
3251
+ peg$fail(peg$c58);
3178
3252
  }
3179
3253
  }
3180
3254
  if (s4 !== peg$FAILED) {
@@ -3185,13 +3259,13 @@ function peg$parse(input, options) {
3185
3259
  s7 = peg$parse__();
3186
3260
  if (s7 !== peg$FAILED) {
3187
3261
  if (input.charCodeAt(peg$currPos) === 125) {
3188
- s8 = peg$c58;
3262
+ s8 = peg$c59;
3189
3263
  peg$currPos++;
3190
3264
  }
3191
3265
  else {
3192
3266
  s8 = peg$FAILED;
3193
3267
  if (peg$silentFails === 0) {
3194
- peg$fail(peg$c59);
3268
+ peg$fail(peg$c60);
3195
3269
  }
3196
3270
  }
3197
3271
  if (s8 !== peg$FAILED) {
@@ -3242,7 +3316,7 @@ function peg$parse(input, options) {
3242
3316
  s10 = peg$parseSEMICOLON();
3243
3317
  if (s10 !== peg$FAILED) {
3244
3318
  peg$savedPos = s0;
3245
- s1 = peg$c60(s3, s7, s9);
3319
+ s1 = peg$c61(s3, s7, s9);
3246
3320
  s0 = s1;
3247
3321
  }
3248
3322
  else {
@@ -3299,7 +3373,7 @@ function peg$parse(input, options) {
3299
3373
  }
3300
3374
  function peg$parseNonSemicolonSoup() {
3301
3375
  let s0, s1, s2, s3, s4, s5, s6;
3302
- const key = peg$currPos * 98 + 32;
3376
+ const key = peg$currPos * 102 + 33;
3303
3377
  const cached = peg$resultsCache[key];
3304
3378
  if (cached) {
3305
3379
  peg$currPos = cached.nextPos;
@@ -3309,27 +3383,27 @@ function peg$parse(input, options) {
3309
3383
  s1 = [];
3310
3384
  s2 = peg$currPos;
3311
3385
  s3 = [];
3312
- if (peg$c61.test(input.charAt(peg$currPos))) {
3386
+ if (peg$c62.test(input.charAt(peg$currPos))) {
3313
3387
  s4 = input.charAt(peg$currPos);
3314
3388
  peg$currPos++;
3315
3389
  }
3316
3390
  else {
3317
3391
  s4 = peg$FAILED;
3318
3392
  if (peg$silentFails === 0) {
3319
- peg$fail(peg$c62);
3393
+ peg$fail(peg$c63);
3320
3394
  }
3321
3395
  }
3322
3396
  if (s4 !== peg$FAILED) {
3323
3397
  while (s4 !== peg$FAILED) {
3324
3398
  s3.push(s4);
3325
- if (peg$c61.test(input.charAt(peg$currPos))) {
3399
+ if (peg$c62.test(input.charAt(peg$currPos))) {
3326
3400
  s4 = input.charAt(peg$currPos);
3327
3401
  peg$currPos++;
3328
3402
  }
3329
3403
  else {
3330
3404
  s4 = peg$FAILED;
3331
3405
  if (peg$silentFails === 0) {
3332
- peg$fail(peg$c62);
3406
+ peg$fail(peg$c63);
3333
3407
  }
3334
3408
  }
3335
3409
  }
@@ -3340,24 +3414,24 @@ function peg$parse(input, options) {
3340
3414
  if (s3 !== peg$FAILED) {
3341
3415
  s4 = peg$currPos;
3342
3416
  if (input.charCodeAt(peg$currPos) === 47) {
3343
- s5 = peg$c38;
3417
+ s5 = peg$c39;
3344
3418
  peg$currPos++;
3345
3419
  }
3346
3420
  else {
3347
3421
  s5 = peg$FAILED;
3348
3422
  if (peg$silentFails === 0) {
3349
- peg$fail(peg$c39);
3423
+ peg$fail(peg$c40);
3350
3424
  }
3351
3425
  }
3352
3426
  if (s5 !== peg$FAILED) {
3353
- if (peg$c63.test(input.charAt(peg$currPos))) {
3427
+ if (peg$c64.test(input.charAt(peg$currPos))) {
3354
3428
  s6 = input.charAt(peg$currPos);
3355
3429
  peg$currPos++;
3356
3430
  }
3357
3431
  else {
3358
3432
  s6 = peg$FAILED;
3359
3433
  if (peg$silentFails === 0) {
3360
- peg$fail(peg$c64);
3434
+ peg$fail(peg$c65);
3361
3435
  }
3362
3436
  }
3363
3437
  if (s6 !== peg$FAILED) {
@@ -3399,27 +3473,27 @@ function peg$parse(input, options) {
3399
3473
  s1.push(s2);
3400
3474
  s2 = peg$currPos;
3401
3475
  s3 = [];
3402
- if (peg$c61.test(input.charAt(peg$currPos))) {
3476
+ if (peg$c62.test(input.charAt(peg$currPos))) {
3403
3477
  s4 = input.charAt(peg$currPos);
3404
3478
  peg$currPos++;
3405
3479
  }
3406
3480
  else {
3407
3481
  s4 = peg$FAILED;
3408
3482
  if (peg$silentFails === 0) {
3409
- peg$fail(peg$c62);
3483
+ peg$fail(peg$c63);
3410
3484
  }
3411
3485
  }
3412
3486
  if (s4 !== peg$FAILED) {
3413
3487
  while (s4 !== peg$FAILED) {
3414
3488
  s3.push(s4);
3415
- if (peg$c61.test(input.charAt(peg$currPos))) {
3489
+ if (peg$c62.test(input.charAt(peg$currPos))) {
3416
3490
  s4 = input.charAt(peg$currPos);
3417
3491
  peg$currPos++;
3418
3492
  }
3419
3493
  else {
3420
3494
  s4 = peg$FAILED;
3421
3495
  if (peg$silentFails === 0) {
3422
- peg$fail(peg$c62);
3496
+ peg$fail(peg$c63);
3423
3497
  }
3424
3498
  }
3425
3499
  }
@@ -3430,24 +3504,24 @@ function peg$parse(input, options) {
3430
3504
  if (s3 !== peg$FAILED) {
3431
3505
  s4 = peg$currPos;
3432
3506
  if (input.charCodeAt(peg$currPos) === 47) {
3433
- s5 = peg$c38;
3507
+ s5 = peg$c39;
3434
3508
  peg$currPos++;
3435
3509
  }
3436
3510
  else {
3437
3511
  s5 = peg$FAILED;
3438
3512
  if (peg$silentFails === 0) {
3439
- peg$fail(peg$c39);
3513
+ peg$fail(peg$c40);
3440
3514
  }
3441
3515
  }
3442
3516
  if (s5 !== peg$FAILED) {
3443
- if (peg$c63.test(input.charAt(peg$currPos))) {
3517
+ if (peg$c64.test(input.charAt(peg$currPos))) {
3444
3518
  s6 = input.charAt(peg$currPos);
3445
3519
  peg$currPos++;
3446
3520
  }
3447
3521
  else {
3448
3522
  s6 = peg$FAILED;
3449
3523
  if (peg$silentFails === 0) {
3450
- peg$fail(peg$c64);
3524
+ peg$fail(peg$c65);
3451
3525
  }
3452
3526
  }
3453
3527
  if (s6 !== peg$FAILED) {
@@ -3496,7 +3570,278 @@ function peg$parse(input, options) {
3496
3570
  }
3497
3571
  function peg$parseParenSoup() {
3498
3572
  let s0, s1, s2, s3, s4, s5, s6;
3499
- const key = peg$currPos * 98 + 33;
3573
+ const key = peg$currPos * 102 + 34;
3574
+ const cached = peg$resultsCache[key];
3575
+ if (cached) {
3576
+ peg$currPos = cached.nextPos;
3577
+ return cached.result;
3578
+ }
3579
+ s0 = [];
3580
+ s1 = peg$currPos;
3581
+ s2 = [];
3582
+ if (peg$c66.test(input.charAt(peg$currPos))) {
3583
+ s3 = input.charAt(peg$currPos);
3584
+ peg$currPos++;
3585
+ }
3586
+ else {
3587
+ s3 = peg$FAILED;
3588
+ if (peg$silentFails === 0) {
3589
+ peg$fail(peg$c67);
3590
+ }
3591
+ }
3592
+ if (s3 !== peg$FAILED) {
3593
+ while (s3 !== peg$FAILED) {
3594
+ s2.push(s3);
3595
+ if (peg$c66.test(input.charAt(peg$currPos))) {
3596
+ s3 = input.charAt(peg$currPos);
3597
+ peg$currPos++;
3598
+ }
3599
+ else {
3600
+ s3 = peg$FAILED;
3601
+ if (peg$silentFails === 0) {
3602
+ peg$fail(peg$c67);
3603
+ }
3604
+ }
3605
+ }
3606
+ }
3607
+ else {
3608
+ s2 = peg$FAILED;
3609
+ }
3610
+ if (s2 !== peg$FAILED) {
3611
+ s3 = peg$currPos;
3612
+ if (input.charCodeAt(peg$currPos) === 47) {
3613
+ s4 = peg$c39;
3614
+ peg$currPos++;
3615
+ }
3616
+ else {
3617
+ s4 = peg$FAILED;
3618
+ if (peg$silentFails === 0) {
3619
+ peg$fail(peg$c40);
3620
+ }
3621
+ }
3622
+ if (s4 !== peg$FAILED) {
3623
+ if (peg$c68.test(input.charAt(peg$currPos))) {
3624
+ s5 = input.charAt(peg$currPos);
3625
+ peg$currPos++;
3626
+ }
3627
+ else {
3628
+ s5 = peg$FAILED;
3629
+ if (peg$silentFails === 0) {
3630
+ peg$fail(peg$c69);
3631
+ }
3632
+ }
3633
+ if (s5 !== peg$FAILED) {
3634
+ s4 = [s4, s5];
3635
+ s3 = s4;
3636
+ }
3637
+ else {
3638
+ peg$currPos = s3;
3639
+ s3 = peg$FAILED;
3640
+ }
3641
+ }
3642
+ else {
3643
+ peg$currPos = s3;
3644
+ s3 = peg$FAILED;
3645
+ }
3646
+ if (s3 === peg$FAILED) {
3647
+ s3 = null;
3648
+ }
3649
+ if (s3 !== peg$FAILED) {
3650
+ s2 = [s2, s3];
3651
+ s1 = s2;
3652
+ }
3653
+ else {
3654
+ peg$currPos = s1;
3655
+ s1 = peg$FAILED;
3656
+ }
3657
+ }
3658
+ else {
3659
+ peg$currPos = s1;
3660
+ s1 = peg$FAILED;
3661
+ }
3662
+ if (s1 === peg$FAILED) {
3663
+ s1 = peg$parseStringLiteral();
3664
+ if (s1 === peg$FAILED) {
3665
+ s1 = peg$parseComment();
3666
+ }
3667
+ }
3668
+ if (s1 === peg$FAILED) {
3669
+ s1 = peg$currPos;
3670
+ s2 = peg$parseLPAREN();
3671
+ if (s2 !== peg$FAILED) {
3672
+ s3 = peg$parse__();
3673
+ if (s3 !== peg$FAILED) {
3674
+ s4 = peg$parseParenSoup();
3675
+ if (s4 !== peg$FAILED) {
3676
+ s5 = peg$parse__();
3677
+ if (s5 !== peg$FAILED) {
3678
+ s6 = peg$parseRPAREN();
3679
+ if (s6 !== peg$FAILED) {
3680
+ s2 = [s2, s3, s4, s5, s6];
3681
+ s1 = s2;
3682
+ }
3683
+ else {
3684
+ peg$currPos = s1;
3685
+ s1 = peg$FAILED;
3686
+ }
3687
+ }
3688
+ else {
3689
+ peg$currPos = s1;
3690
+ s1 = peg$FAILED;
3691
+ }
3692
+ }
3693
+ else {
3694
+ peg$currPos = s1;
3695
+ s1 = peg$FAILED;
3696
+ }
3697
+ }
3698
+ else {
3699
+ peg$currPos = s1;
3700
+ s1 = peg$FAILED;
3701
+ }
3702
+ }
3703
+ else {
3704
+ peg$currPos = s1;
3705
+ s1 = peg$FAILED;
3706
+ }
3707
+ }
3708
+ while (s1 !== peg$FAILED) {
3709
+ s0.push(s1);
3710
+ s1 = peg$currPos;
3711
+ s2 = [];
3712
+ if (peg$c66.test(input.charAt(peg$currPos))) {
3713
+ s3 = input.charAt(peg$currPos);
3714
+ peg$currPos++;
3715
+ }
3716
+ else {
3717
+ s3 = peg$FAILED;
3718
+ if (peg$silentFails === 0) {
3719
+ peg$fail(peg$c67);
3720
+ }
3721
+ }
3722
+ if (s3 !== peg$FAILED) {
3723
+ while (s3 !== peg$FAILED) {
3724
+ s2.push(s3);
3725
+ if (peg$c66.test(input.charAt(peg$currPos))) {
3726
+ s3 = input.charAt(peg$currPos);
3727
+ peg$currPos++;
3728
+ }
3729
+ else {
3730
+ s3 = peg$FAILED;
3731
+ if (peg$silentFails === 0) {
3732
+ peg$fail(peg$c67);
3733
+ }
3734
+ }
3735
+ }
3736
+ }
3737
+ else {
3738
+ s2 = peg$FAILED;
3739
+ }
3740
+ if (s2 !== peg$FAILED) {
3741
+ s3 = peg$currPos;
3742
+ if (input.charCodeAt(peg$currPos) === 47) {
3743
+ s4 = peg$c39;
3744
+ peg$currPos++;
3745
+ }
3746
+ else {
3747
+ s4 = peg$FAILED;
3748
+ if (peg$silentFails === 0) {
3749
+ peg$fail(peg$c40);
3750
+ }
3751
+ }
3752
+ if (s4 !== peg$FAILED) {
3753
+ if (peg$c68.test(input.charAt(peg$currPos))) {
3754
+ s5 = input.charAt(peg$currPos);
3755
+ peg$currPos++;
3756
+ }
3757
+ else {
3758
+ s5 = peg$FAILED;
3759
+ if (peg$silentFails === 0) {
3760
+ peg$fail(peg$c69);
3761
+ }
3762
+ }
3763
+ if (s5 !== peg$FAILED) {
3764
+ s4 = [s4, s5];
3765
+ s3 = s4;
3766
+ }
3767
+ else {
3768
+ peg$currPos = s3;
3769
+ s3 = peg$FAILED;
3770
+ }
3771
+ }
3772
+ else {
3773
+ peg$currPos = s3;
3774
+ s3 = peg$FAILED;
3775
+ }
3776
+ if (s3 === peg$FAILED) {
3777
+ s3 = null;
3778
+ }
3779
+ if (s3 !== peg$FAILED) {
3780
+ s2 = [s2, s3];
3781
+ s1 = s2;
3782
+ }
3783
+ else {
3784
+ peg$currPos = s1;
3785
+ s1 = peg$FAILED;
3786
+ }
3787
+ }
3788
+ else {
3789
+ peg$currPos = s1;
3790
+ s1 = peg$FAILED;
3791
+ }
3792
+ if (s1 === peg$FAILED) {
3793
+ s1 = peg$parseStringLiteral();
3794
+ if (s1 === peg$FAILED) {
3795
+ s1 = peg$parseComment();
3796
+ }
3797
+ }
3798
+ if (s1 === peg$FAILED) {
3799
+ s1 = peg$currPos;
3800
+ s2 = peg$parseLPAREN();
3801
+ if (s2 !== peg$FAILED) {
3802
+ s3 = peg$parse__();
3803
+ if (s3 !== peg$FAILED) {
3804
+ s4 = peg$parseParenSoup();
3805
+ if (s4 !== peg$FAILED) {
3806
+ s5 = peg$parse__();
3807
+ if (s5 !== peg$FAILED) {
3808
+ s6 = peg$parseRPAREN();
3809
+ if (s6 !== peg$FAILED) {
3810
+ s2 = [s2, s3, s4, s5, s6];
3811
+ s1 = s2;
3812
+ }
3813
+ else {
3814
+ peg$currPos = s1;
3815
+ s1 = peg$FAILED;
3816
+ }
3817
+ }
3818
+ else {
3819
+ peg$currPos = s1;
3820
+ s1 = peg$FAILED;
3821
+ }
3822
+ }
3823
+ else {
3824
+ peg$currPos = s1;
3825
+ s1 = peg$FAILED;
3826
+ }
3827
+ }
3828
+ else {
3829
+ peg$currPos = s1;
3830
+ s1 = peg$FAILED;
3831
+ }
3832
+ }
3833
+ else {
3834
+ peg$currPos = s1;
3835
+ s1 = peg$FAILED;
3836
+ }
3837
+ }
3838
+ }
3839
+ peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3840
+ return s0;
3841
+ }
3842
+ function peg$parseLayoutExprSoup() {
3843
+ let s0, s1, s2, s3, s4, s5, s6;
3844
+ const key = peg$currPos * 102 + 35;
3500
3845
  const cached = peg$resultsCache[key];
3501
3846
  if (cached) {
3502
3847
  peg$currPos = cached.nextPos;
@@ -3505,27 +3850,27 @@ function peg$parse(input, options) {
3505
3850
  s0 = [];
3506
3851
  s1 = peg$currPos;
3507
3852
  s2 = [];
3508
- if (peg$c65.test(input.charAt(peg$currPos))) {
3853
+ if (peg$c70.test(input.charAt(peg$currPos))) {
3509
3854
  s3 = input.charAt(peg$currPos);
3510
3855
  peg$currPos++;
3511
3856
  }
3512
3857
  else {
3513
3858
  s3 = peg$FAILED;
3514
3859
  if (peg$silentFails === 0) {
3515
- peg$fail(peg$c66);
3860
+ peg$fail(peg$c71);
3516
3861
  }
3517
3862
  }
3518
3863
  if (s3 !== peg$FAILED) {
3519
3864
  while (s3 !== peg$FAILED) {
3520
3865
  s2.push(s3);
3521
- if (peg$c65.test(input.charAt(peg$currPos))) {
3866
+ if (peg$c70.test(input.charAt(peg$currPos))) {
3522
3867
  s3 = input.charAt(peg$currPos);
3523
3868
  peg$currPos++;
3524
3869
  }
3525
3870
  else {
3526
3871
  s3 = peg$FAILED;
3527
3872
  if (peg$silentFails === 0) {
3528
- peg$fail(peg$c66);
3873
+ peg$fail(peg$c71);
3529
3874
  }
3530
3875
  }
3531
3876
  }
@@ -3536,24 +3881,24 @@ function peg$parse(input, options) {
3536
3881
  if (s2 !== peg$FAILED) {
3537
3882
  s3 = peg$currPos;
3538
3883
  if (input.charCodeAt(peg$currPos) === 47) {
3539
- s4 = peg$c38;
3884
+ s4 = peg$c39;
3540
3885
  peg$currPos++;
3541
3886
  }
3542
3887
  else {
3543
3888
  s4 = peg$FAILED;
3544
3889
  if (peg$silentFails === 0) {
3545
- peg$fail(peg$c39);
3890
+ peg$fail(peg$c40);
3546
3891
  }
3547
3892
  }
3548
3893
  if (s4 !== peg$FAILED) {
3549
- if (peg$c67.test(input.charAt(peg$currPos))) {
3894
+ if (peg$c68.test(input.charAt(peg$currPos))) {
3550
3895
  s5 = input.charAt(peg$currPos);
3551
3896
  peg$currPos++;
3552
3897
  }
3553
3898
  else {
3554
3899
  s5 = peg$FAILED;
3555
3900
  if (peg$silentFails === 0) {
3556
- peg$fail(peg$c68);
3901
+ peg$fail(peg$c69);
3557
3902
  }
3558
3903
  }
3559
3904
  if (s5 !== peg$FAILED) {
@@ -3635,27 +3980,27 @@ function peg$parse(input, options) {
3635
3980
  s0.push(s1);
3636
3981
  s1 = peg$currPos;
3637
3982
  s2 = [];
3638
- if (peg$c65.test(input.charAt(peg$currPos))) {
3983
+ if (peg$c70.test(input.charAt(peg$currPos))) {
3639
3984
  s3 = input.charAt(peg$currPos);
3640
3985
  peg$currPos++;
3641
3986
  }
3642
3987
  else {
3643
3988
  s3 = peg$FAILED;
3644
3989
  if (peg$silentFails === 0) {
3645
- peg$fail(peg$c66);
3990
+ peg$fail(peg$c71);
3646
3991
  }
3647
3992
  }
3648
3993
  if (s3 !== peg$FAILED) {
3649
3994
  while (s3 !== peg$FAILED) {
3650
3995
  s2.push(s3);
3651
- if (peg$c65.test(input.charAt(peg$currPos))) {
3996
+ if (peg$c70.test(input.charAt(peg$currPos))) {
3652
3997
  s3 = input.charAt(peg$currPos);
3653
3998
  peg$currPos++;
3654
3999
  }
3655
4000
  else {
3656
4001
  s3 = peg$FAILED;
3657
4002
  if (peg$silentFails === 0) {
3658
- peg$fail(peg$c66);
4003
+ peg$fail(peg$c71);
3659
4004
  }
3660
4005
  }
3661
4006
  }
@@ -3666,24 +4011,24 @@ function peg$parse(input, options) {
3666
4011
  if (s2 !== peg$FAILED) {
3667
4012
  s3 = peg$currPos;
3668
4013
  if (input.charCodeAt(peg$currPos) === 47) {
3669
- s4 = peg$c38;
4014
+ s4 = peg$c39;
3670
4015
  peg$currPos++;
3671
4016
  }
3672
4017
  else {
3673
4018
  s4 = peg$FAILED;
3674
4019
  if (peg$silentFails === 0) {
3675
- peg$fail(peg$c39);
4020
+ peg$fail(peg$c40);
3676
4021
  }
3677
4022
  }
3678
4023
  if (s4 !== peg$FAILED) {
3679
- if (peg$c67.test(input.charAt(peg$currPos))) {
4024
+ if (peg$c68.test(input.charAt(peg$currPos))) {
3680
4025
  s5 = input.charAt(peg$currPos);
3681
4026
  peg$currPos++;
3682
4027
  }
3683
4028
  else {
3684
4029
  s5 = peg$FAILED;
3685
4030
  if (peg$silentFails === 0) {
3686
- peg$fail(peg$c68);
4031
+ peg$fail(peg$c69);
3687
4032
  }
3688
4033
  }
3689
4034
  if (s5 !== peg$FAILED) {
@@ -3767,7 +4112,7 @@ function peg$parse(input, options) {
3767
4112
  }
3768
4113
  function peg$parseBraceSoup() {
3769
4114
  let s0, s1, s2, s3, s4, s5, s6;
3770
- const key = peg$currPos * 98 + 34;
4115
+ const key = peg$currPos * 102 + 36;
3771
4116
  const cached = peg$resultsCache[key];
3772
4117
  if (cached) {
3773
4118
  peg$currPos = cached.nextPos;
@@ -3776,27 +4121,27 @@ function peg$parse(input, options) {
3776
4121
  s0 = [];
3777
4122
  s1 = peg$currPos;
3778
4123
  s2 = [];
3779
- if (peg$c69.test(input.charAt(peg$currPos))) {
4124
+ if (peg$c72.test(input.charAt(peg$currPos))) {
3780
4125
  s3 = input.charAt(peg$currPos);
3781
4126
  peg$currPos++;
3782
4127
  }
3783
4128
  else {
3784
4129
  s3 = peg$FAILED;
3785
4130
  if (peg$silentFails === 0) {
3786
- peg$fail(peg$c70);
4131
+ peg$fail(peg$c73);
3787
4132
  }
3788
4133
  }
3789
4134
  if (s3 !== peg$FAILED) {
3790
4135
  while (s3 !== peg$FAILED) {
3791
4136
  s2.push(s3);
3792
- if (peg$c69.test(input.charAt(peg$currPos))) {
4137
+ if (peg$c72.test(input.charAt(peg$currPos))) {
3793
4138
  s3 = input.charAt(peg$currPos);
3794
4139
  peg$currPos++;
3795
4140
  }
3796
4141
  else {
3797
4142
  s3 = peg$FAILED;
3798
4143
  if (peg$silentFails === 0) {
3799
- peg$fail(peg$c70);
4144
+ peg$fail(peg$c73);
3800
4145
  }
3801
4146
  }
3802
4147
  }
@@ -3807,24 +4152,24 @@ function peg$parse(input, options) {
3807
4152
  if (s2 !== peg$FAILED) {
3808
4153
  s3 = peg$currPos;
3809
4154
  if (input.charCodeAt(peg$currPos) === 47) {
3810
- s4 = peg$c38;
4155
+ s4 = peg$c39;
3811
4156
  peg$currPos++;
3812
4157
  }
3813
4158
  else {
3814
4159
  s4 = peg$FAILED;
3815
4160
  if (peg$silentFails === 0) {
3816
- peg$fail(peg$c39);
4161
+ peg$fail(peg$c40);
3817
4162
  }
3818
4163
  }
3819
4164
  if (s4 !== peg$FAILED) {
3820
- if (peg$c71.test(input.charAt(peg$currPos))) {
4165
+ if (peg$c74.test(input.charAt(peg$currPos))) {
3821
4166
  s5 = input.charAt(peg$currPos);
3822
4167
  peg$currPos++;
3823
4168
  }
3824
4169
  else {
3825
4170
  s5 = peg$FAILED;
3826
4171
  if (peg$silentFails === 0) {
3827
- peg$fail(peg$c72);
4172
+ peg$fail(peg$c75);
3828
4173
  }
3829
4174
  }
3830
4175
  if (s5 !== peg$FAILED) {
@@ -3906,27 +4251,27 @@ function peg$parse(input, options) {
3906
4251
  s0.push(s1);
3907
4252
  s1 = peg$currPos;
3908
4253
  s2 = [];
3909
- if (peg$c69.test(input.charAt(peg$currPos))) {
4254
+ if (peg$c72.test(input.charAt(peg$currPos))) {
3910
4255
  s3 = input.charAt(peg$currPos);
3911
4256
  peg$currPos++;
3912
4257
  }
3913
4258
  else {
3914
4259
  s3 = peg$FAILED;
3915
4260
  if (peg$silentFails === 0) {
3916
- peg$fail(peg$c70);
4261
+ peg$fail(peg$c73);
3917
4262
  }
3918
4263
  }
3919
4264
  if (s3 !== peg$FAILED) {
3920
4265
  while (s3 !== peg$FAILED) {
3921
4266
  s2.push(s3);
3922
- if (peg$c69.test(input.charAt(peg$currPos))) {
4267
+ if (peg$c72.test(input.charAt(peg$currPos))) {
3923
4268
  s3 = input.charAt(peg$currPos);
3924
4269
  peg$currPos++;
3925
4270
  }
3926
4271
  else {
3927
4272
  s3 = peg$FAILED;
3928
4273
  if (peg$silentFails === 0) {
3929
- peg$fail(peg$c70);
4274
+ peg$fail(peg$c73);
3930
4275
  }
3931
4276
  }
3932
4277
  }
@@ -3937,24 +4282,24 @@ function peg$parse(input, options) {
3937
4282
  if (s2 !== peg$FAILED) {
3938
4283
  s3 = peg$currPos;
3939
4284
  if (input.charCodeAt(peg$currPos) === 47) {
3940
- s4 = peg$c38;
4285
+ s4 = peg$c39;
3941
4286
  peg$currPos++;
3942
4287
  }
3943
4288
  else {
3944
4289
  s4 = peg$FAILED;
3945
4290
  if (peg$silentFails === 0) {
3946
- peg$fail(peg$c39);
4291
+ peg$fail(peg$c40);
3947
4292
  }
3948
4293
  }
3949
4294
  if (s4 !== peg$FAILED) {
3950
- if (peg$c71.test(input.charAt(peg$currPos))) {
4295
+ if (peg$c74.test(input.charAt(peg$currPos))) {
3951
4296
  s5 = input.charAt(peg$currPos);
3952
4297
  peg$currPos++;
3953
4298
  }
3954
4299
  else {
3955
4300
  s5 = peg$FAILED;
3956
4301
  if (peg$silentFails === 0) {
3957
- peg$fail(peg$c72);
4302
+ peg$fail(peg$c75);
3958
4303
  }
3959
4304
  }
3960
4305
  if (s5 !== peg$FAILED) {
@@ -4038,75 +4383,75 @@ function peg$parse(input, options) {
4038
4383
  }
4039
4384
  function peg$parsePrimitiveWhiteSpace() {
4040
4385
  let s0;
4041
- const key = peg$currPos * 98 + 35;
4386
+ const key = peg$currPos * 102 + 37;
4042
4387
  const cached = peg$resultsCache[key];
4043
4388
  if (cached) {
4044
4389
  peg$currPos = cached.nextPos;
4045
4390
  return cached.result;
4046
4391
  }
4047
4392
  if (input.charCodeAt(peg$currPos) === 9) {
4048
- s0 = peg$c73;
4393
+ s0 = peg$c76;
4049
4394
  peg$currPos++;
4050
4395
  }
4051
4396
  else {
4052
4397
  s0 = peg$FAILED;
4053
4398
  if (peg$silentFails === 0) {
4054
- peg$fail(peg$c74);
4399
+ peg$fail(peg$c77);
4055
4400
  }
4056
4401
  }
4057
4402
  if (s0 === peg$FAILED) {
4058
4403
  if (input.charCodeAt(peg$currPos) === 11) {
4059
- s0 = peg$c75;
4404
+ s0 = peg$c78;
4060
4405
  peg$currPos++;
4061
4406
  }
4062
4407
  else {
4063
4408
  s0 = peg$FAILED;
4064
4409
  if (peg$silentFails === 0) {
4065
- peg$fail(peg$c76);
4410
+ peg$fail(peg$c79);
4066
4411
  }
4067
4412
  }
4068
4413
  if (s0 === peg$FAILED) {
4069
4414
  if (input.charCodeAt(peg$currPos) === 12) {
4070
- s0 = peg$c77;
4415
+ s0 = peg$c80;
4071
4416
  peg$currPos++;
4072
4417
  }
4073
4418
  else {
4074
4419
  s0 = peg$FAILED;
4075
4420
  if (peg$silentFails === 0) {
4076
- peg$fail(peg$c78);
4421
+ peg$fail(peg$c81);
4077
4422
  }
4078
4423
  }
4079
4424
  if (s0 === peg$FAILED) {
4080
4425
  if (input.charCodeAt(peg$currPos) === 32) {
4081
- s0 = peg$c79;
4426
+ s0 = peg$c82;
4082
4427
  peg$currPos++;
4083
4428
  }
4084
4429
  else {
4085
4430
  s0 = peg$FAILED;
4086
4431
  if (peg$silentFails === 0) {
4087
- peg$fail(peg$c80);
4432
+ peg$fail(peg$c83);
4088
4433
  }
4089
4434
  }
4090
4435
  if (s0 === peg$FAILED) {
4091
4436
  if (input.charCodeAt(peg$currPos) === 160) {
4092
- s0 = peg$c81;
4437
+ s0 = peg$c84;
4093
4438
  peg$currPos++;
4094
4439
  }
4095
4440
  else {
4096
4441
  s0 = peg$FAILED;
4097
4442
  if (peg$silentFails === 0) {
4098
- peg$fail(peg$c82);
4443
+ peg$fail(peg$c85);
4099
4444
  }
4100
4445
  }
4101
4446
  if (s0 === peg$FAILED) {
4102
4447
  if (input.charCodeAt(peg$currPos) === 65279) {
4103
- s0 = peg$c83;
4448
+ s0 = peg$c86;
4104
4449
  peg$currPos++;
4105
4450
  }
4106
4451
  else {
4107
4452
  s0 = peg$FAILED;
4108
4453
  if (peg$silentFails === 0) {
4109
- peg$fail(peg$c84);
4454
+ peg$fail(peg$c87);
4110
4455
  }
4111
4456
  }
4112
4457
  if (s0 === peg$FAILED) {
@@ -4122,20 +4467,20 @@ function peg$parse(input, options) {
4122
4467
  }
4123
4468
  function peg$parseZs() {
4124
4469
  let s0;
4125
- const key = peg$currPos * 98 + 36;
4470
+ const key = peg$currPos * 102 + 38;
4126
4471
  const cached = peg$resultsCache[key];
4127
4472
  if (cached) {
4128
4473
  peg$currPos = cached.nextPos;
4129
4474
  return cached.result;
4130
4475
  }
4131
- if (peg$c85.test(input.charAt(peg$currPos))) {
4476
+ if (peg$c88.test(input.charAt(peg$currPos))) {
4132
4477
  s0 = input.charAt(peg$currPos);
4133
4478
  peg$currPos++;
4134
4479
  }
4135
4480
  else {
4136
4481
  s0 = peg$FAILED;
4137
4482
  if (peg$silentFails === 0) {
4138
- peg$fail(peg$c86);
4483
+ peg$fail(peg$c89);
4139
4484
  }
4140
4485
  }
4141
4486
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4143,20 +4488,20 @@ function peg$parse(input, options) {
4143
4488
  }
4144
4489
  function peg$parseLineTerminator() {
4145
4490
  let s0;
4146
- const key = peg$currPos * 98 + 37;
4491
+ const key = peg$currPos * 102 + 39;
4147
4492
  const cached = peg$resultsCache[key];
4148
4493
  if (cached) {
4149
4494
  peg$currPos = cached.nextPos;
4150
4495
  return cached.result;
4151
4496
  }
4152
- if (peg$c87.test(input.charAt(peg$currPos))) {
4497
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4153
4498
  s0 = input.charAt(peg$currPos);
4154
4499
  peg$currPos++;
4155
4500
  }
4156
4501
  else {
4157
4502
  s0 = peg$FAILED;
4158
4503
  if (peg$silentFails === 0) {
4159
- peg$fail(peg$c88);
4504
+ peg$fail(peg$c91);
4160
4505
  }
4161
4506
  }
4162
4507
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4164,64 +4509,64 @@ function peg$parse(input, options) {
4164
4509
  }
4165
4510
  function peg$parseLineTerminatorSequence() {
4166
4511
  let s0;
4167
- const key = peg$currPos * 98 + 38;
4512
+ const key = peg$currPos * 102 + 40;
4168
4513
  const cached = peg$resultsCache[key];
4169
4514
  if (cached) {
4170
4515
  peg$currPos = cached.nextPos;
4171
4516
  return cached.result;
4172
4517
  }
4173
4518
  if (input.charCodeAt(peg$currPos) === 10) {
4174
- s0 = peg$c89;
4519
+ s0 = peg$c92;
4175
4520
  peg$currPos++;
4176
4521
  }
4177
4522
  else {
4178
4523
  s0 = peg$FAILED;
4179
4524
  if (peg$silentFails === 0) {
4180
- peg$fail(peg$c90);
4525
+ peg$fail(peg$c93);
4181
4526
  }
4182
4527
  }
4183
4528
  if (s0 === peg$FAILED) {
4184
- if (input.substr(peg$currPos, 2) === peg$c91) {
4185
- s0 = peg$c91;
4529
+ if (input.substr(peg$currPos, 2) === peg$c94) {
4530
+ s0 = peg$c94;
4186
4531
  peg$currPos += 2;
4187
4532
  }
4188
4533
  else {
4189
4534
  s0 = peg$FAILED;
4190
4535
  if (peg$silentFails === 0) {
4191
- peg$fail(peg$c92);
4536
+ peg$fail(peg$c95);
4192
4537
  }
4193
4538
  }
4194
4539
  if (s0 === peg$FAILED) {
4195
4540
  if (input.charCodeAt(peg$currPos) === 13) {
4196
- s0 = peg$c93;
4541
+ s0 = peg$c96;
4197
4542
  peg$currPos++;
4198
4543
  }
4199
4544
  else {
4200
4545
  s0 = peg$FAILED;
4201
4546
  if (peg$silentFails === 0) {
4202
- peg$fail(peg$c94);
4547
+ peg$fail(peg$c97);
4203
4548
  }
4204
4549
  }
4205
4550
  if (s0 === peg$FAILED) {
4206
4551
  if (input.charCodeAt(peg$currPos) === 8232) {
4207
- s0 = peg$c95;
4552
+ s0 = peg$c98;
4208
4553
  peg$currPos++;
4209
4554
  }
4210
4555
  else {
4211
4556
  s0 = peg$FAILED;
4212
4557
  if (peg$silentFails === 0) {
4213
- peg$fail(peg$c96);
4558
+ peg$fail(peg$c99);
4214
4559
  }
4215
4560
  }
4216
4561
  if (s0 === peg$FAILED) {
4217
4562
  if (input.charCodeAt(peg$currPos) === 8233) {
4218
- s0 = peg$c97;
4563
+ s0 = peg$c100;
4219
4564
  peg$currPos++;
4220
4565
  }
4221
4566
  else {
4222
4567
  s0 = peg$FAILED;
4223
4568
  if (peg$silentFails === 0) {
4224
- peg$fail(peg$c98);
4569
+ peg$fail(peg$c101);
4225
4570
  }
4226
4571
  }
4227
4572
  }
@@ -4233,7 +4578,7 @@ function peg$parse(input, options) {
4233
4578
  }
4234
4579
  function peg$parse__() {
4235
4580
  let s0, s1;
4236
- const key = peg$currPos * 98 + 39;
4581
+ const key = peg$currPos * 102 + 41;
4237
4582
  const cached = peg$resultsCache[key];
4238
4583
  if (cached) {
4239
4584
  peg$currPos = cached.nextPos;
@@ -4262,20 +4607,20 @@ function peg$parse(input, options) {
4262
4607
  }
4263
4608
  function peg$parseNonLineTerminator() {
4264
4609
  let s0;
4265
- const key = peg$currPos * 98 + 40;
4610
+ const key = peg$currPos * 102 + 42;
4266
4611
  const cached = peg$resultsCache[key];
4267
4612
  if (cached) {
4268
4613
  peg$currPos = cached.nextPos;
4269
4614
  return cached.result;
4270
4615
  }
4271
- if (peg$c99.test(input.charAt(peg$currPos))) {
4616
+ if (peg$c102.test(input.charAt(peg$currPos))) {
4272
4617
  s0 = input.charAt(peg$currPos);
4273
4618
  peg$currPos++;
4274
4619
  }
4275
4620
  else {
4276
4621
  s0 = peg$FAILED;
4277
4622
  if (peg$silentFails === 0) {
4278
- peg$fail(peg$c100);
4623
+ peg$fail(peg$c103);
4279
4624
  }
4280
4625
  }
4281
4626
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4283,45 +4628,45 @@ function peg$parse(input, options) {
4283
4628
  }
4284
4629
  function peg$parseEndOfLineComment() {
4285
4630
  let s0, s1, s2, s3, s4;
4286
- const key = peg$currPos * 98 + 41;
4631
+ const key = peg$currPos * 102 + 43;
4287
4632
  const cached = peg$resultsCache[key];
4288
4633
  if (cached) {
4289
4634
  peg$currPos = cached.nextPos;
4290
4635
  return cached.result;
4291
4636
  }
4292
4637
  s0 = peg$currPos;
4293
- if (input.substr(peg$currPos, 2) === peg$c101) {
4294
- s1 = peg$c101;
4638
+ if (input.substr(peg$currPos, 2) === peg$c104) {
4639
+ s1 = peg$c104;
4295
4640
  peg$currPos += 2;
4296
4641
  }
4297
4642
  else {
4298
4643
  s1 = peg$FAILED;
4299
4644
  if (peg$silentFails === 0) {
4300
- peg$fail(peg$c102);
4645
+ peg$fail(peg$c105);
4301
4646
  }
4302
4647
  }
4303
4648
  if (s1 !== peg$FAILED) {
4304
4649
  s2 = [];
4305
4650
  if (input.charCodeAt(peg$currPos) === 47) {
4306
- s3 = peg$c38;
4651
+ s3 = peg$c39;
4307
4652
  peg$currPos++;
4308
4653
  }
4309
4654
  else {
4310
4655
  s3 = peg$FAILED;
4311
4656
  if (peg$silentFails === 0) {
4312
- peg$fail(peg$c39);
4657
+ peg$fail(peg$c40);
4313
4658
  }
4314
4659
  }
4315
4660
  while (s3 !== peg$FAILED) {
4316
4661
  s2.push(s3);
4317
4662
  if (input.charCodeAt(peg$currPos) === 47) {
4318
- s3 = peg$c38;
4663
+ s3 = peg$c39;
4319
4664
  peg$currPos++;
4320
4665
  }
4321
4666
  else {
4322
4667
  s3 = peg$FAILED;
4323
4668
  if (peg$silentFails === 0) {
4324
- peg$fail(peg$c39);
4669
+ peg$fail(peg$c40);
4325
4670
  }
4326
4671
  }
4327
4672
  }
@@ -4334,7 +4679,7 @@ function peg$parse(input, options) {
4334
4679
  }
4335
4680
  if (s3 !== peg$FAILED) {
4336
4681
  peg$savedPos = s0;
4337
- s1 = peg$c103();
4682
+ s1 = peg$c106();
4338
4683
  s0 = s1;
4339
4684
  }
4340
4685
  else {
@@ -4356,47 +4701,47 @@ function peg$parse(input, options) {
4356
4701
  }
4357
4702
  function peg$parseEnclosedComment() {
4358
4703
  let s0, s1, s2, s3, s4, s5;
4359
- const key = peg$currPos * 98 + 42;
4704
+ const key = peg$currPos * 102 + 44;
4360
4705
  const cached = peg$resultsCache[key];
4361
4706
  if (cached) {
4362
4707
  peg$currPos = cached.nextPos;
4363
4708
  return cached.result;
4364
4709
  }
4365
4710
  s0 = peg$currPos;
4366
- if (input.substr(peg$currPos, 2) === peg$c104) {
4367
- s1 = peg$c104;
4711
+ if (input.substr(peg$currPos, 2) === peg$c107) {
4712
+ s1 = peg$c107;
4368
4713
  peg$currPos += 2;
4369
4714
  }
4370
4715
  else {
4371
4716
  s1 = peg$FAILED;
4372
4717
  if (peg$silentFails === 0) {
4373
- peg$fail(peg$c105);
4718
+ peg$fail(peg$c108);
4374
4719
  }
4375
4720
  }
4376
4721
  if (s1 !== peg$FAILED) {
4377
4722
  s2 = [];
4378
4723
  s3 = [];
4379
- if (peg$c106.test(input.charAt(peg$currPos))) {
4724
+ if (peg$c109.test(input.charAt(peg$currPos))) {
4380
4725
  s4 = input.charAt(peg$currPos);
4381
4726
  peg$currPos++;
4382
4727
  }
4383
4728
  else {
4384
4729
  s4 = peg$FAILED;
4385
4730
  if (peg$silentFails === 0) {
4386
- peg$fail(peg$c107);
4731
+ peg$fail(peg$c110);
4387
4732
  }
4388
4733
  }
4389
4734
  if (s4 !== peg$FAILED) {
4390
4735
  while (s4 !== peg$FAILED) {
4391
4736
  s3.push(s4);
4392
- if (peg$c106.test(input.charAt(peg$currPos))) {
4737
+ if (peg$c109.test(input.charAt(peg$currPos))) {
4393
4738
  s4 = input.charAt(peg$currPos);
4394
4739
  peg$currPos++;
4395
4740
  }
4396
4741
  else {
4397
4742
  s4 = peg$FAILED;
4398
4743
  if (peg$silentFails === 0) {
4399
- peg$fail(peg$c107);
4744
+ peg$fail(peg$c110);
4400
4745
  }
4401
4746
  }
4402
4747
  }
@@ -4408,26 +4753,26 @@ function peg$parse(input, options) {
4408
4753
  s3 = peg$currPos;
4409
4754
  s4 = [];
4410
4755
  if (input.charCodeAt(peg$currPos) === 42) {
4411
- s5 = peg$c36;
4756
+ s5 = peg$c37;
4412
4757
  peg$currPos++;
4413
4758
  }
4414
4759
  else {
4415
4760
  s5 = peg$FAILED;
4416
4761
  if (peg$silentFails === 0) {
4417
- peg$fail(peg$c37);
4762
+ peg$fail(peg$c38);
4418
4763
  }
4419
4764
  }
4420
4765
  if (s5 !== peg$FAILED) {
4421
4766
  while (s5 !== peg$FAILED) {
4422
4767
  s4.push(s5);
4423
4768
  if (input.charCodeAt(peg$currPos) === 42) {
4424
- s5 = peg$c36;
4769
+ s5 = peg$c37;
4425
4770
  peg$currPos++;
4426
4771
  }
4427
4772
  else {
4428
4773
  s5 = peg$FAILED;
4429
4774
  if (peg$silentFails === 0) {
4430
- peg$fail(peg$c37);
4775
+ peg$fail(peg$c38);
4431
4776
  }
4432
4777
  }
4433
4778
  }
@@ -4436,14 +4781,14 @@ function peg$parse(input, options) {
4436
4781
  s4 = peg$FAILED;
4437
4782
  }
4438
4783
  if (s4 !== peg$FAILED) {
4439
- if (peg$c108.test(input.charAt(peg$currPos))) {
4784
+ if (peg$c111.test(input.charAt(peg$currPos))) {
4440
4785
  s5 = input.charAt(peg$currPos);
4441
4786
  peg$currPos++;
4442
4787
  }
4443
4788
  else {
4444
4789
  s5 = peg$FAILED;
4445
4790
  if (peg$silentFails === 0) {
4446
- peg$fail(peg$c109);
4791
+ peg$fail(peg$c112);
4447
4792
  }
4448
4793
  }
4449
4794
  if (s5 !== peg$FAILED) {
@@ -4463,27 +4808,27 @@ function peg$parse(input, options) {
4463
4808
  while (s3 !== peg$FAILED) {
4464
4809
  s2.push(s3);
4465
4810
  s3 = [];
4466
- if (peg$c106.test(input.charAt(peg$currPos))) {
4811
+ if (peg$c109.test(input.charAt(peg$currPos))) {
4467
4812
  s4 = input.charAt(peg$currPos);
4468
4813
  peg$currPos++;
4469
4814
  }
4470
4815
  else {
4471
4816
  s4 = peg$FAILED;
4472
4817
  if (peg$silentFails === 0) {
4473
- peg$fail(peg$c107);
4818
+ peg$fail(peg$c110);
4474
4819
  }
4475
4820
  }
4476
4821
  if (s4 !== peg$FAILED) {
4477
4822
  while (s4 !== peg$FAILED) {
4478
4823
  s3.push(s4);
4479
- if (peg$c106.test(input.charAt(peg$currPos))) {
4824
+ if (peg$c109.test(input.charAt(peg$currPos))) {
4480
4825
  s4 = input.charAt(peg$currPos);
4481
4826
  peg$currPos++;
4482
4827
  }
4483
4828
  else {
4484
4829
  s4 = peg$FAILED;
4485
4830
  if (peg$silentFails === 0) {
4486
- peg$fail(peg$c107);
4831
+ peg$fail(peg$c110);
4487
4832
  }
4488
4833
  }
4489
4834
  }
@@ -4495,26 +4840,26 @@ function peg$parse(input, options) {
4495
4840
  s3 = peg$currPos;
4496
4841
  s4 = [];
4497
4842
  if (input.charCodeAt(peg$currPos) === 42) {
4498
- s5 = peg$c36;
4843
+ s5 = peg$c37;
4499
4844
  peg$currPos++;
4500
4845
  }
4501
4846
  else {
4502
4847
  s5 = peg$FAILED;
4503
4848
  if (peg$silentFails === 0) {
4504
- peg$fail(peg$c37);
4849
+ peg$fail(peg$c38);
4505
4850
  }
4506
4851
  }
4507
4852
  if (s5 !== peg$FAILED) {
4508
4853
  while (s5 !== peg$FAILED) {
4509
4854
  s4.push(s5);
4510
4855
  if (input.charCodeAt(peg$currPos) === 42) {
4511
- s5 = peg$c36;
4856
+ s5 = peg$c37;
4512
4857
  peg$currPos++;
4513
4858
  }
4514
4859
  else {
4515
4860
  s5 = peg$FAILED;
4516
4861
  if (peg$silentFails === 0) {
4517
- peg$fail(peg$c37);
4862
+ peg$fail(peg$c38);
4518
4863
  }
4519
4864
  }
4520
4865
  }
@@ -4523,14 +4868,14 @@ function peg$parse(input, options) {
4523
4868
  s4 = peg$FAILED;
4524
4869
  }
4525
4870
  if (s4 !== peg$FAILED) {
4526
- if (peg$c108.test(input.charAt(peg$currPos))) {
4871
+ if (peg$c111.test(input.charAt(peg$currPos))) {
4527
4872
  s5 = input.charAt(peg$currPos);
4528
4873
  peg$currPos++;
4529
4874
  }
4530
4875
  else {
4531
4876
  s5 = peg$FAILED;
4532
4877
  if (peg$silentFails === 0) {
4533
- peg$fail(peg$c109);
4878
+ peg$fail(peg$c112);
4534
4879
  }
4535
4880
  }
4536
4881
  if (s5 !== peg$FAILED) {
@@ -4551,26 +4896,26 @@ function peg$parse(input, options) {
4551
4896
  if (s2 !== peg$FAILED) {
4552
4897
  s3 = [];
4553
4898
  if (input.charCodeAt(peg$currPos) === 42) {
4554
- s4 = peg$c36;
4899
+ s4 = peg$c37;
4555
4900
  peg$currPos++;
4556
4901
  }
4557
4902
  else {
4558
4903
  s4 = peg$FAILED;
4559
4904
  if (peg$silentFails === 0) {
4560
- peg$fail(peg$c37);
4905
+ peg$fail(peg$c38);
4561
4906
  }
4562
4907
  }
4563
4908
  if (s4 !== peg$FAILED) {
4564
4909
  while (s4 !== peg$FAILED) {
4565
4910
  s3.push(s4);
4566
4911
  if (input.charCodeAt(peg$currPos) === 42) {
4567
- s4 = peg$c36;
4912
+ s4 = peg$c37;
4568
4913
  peg$currPos++;
4569
4914
  }
4570
4915
  else {
4571
4916
  s4 = peg$FAILED;
4572
4917
  if (peg$silentFails === 0) {
4573
- peg$fail(peg$c37);
4918
+ peg$fail(peg$c38);
4574
4919
  }
4575
4920
  }
4576
4921
  }
@@ -4580,13 +4925,13 @@ function peg$parse(input, options) {
4580
4925
  }
4581
4926
  if (s3 !== peg$FAILED) {
4582
4927
  if (input.charCodeAt(peg$currPos) === 47) {
4583
- s4 = peg$c38;
4928
+ s4 = peg$c39;
4584
4929
  peg$currPos++;
4585
4930
  }
4586
4931
  else {
4587
4932
  s4 = peg$FAILED;
4588
4933
  if (peg$silentFails === 0) {
4589
- peg$fail(peg$c39);
4934
+ peg$fail(peg$c40);
4590
4935
  }
4591
4936
  }
4592
4937
  if (s4 !== peg$FAILED) {
@@ -4618,7 +4963,7 @@ function peg$parse(input, options) {
4618
4963
  }
4619
4964
  function peg$parseComment() {
4620
4965
  let s0;
4621
- const key = peg$currPos * 98 + 43;
4966
+ const key = peg$currPos * 102 + 45;
4622
4967
  const cached = peg$resultsCache[key];
4623
4968
  if (cached) {
4624
4969
  peg$currPos = cached.nextPos;
@@ -4633,20 +4978,20 @@ function peg$parse(input, options) {
4633
4978
  }
4634
4979
  function peg$parseIMPORT() {
4635
4980
  let s0;
4636
- const key = peg$currPos * 98 + 44;
4981
+ const key = peg$currPos * 102 + 46;
4637
4982
  const cached = peg$resultsCache[key];
4638
4983
  if (cached) {
4639
4984
  peg$currPos = cached.nextPos;
4640
4985
  return cached.result;
4641
4986
  }
4642
- if (input.substr(peg$currPos, 6) === peg$c110) {
4643
- s0 = peg$c110;
4987
+ if (input.substr(peg$currPos, 6) === peg$c113) {
4988
+ s0 = peg$c113;
4644
4989
  peg$currPos += 6;
4645
4990
  }
4646
4991
  else {
4647
4992
  s0 = peg$FAILED;
4648
4993
  if (peg$silentFails === 0) {
4649
- peg$fail(peg$c111);
4994
+ peg$fail(peg$c114);
4650
4995
  }
4651
4996
  }
4652
4997
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4654,20 +4999,20 @@ function peg$parse(input, options) {
4654
4999
  }
4655
5000
  function peg$parseAS() {
4656
5001
  let s0;
4657
- const key = peg$currPos * 98 + 45;
5002
+ const key = peg$currPos * 102 + 47;
4658
5003
  const cached = peg$resultsCache[key];
4659
5004
  if (cached) {
4660
5005
  peg$currPos = cached.nextPos;
4661
5006
  return cached.result;
4662
5007
  }
4663
- if (input.substr(peg$currPos, 2) === peg$c112) {
4664
- s0 = peg$c112;
5008
+ if (input.substr(peg$currPos, 2) === peg$c115) {
5009
+ s0 = peg$c115;
4665
5010
  peg$currPos += 2;
4666
5011
  }
4667
5012
  else {
4668
5013
  s0 = peg$FAILED;
4669
5014
  if (peg$silentFails === 0) {
4670
- peg$fail(peg$c113);
5015
+ peg$fail(peg$c116);
4671
5016
  }
4672
5017
  }
4673
5018
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4675,20 +5020,20 @@ function peg$parse(input, options) {
4675
5020
  }
4676
5021
  function peg$parseFROM() {
4677
5022
  let s0;
4678
- const key = peg$currPos * 98 + 46;
5023
+ const key = peg$currPos * 102 + 48;
4679
5024
  const cached = peg$resultsCache[key];
4680
5025
  if (cached) {
4681
5026
  peg$currPos = cached.nextPos;
4682
5027
  return cached.result;
4683
5028
  }
4684
- if (input.substr(peg$currPos, 4) === peg$c114) {
4685
- s0 = peg$c114;
5029
+ if (input.substr(peg$currPos, 4) === peg$c117) {
5030
+ s0 = peg$c117;
4686
5031
  peg$currPos += 4;
4687
5032
  }
4688
5033
  else {
4689
5034
  s0 = peg$FAILED;
4690
5035
  if (peg$silentFails === 0) {
4691
- peg$fail(peg$c115);
5036
+ peg$fail(peg$c118);
4692
5037
  }
4693
5038
  }
4694
5039
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4696,7 +5041,7 @@ function peg$parse(input, options) {
4696
5041
  }
4697
5042
  function peg$parseSEMICOLON() {
4698
5043
  let s0;
4699
- const key = peg$currPos * 98 + 47;
5044
+ const key = peg$currPos * 102 + 49;
4700
5045
  const cached = peg$resultsCache[key];
4701
5046
  if (cached) {
4702
5047
  peg$currPos = cached.nextPos;
@@ -4717,20 +5062,20 @@ function peg$parse(input, options) {
4717
5062
  }
4718
5063
  function peg$parseASTERISK() {
4719
5064
  let s0;
4720
- const key = peg$currPos * 98 + 48;
5065
+ const key = peg$currPos * 102 + 50;
4721
5066
  const cached = peg$resultsCache[key];
4722
5067
  if (cached) {
4723
5068
  peg$currPos = cached.nextPos;
4724
5069
  return cached.result;
4725
5070
  }
4726
5071
  if (input.charCodeAt(peg$currPos) === 42) {
4727
- s0 = peg$c36;
5072
+ s0 = peg$c37;
4728
5073
  peg$currPos++;
4729
5074
  }
4730
5075
  else {
4731
5076
  s0 = peg$FAILED;
4732
5077
  if (peg$silentFails === 0) {
4733
- peg$fail(peg$c37);
5078
+ peg$fail(peg$c38);
4734
5079
  }
4735
5080
  }
4736
5081
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4738,20 +5083,20 @@ function peg$parse(input, options) {
4738
5083
  }
4739
5084
  function peg$parseLPAREN() {
4740
5085
  let s0;
4741
- const key = peg$currPos * 98 + 49;
5086
+ const key = peg$currPos * 102 + 51;
4742
5087
  const cached = peg$resultsCache[key];
4743
5088
  if (cached) {
4744
5089
  peg$currPos = cached.nextPos;
4745
5090
  return cached.result;
4746
5091
  }
4747
5092
  if (input.charCodeAt(peg$currPos) === 40) {
4748
- s0 = peg$c116;
5093
+ s0 = peg$c119;
4749
5094
  peg$currPos++;
4750
5095
  }
4751
5096
  else {
4752
5097
  s0 = peg$FAILED;
4753
5098
  if (peg$silentFails === 0) {
4754
- peg$fail(peg$c117);
5099
+ peg$fail(peg$c120);
4755
5100
  }
4756
5101
  }
4757
5102
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4759,20 +5104,20 @@ function peg$parse(input, options) {
4759
5104
  }
4760
5105
  function peg$parseRPAREN() {
4761
5106
  let s0;
4762
- const key = peg$currPos * 98 + 50;
5107
+ const key = peg$currPos * 102 + 52;
4763
5108
  const cached = peg$resultsCache[key];
4764
5109
  if (cached) {
4765
5110
  peg$currPos = cached.nextPos;
4766
5111
  return cached.result;
4767
5112
  }
4768
5113
  if (input.charCodeAt(peg$currPos) === 41) {
4769
- s0 = peg$c118;
5114
+ s0 = peg$c121;
4770
5115
  peg$currPos++;
4771
5116
  }
4772
5117
  else {
4773
5118
  s0 = peg$FAILED;
4774
5119
  if (peg$silentFails === 0) {
4775
- peg$fail(peg$c119);
5120
+ peg$fail(peg$c122);
4776
5121
  }
4777
5122
  }
4778
5123
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4780,20 +5125,20 @@ function peg$parse(input, options) {
4780
5125
  }
4781
5126
  function peg$parseLBRACE() {
4782
5127
  let s0;
4783
- const key = peg$currPos * 98 + 51;
5128
+ const key = peg$currPos * 102 + 53;
4784
5129
  const cached = peg$resultsCache[key];
4785
5130
  if (cached) {
4786
5131
  peg$currPos = cached.nextPos;
4787
5132
  return cached.result;
4788
5133
  }
4789
5134
  if (input.charCodeAt(peg$currPos) === 123) {
4790
- s0 = peg$c56;
5135
+ s0 = peg$c57;
4791
5136
  peg$currPos++;
4792
5137
  }
4793
5138
  else {
4794
5139
  s0 = peg$FAILED;
4795
5140
  if (peg$silentFails === 0) {
4796
- peg$fail(peg$c57);
5141
+ peg$fail(peg$c58);
4797
5142
  }
4798
5143
  }
4799
5144
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4801,20 +5146,20 @@ function peg$parse(input, options) {
4801
5146
  }
4802
5147
  function peg$parseRBRACE() {
4803
5148
  let s0;
4804
- const key = peg$currPos * 98 + 52;
5149
+ const key = peg$currPos * 102 + 54;
4805
5150
  const cached = peg$resultsCache[key];
4806
5151
  if (cached) {
4807
5152
  peg$currPos = cached.nextPos;
4808
5153
  return cached.result;
4809
5154
  }
4810
5155
  if (input.charCodeAt(peg$currPos) === 125) {
4811
- s0 = peg$c58;
5156
+ s0 = peg$c59;
4812
5157
  peg$currPos++;
4813
5158
  }
4814
5159
  else {
4815
5160
  s0 = peg$FAILED;
4816
5161
  if (peg$silentFails === 0) {
4817
- peg$fail(peg$c59);
5162
+ peg$fail(peg$c60);
4818
5163
  }
4819
5164
  }
4820
5165
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4822,20 +5167,20 @@ function peg$parse(input, options) {
4822
5167
  }
4823
5168
  function peg$parseLBRACKET() {
4824
5169
  let s0;
4825
- const key = peg$currPos * 98 + 53;
5170
+ const key = peg$currPos * 102 + 55;
4826
5171
  const cached = peg$resultsCache[key];
4827
5172
  if (cached) {
4828
5173
  peg$currPos = cached.nextPos;
4829
5174
  return cached.result;
4830
5175
  }
4831
5176
  if (input.charCodeAt(peg$currPos) === 91) {
4832
- s0 = peg$c120;
5177
+ s0 = peg$c123;
4833
5178
  peg$currPos++;
4834
5179
  }
4835
5180
  else {
4836
5181
  s0 = peg$FAILED;
4837
5182
  if (peg$silentFails === 0) {
4838
- peg$fail(peg$c121);
5183
+ peg$fail(peg$c124);
4839
5184
  }
4840
5185
  }
4841
5186
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4843,20 +5188,20 @@ function peg$parse(input, options) {
4843
5188
  }
4844
5189
  function peg$parseRBRACKET() {
4845
5190
  let s0;
4846
- const key = peg$currPos * 98 + 54;
5191
+ const key = peg$currPos * 102 + 56;
4847
5192
  const cached = peg$resultsCache[key];
4848
5193
  if (cached) {
4849
5194
  peg$currPos = cached.nextPos;
4850
5195
  return cached.result;
4851
5196
  }
4852
5197
  if (input.charCodeAt(peg$currPos) === 93) {
4853
- s0 = peg$c122;
5198
+ s0 = peg$c125;
4854
5199
  peg$currPos++;
4855
5200
  }
4856
5201
  else {
4857
5202
  s0 = peg$FAILED;
4858
5203
  if (peg$silentFails === 0) {
4859
- peg$fail(peg$c123);
5204
+ peg$fail(peg$c126);
4860
5205
  }
4861
5206
  }
4862
5207
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4864,20 +5209,20 @@ function peg$parse(input, options) {
4864
5209
  }
4865
5210
  function peg$parseCOMMA() {
4866
5211
  let s0;
4867
- const key = peg$currPos * 98 + 55;
5212
+ const key = peg$currPos * 102 + 57;
4868
5213
  const cached = peg$resultsCache[key];
4869
5214
  if (cached) {
4870
5215
  peg$currPos = cached.nextPos;
4871
5216
  return cached.result;
4872
5217
  }
4873
5218
  if (input.charCodeAt(peg$currPos) === 44) {
4874
- s0 = peg$c124;
5219
+ s0 = peg$c127;
4875
5220
  peg$currPos++;
4876
5221
  }
4877
5222
  else {
4878
5223
  s0 = peg$FAILED;
4879
5224
  if (peg$silentFails === 0) {
4880
- peg$fail(peg$c125);
5225
+ peg$fail(peg$c128);
4881
5226
  }
4882
5227
  }
4883
5228
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4885,20 +5230,20 @@ function peg$parse(input, options) {
4885
5230
  }
4886
5231
  function peg$parseEQUAL() {
4887
5232
  let s0;
4888
- const key = peg$currPos * 98 + 56;
5233
+ const key = peg$currPos * 102 + 58;
4889
5234
  const cached = peg$resultsCache[key];
4890
5235
  if (cached) {
4891
5236
  peg$currPos = cached.nextPos;
4892
5237
  return cached.result;
4893
5238
  }
4894
5239
  if (input.charCodeAt(peg$currPos) === 61) {
4895
- s0 = peg$c126;
5240
+ s0 = peg$c129;
4896
5241
  peg$currPos++;
4897
5242
  }
4898
5243
  else {
4899
5244
  s0 = peg$FAILED;
4900
5245
  if (peg$silentFails === 0) {
4901
- peg$fail(peg$c127);
5246
+ peg$fail(peg$c130);
4902
5247
  }
4903
5248
  }
4904
5249
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4906,20 +5251,20 @@ function peg$parse(input, options) {
4906
5251
  }
4907
5252
  function peg$parseADDRESS() {
4908
5253
  let s0;
4909
- const key = peg$currPos * 98 + 57;
5254
+ const key = peg$currPos * 102 + 59;
4910
5255
  const cached = peg$resultsCache[key];
4911
5256
  if (cached) {
4912
5257
  peg$currPos = cached.nextPos;
4913
5258
  return cached.result;
4914
5259
  }
4915
- if (input.substr(peg$currPos, 7) === peg$c128) {
4916
- s0 = peg$c128;
5260
+ if (input.substr(peg$currPos, 7) === peg$c131) {
5261
+ s0 = peg$c131;
4917
5262
  peg$currPos += 7;
4918
5263
  }
4919
5264
  else {
4920
5265
  s0 = peg$FAILED;
4921
5266
  if (peg$silentFails === 0) {
4922
- peg$fail(peg$c129);
5267
+ peg$fail(peg$c132);
4923
5268
  }
4924
5269
  }
4925
5270
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4927,20 +5272,20 @@ function peg$parse(input, options) {
4927
5272
  }
4928
5273
  function peg$parsePAYABLE() {
4929
5274
  let s0;
4930
- const key = peg$currPos * 98 + 58;
5275
+ const key = peg$currPos * 102 + 60;
4931
5276
  const cached = peg$resultsCache[key];
4932
5277
  if (cached) {
4933
5278
  peg$currPos = cached.nextPos;
4934
5279
  return cached.result;
4935
5280
  }
4936
- if (input.substr(peg$currPos, 7) === peg$c130) {
4937
- s0 = peg$c130;
5281
+ if (input.substr(peg$currPos, 7) === peg$c133) {
5282
+ s0 = peg$c133;
4938
5283
  peg$currPos += 7;
4939
5284
  }
4940
5285
  else {
4941
5286
  s0 = peg$FAILED;
4942
5287
  if (peg$silentFails === 0) {
4943
- peg$fail(peg$c131);
5288
+ peg$fail(peg$c134);
4944
5289
  }
4945
5290
  }
4946
5291
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4948,20 +5293,20 @@ function peg$parse(input, options) {
4948
5293
  }
4949
5294
  function peg$parseABSTRACT() {
4950
5295
  let s0;
4951
- const key = peg$currPos * 98 + 59;
5296
+ const key = peg$currPos * 102 + 61;
4952
5297
  const cached = peg$resultsCache[key];
4953
5298
  if (cached) {
4954
5299
  peg$currPos = cached.nextPos;
4955
5300
  return cached.result;
4956
5301
  }
4957
- if (input.substr(peg$currPos, 8) === peg$c132) {
4958
- s0 = peg$c132;
5302
+ if (input.substr(peg$currPos, 8) === peg$c135) {
5303
+ s0 = peg$c135;
4959
5304
  peg$currPos += 8;
4960
5305
  }
4961
5306
  else {
4962
5307
  s0 = peg$FAILED;
4963
5308
  if (peg$silentFails === 0) {
4964
- peg$fail(peg$c133);
5309
+ peg$fail(peg$c136);
4965
5310
  }
4966
5311
  }
4967
5312
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4969,20 +5314,20 @@ function peg$parse(input, options) {
4969
5314
  }
4970
5315
  function peg$parseCONTRACT() {
4971
5316
  let s0;
4972
- const key = peg$currPos * 98 + 60;
5317
+ const key = peg$currPos * 102 + 62;
4973
5318
  const cached = peg$resultsCache[key];
4974
5319
  if (cached) {
4975
5320
  peg$currPos = cached.nextPos;
4976
5321
  return cached.result;
4977
5322
  }
4978
- if (input.substr(peg$currPos, 8) === peg$c134) {
4979
- s0 = peg$c134;
5323
+ if (input.substr(peg$currPos, 8) === peg$c137) {
5324
+ s0 = peg$c137;
4980
5325
  peg$currPos += 8;
4981
5326
  }
4982
5327
  else {
4983
5328
  s0 = peg$FAILED;
4984
5329
  if (peg$silentFails === 0) {
4985
- peg$fail(peg$c135);
5330
+ peg$fail(peg$c138);
4986
5331
  }
4987
5332
  }
4988
5333
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -4990,20 +5335,20 @@ function peg$parse(input, options) {
4990
5335
  }
4991
5336
  function peg$parseLIBRARY() {
4992
5337
  let s0;
4993
- const key = peg$currPos * 98 + 61;
5338
+ const key = peg$currPos * 102 + 63;
4994
5339
  const cached = peg$resultsCache[key];
4995
5340
  if (cached) {
4996
5341
  peg$currPos = cached.nextPos;
4997
5342
  return cached.result;
4998
5343
  }
4999
- if (input.substr(peg$currPos, 7) === peg$c136) {
5000
- s0 = peg$c136;
5344
+ if (input.substr(peg$currPos, 7) === peg$c139) {
5345
+ s0 = peg$c139;
5001
5346
  peg$currPos += 7;
5002
5347
  }
5003
5348
  else {
5004
5349
  s0 = peg$FAILED;
5005
5350
  if (peg$silentFails === 0) {
5006
- peg$fail(peg$c137);
5351
+ peg$fail(peg$c140);
5007
5352
  }
5008
5353
  }
5009
5354
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5011,20 +5356,20 @@ function peg$parse(input, options) {
5011
5356
  }
5012
5357
  function peg$parseINTERFACE() {
5013
5358
  let s0;
5014
- const key = peg$currPos * 98 + 62;
5359
+ const key = peg$currPos * 102 + 64;
5015
5360
  const cached = peg$resultsCache[key];
5016
5361
  if (cached) {
5017
5362
  peg$currPos = cached.nextPos;
5018
5363
  return cached.result;
5019
5364
  }
5020
- if (input.substr(peg$currPos, 9) === peg$c138) {
5021
- s0 = peg$c138;
5365
+ if (input.substr(peg$currPos, 9) === peg$c141) {
5366
+ s0 = peg$c141;
5022
5367
  peg$currPos += 9;
5023
5368
  }
5024
5369
  else {
5025
5370
  s0 = peg$FAILED;
5026
5371
  if (peg$silentFails === 0) {
5027
- peg$fail(peg$c139);
5372
+ peg$fail(peg$c142);
5028
5373
  }
5029
5374
  }
5030
5375
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5032,20 +5377,20 @@ function peg$parse(input, options) {
5032
5377
  }
5033
5378
  function peg$parseSTRUCT() {
5034
5379
  let s0;
5035
- const key = peg$currPos * 98 + 63;
5380
+ const key = peg$currPos * 102 + 65;
5036
5381
  const cached = peg$resultsCache[key];
5037
5382
  if (cached) {
5038
5383
  peg$currPos = cached.nextPos;
5039
5384
  return cached.result;
5040
5385
  }
5041
- if (input.substr(peg$currPos, 6) === peg$c140) {
5042
- s0 = peg$c140;
5386
+ if (input.substr(peg$currPos, 6) === peg$c143) {
5387
+ s0 = peg$c143;
5043
5388
  peg$currPos += 6;
5044
5389
  }
5045
5390
  else {
5046
5391
  s0 = peg$FAILED;
5047
5392
  if (peg$silentFails === 0) {
5048
- peg$fail(peg$c141);
5393
+ peg$fail(peg$c144);
5049
5394
  }
5050
5395
  }
5051
5396
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5053,20 +5398,20 @@ function peg$parse(input, options) {
5053
5398
  }
5054
5399
  function peg$parseENUM() {
5055
5400
  let s0;
5056
- const key = peg$currPos * 98 + 64;
5401
+ const key = peg$currPos * 102 + 66;
5057
5402
  const cached = peg$resultsCache[key];
5058
5403
  if (cached) {
5059
5404
  peg$currPos = cached.nextPos;
5060
5405
  return cached.result;
5061
5406
  }
5062
- if (input.substr(peg$currPos, 4) === peg$c142) {
5063
- s0 = peg$c142;
5407
+ if (input.substr(peg$currPos, 4) === peg$c145) {
5408
+ s0 = peg$c145;
5064
5409
  peg$currPos += 4;
5065
5410
  }
5066
5411
  else {
5067
5412
  s0 = peg$FAILED;
5068
5413
  if (peg$silentFails === 0) {
5069
- peg$fail(peg$c143);
5414
+ peg$fail(peg$c146);
5070
5415
  }
5071
5416
  }
5072
5417
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5074,20 +5419,20 @@ function peg$parse(input, options) {
5074
5419
  }
5075
5420
  function peg$parseCONSTANT() {
5076
5421
  let s0;
5077
- const key = peg$currPos * 98 + 65;
5422
+ const key = peg$currPos * 102 + 67;
5078
5423
  const cached = peg$resultsCache[key];
5079
5424
  if (cached) {
5080
5425
  peg$currPos = cached.nextPos;
5081
5426
  return cached.result;
5082
5427
  }
5083
- if (input.substr(peg$currPos, 8) === peg$c144) {
5084
- s0 = peg$c144;
5428
+ if (input.substr(peg$currPos, 8) === peg$c147) {
5429
+ s0 = peg$c147;
5085
5430
  peg$currPos += 8;
5086
5431
  }
5087
5432
  else {
5088
5433
  s0 = peg$FAILED;
5089
5434
  if (peg$silentFails === 0) {
5090
- peg$fail(peg$c145);
5435
+ peg$fail(peg$c148);
5091
5436
  }
5092
5437
  }
5093
5438
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5095,20 +5440,20 @@ function peg$parse(input, options) {
5095
5440
  }
5096
5441
  function peg$parseFUNCTION() {
5097
5442
  let s0;
5098
- const key = peg$currPos * 98 + 66;
5443
+ const key = peg$currPos * 102 + 68;
5099
5444
  const cached = peg$resultsCache[key];
5100
5445
  if (cached) {
5101
5446
  peg$currPos = cached.nextPos;
5102
5447
  return cached.result;
5103
5448
  }
5104
- if (input.substr(peg$currPos, 8) === peg$c146) {
5105
- s0 = peg$c146;
5449
+ if (input.substr(peg$currPos, 8) === peg$c149) {
5450
+ s0 = peg$c149;
5106
5451
  peg$currPos += 8;
5107
5452
  }
5108
5453
  else {
5109
5454
  s0 = peg$FAILED;
5110
5455
  if (peg$silentFails === 0) {
5111
- peg$fail(peg$c147);
5456
+ peg$fail(peg$c150);
5112
5457
  }
5113
5458
  }
5114
5459
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5116,20 +5461,20 @@ function peg$parse(input, options) {
5116
5461
  }
5117
5462
  function peg$parseIS() {
5118
5463
  let s0;
5119
- const key = peg$currPos * 98 + 67;
5464
+ const key = peg$currPos * 102 + 69;
5120
5465
  const cached = peg$resultsCache[key];
5121
5466
  if (cached) {
5122
5467
  peg$currPos = cached.nextPos;
5123
5468
  return cached.result;
5124
5469
  }
5125
- if (input.substr(peg$currPos, 2) === peg$c148) {
5126
- s0 = peg$c148;
5470
+ if (input.substr(peg$currPos, 2) === peg$c151) {
5471
+ s0 = peg$c151;
5127
5472
  peg$currPos += 2;
5128
5473
  }
5129
5474
  else {
5130
5475
  s0 = peg$FAILED;
5131
5476
  if (peg$silentFails === 0) {
5132
- peg$fail(peg$c149);
5477
+ peg$fail(peg$c152);
5133
5478
  }
5134
5479
  }
5135
5480
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5137,20 +5482,20 @@ function peg$parse(input, options) {
5137
5482
  }
5138
5483
  function peg$parseTYPE() {
5139
5484
  let s0;
5140
- const key = peg$currPos * 98 + 68;
5485
+ const key = peg$currPos * 102 + 70;
5141
5486
  const cached = peg$resultsCache[key];
5142
5487
  if (cached) {
5143
5488
  peg$currPos = cached.nextPos;
5144
5489
  return cached.result;
5145
5490
  }
5146
- if (input.substr(peg$currPos, 4) === peg$c150) {
5147
- s0 = peg$c150;
5491
+ if (input.substr(peg$currPos, 4) === peg$c153) {
5492
+ s0 = peg$c153;
5148
5493
  peg$currPos += 4;
5149
5494
  }
5150
5495
  else {
5151
5496
  s0 = peg$FAILED;
5152
5497
  if (peg$silentFails === 0) {
5153
- peg$fail(peg$c151);
5498
+ peg$fail(peg$c154);
5154
5499
  }
5155
5500
  }
5156
5501
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5158,20 +5503,20 @@ function peg$parse(input, options) {
5158
5503
  }
5159
5504
  function peg$parseRETURNS() {
5160
5505
  let s0;
5161
- const key = peg$currPos * 98 + 69;
5506
+ const key = peg$currPos * 102 + 71;
5162
5507
  const cached = peg$resultsCache[key];
5163
5508
  if (cached) {
5164
5509
  peg$currPos = cached.nextPos;
5165
5510
  return cached.result;
5166
5511
  }
5167
- if (input.substr(peg$currPos, 7) === peg$c152) {
5168
- s0 = peg$c152;
5512
+ if (input.substr(peg$currPos, 7) === peg$c155) {
5513
+ s0 = peg$c155;
5169
5514
  peg$currPos += 7;
5170
5515
  }
5171
5516
  else {
5172
5517
  s0 = peg$FAILED;
5173
5518
  if (peg$silentFails === 0) {
5174
- peg$fail(peg$c153);
5519
+ peg$fail(peg$c156);
5175
5520
  }
5176
5521
  }
5177
5522
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5179,20 +5524,20 @@ function peg$parse(input, options) {
5179
5524
  }
5180
5525
  function peg$parsePRAGMA() {
5181
5526
  let s0;
5182
- const key = peg$currPos * 98 + 70;
5527
+ const key = peg$currPos * 102 + 72;
5183
5528
  const cached = peg$resultsCache[key];
5184
5529
  if (cached) {
5185
5530
  peg$currPos = cached.nextPos;
5186
5531
  return cached.result;
5187
5532
  }
5188
- if (input.substr(peg$currPos, 6) === peg$c154) {
5189
- s0 = peg$c154;
5533
+ if (input.substr(peg$currPos, 6) === peg$c157) {
5534
+ s0 = peg$c157;
5190
5535
  peg$currPos += 6;
5191
5536
  }
5192
5537
  else {
5193
5538
  s0 = peg$FAILED;
5194
5539
  if (peg$silentFails === 0) {
5195
- peg$fail(peg$c155);
5540
+ peg$fail(peg$c158);
5196
5541
  }
5197
5542
  }
5198
5543
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5200,20 +5545,20 @@ function peg$parse(input, options) {
5200
5545
  }
5201
5546
  function peg$parseERROR() {
5202
5547
  let s0;
5203
- const key = peg$currPos * 98 + 71;
5548
+ const key = peg$currPos * 102 + 73;
5204
5549
  const cached = peg$resultsCache[key];
5205
5550
  if (cached) {
5206
5551
  peg$currPos = cached.nextPos;
5207
5552
  return cached.result;
5208
5553
  }
5209
- if (input.substr(peg$currPos, 5) === peg$c156) {
5210
- s0 = peg$c156;
5554
+ if (input.substr(peg$currPos, 5) === peg$c159) {
5555
+ s0 = peg$c159;
5211
5556
  peg$currPos += 5;
5212
5557
  }
5213
5558
  else {
5214
5559
  s0 = peg$FAILED;
5215
5560
  if (peg$silentFails === 0) {
5216
- peg$fail(peg$c157);
5561
+ peg$fail(peg$c160);
5217
5562
  }
5218
5563
  }
5219
5564
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5221,20 +5566,20 @@ function peg$parse(input, options) {
5221
5566
  }
5222
5567
  function peg$parseEVENT() {
5223
5568
  let s0;
5224
- const key = peg$currPos * 98 + 72;
5569
+ const key = peg$currPos * 102 + 74;
5225
5570
  const cached = peg$resultsCache[key];
5226
5571
  if (cached) {
5227
5572
  peg$currPos = cached.nextPos;
5228
5573
  return cached.result;
5229
5574
  }
5230
- if (input.substr(peg$currPos, 5) === peg$c158) {
5231
- s0 = peg$c158;
5575
+ if (input.substr(peg$currPos, 5) === peg$c161) {
5576
+ s0 = peg$c161;
5232
5577
  peg$currPos += 5;
5233
5578
  }
5234
5579
  else {
5235
5580
  s0 = peg$FAILED;
5236
5581
  if (peg$silentFails === 0) {
5237
- peg$fail(peg$c159);
5582
+ peg$fail(peg$c162);
5238
5583
  }
5239
5584
  }
5240
5585
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5242,20 +5587,20 @@ function peg$parse(input, options) {
5242
5587
  }
5243
5588
  function peg$parseUSING() {
5244
5589
  let s0;
5245
- const key = peg$currPos * 98 + 73;
5590
+ const key = peg$currPos * 102 + 75;
5246
5591
  const cached = peg$resultsCache[key];
5247
5592
  if (cached) {
5248
5593
  peg$currPos = cached.nextPos;
5249
5594
  return cached.result;
5250
5595
  }
5251
- if (input.substr(peg$currPos, 5) === peg$c160) {
5252
- s0 = peg$c160;
5596
+ if (input.substr(peg$currPos, 5) === peg$c163) {
5597
+ s0 = peg$c163;
5253
5598
  peg$currPos += 5;
5254
5599
  }
5255
5600
  else {
5256
5601
  s0 = peg$FAILED;
5257
5602
  if (peg$silentFails === 0) {
5258
- peg$fail(peg$c161);
5603
+ peg$fail(peg$c164);
5259
5604
  }
5260
5605
  }
5261
5606
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5263,20 +5608,20 @@ function peg$parse(input, options) {
5263
5608
  }
5264
5609
  function peg$parseFOR() {
5265
5610
  let s0;
5266
- const key = peg$currPos * 98 + 74;
5611
+ const key = peg$currPos * 102 + 76;
5267
5612
  const cached = peg$resultsCache[key];
5268
5613
  if (cached) {
5269
5614
  peg$currPos = cached.nextPos;
5270
5615
  return cached.result;
5271
5616
  }
5272
- if (input.substr(peg$currPos, 3) === peg$c162) {
5273
- s0 = peg$c162;
5617
+ if (input.substr(peg$currPos, 3) === peg$c165) {
5618
+ s0 = peg$c165;
5274
5619
  peg$currPos += 3;
5275
5620
  }
5276
5621
  else {
5277
5622
  s0 = peg$FAILED;
5278
5623
  if (peg$silentFails === 0) {
5279
- peg$fail(peg$c163);
5624
+ peg$fail(peg$c166);
5280
5625
  }
5281
5626
  }
5282
5627
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5284,20 +5629,20 @@ function peg$parse(input, options) {
5284
5629
  }
5285
5630
  function peg$parseGLOBAL() {
5286
5631
  let s0;
5287
- const key = peg$currPos * 98 + 75;
5632
+ const key = peg$currPos * 102 + 77;
5288
5633
  const cached = peg$resultsCache[key];
5289
5634
  if (cached) {
5290
5635
  peg$currPos = cached.nextPos;
5291
5636
  return cached.result;
5292
5637
  }
5293
- if (input.substr(peg$currPos, 6) === peg$c164) {
5294
- s0 = peg$c164;
5638
+ if (input.substr(peg$currPos, 6) === peg$c167) {
5639
+ s0 = peg$c167;
5295
5640
  peg$currPos += 6;
5296
5641
  }
5297
5642
  else {
5298
5643
  s0 = peg$FAILED;
5299
5644
  if (peg$silentFails === 0) {
5300
- peg$fail(peg$c165);
5645
+ peg$fail(peg$c168);
5301
5646
  }
5302
5647
  }
5303
5648
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5305,20 +5650,62 @@ function peg$parse(input, options) {
5305
5650
  }
5306
5651
  function peg$parseANONYMOUS() {
5307
5652
  let s0;
5308
- const key = peg$currPos * 98 + 76;
5653
+ const key = peg$currPos * 102 + 78;
5309
5654
  const cached = peg$resultsCache[key];
5310
5655
  if (cached) {
5311
5656
  peg$currPos = cached.nextPos;
5312
5657
  return cached.result;
5313
5658
  }
5314
- if (input.substr(peg$currPos, 9) === peg$c166) {
5315
- s0 = peg$c166;
5659
+ if (input.substr(peg$currPos, 9) === peg$c169) {
5660
+ s0 = peg$c169;
5316
5661
  peg$currPos += 9;
5317
5662
  }
5318
5663
  else {
5319
5664
  s0 = peg$FAILED;
5320
5665
  if (peg$silentFails === 0) {
5321
- peg$fail(peg$c167);
5666
+ peg$fail(peg$c170);
5667
+ }
5668
+ }
5669
+ peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5670
+ return s0;
5671
+ }
5672
+ function peg$parseLAYOUT() {
5673
+ let s0;
5674
+ const key = peg$currPos * 102 + 79;
5675
+ const cached = peg$resultsCache[key];
5676
+ if (cached) {
5677
+ peg$currPos = cached.nextPos;
5678
+ return cached.result;
5679
+ }
5680
+ if (input.substr(peg$currPos, 6) === peg$c171) {
5681
+ s0 = peg$c171;
5682
+ peg$currPos += 6;
5683
+ }
5684
+ else {
5685
+ s0 = peg$FAILED;
5686
+ if (peg$silentFails === 0) {
5687
+ peg$fail(peg$c172);
5688
+ }
5689
+ }
5690
+ peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5691
+ return s0;
5692
+ }
5693
+ function peg$parseAT() {
5694
+ let s0;
5695
+ const key = peg$currPos * 102 + 80;
5696
+ const cached = peg$resultsCache[key];
5697
+ if (cached) {
5698
+ peg$currPos = cached.nextPos;
5699
+ return cached.result;
5700
+ }
5701
+ if (input.substr(peg$currPos, 2) === peg$c173) {
5702
+ s0 = peg$c173;
5703
+ peg$currPos += 2;
5704
+ }
5705
+ else {
5706
+ s0 = peg$FAILED;
5707
+ if (peg$silentFails === 0) {
5708
+ peg$fail(peg$c174);
5322
5709
  }
5323
5710
  }
5324
5711
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5326,7 +5713,7 @@ function peg$parse(input, options) {
5326
5713
  }
5327
5714
  function peg$parseStringLiteral() {
5328
5715
  let s0, s1, s2, s3;
5329
- const key = peg$currPos * 98 + 77;
5716
+ const key = peg$currPos * 102 + 81;
5330
5717
  const cached = peg$resultsCache[key];
5331
5718
  if (cached) {
5332
5719
  peg$currPos = cached.nextPos;
@@ -5334,13 +5721,13 @@ function peg$parse(input, options) {
5334
5721
  }
5335
5722
  s0 = peg$currPos;
5336
5723
  if (input.charCodeAt(peg$currPos) === 39) {
5337
- s1 = peg$c168;
5724
+ s1 = peg$c175;
5338
5725
  peg$currPos++;
5339
5726
  }
5340
5727
  else {
5341
5728
  s1 = peg$FAILED;
5342
5729
  if (peg$silentFails === 0) {
5343
- peg$fail(peg$c169);
5730
+ peg$fail(peg$c176);
5344
5731
  }
5345
5732
  }
5346
5733
  if (s1 !== peg$FAILED) {
@@ -5352,18 +5739,18 @@ function peg$parse(input, options) {
5352
5739
  }
5353
5740
  if (s2 !== peg$FAILED) {
5354
5741
  if (input.charCodeAt(peg$currPos) === 39) {
5355
- s3 = peg$c168;
5742
+ s3 = peg$c175;
5356
5743
  peg$currPos++;
5357
5744
  }
5358
5745
  else {
5359
5746
  s3 = peg$FAILED;
5360
5747
  if (peg$silentFails === 0) {
5361
- peg$fail(peg$c169);
5748
+ peg$fail(peg$c176);
5362
5749
  }
5363
5750
  }
5364
5751
  if (s3 !== peg$FAILED) {
5365
5752
  peg$savedPos = s0;
5366
- s1 = peg$c170(s2);
5753
+ s1 = peg$c177(s2);
5367
5754
  s0 = s1;
5368
5755
  }
5369
5756
  else {
@@ -5383,13 +5770,13 @@ function peg$parse(input, options) {
5383
5770
  if (s0 === peg$FAILED) {
5384
5771
  s0 = peg$currPos;
5385
5772
  if (input.charCodeAt(peg$currPos) === 34) {
5386
- s1 = peg$c171;
5773
+ s1 = peg$c178;
5387
5774
  peg$currPos++;
5388
5775
  }
5389
5776
  else {
5390
5777
  s1 = peg$FAILED;
5391
5778
  if (peg$silentFails === 0) {
5392
- peg$fail(peg$c172);
5779
+ peg$fail(peg$c179);
5393
5780
  }
5394
5781
  }
5395
5782
  if (s1 !== peg$FAILED) {
@@ -5401,18 +5788,18 @@ function peg$parse(input, options) {
5401
5788
  }
5402
5789
  if (s2 !== peg$FAILED) {
5403
5790
  if (input.charCodeAt(peg$currPos) === 34) {
5404
- s3 = peg$c171;
5791
+ s3 = peg$c178;
5405
5792
  peg$currPos++;
5406
5793
  }
5407
5794
  else {
5408
5795
  s3 = peg$FAILED;
5409
5796
  if (peg$silentFails === 0) {
5410
- peg$fail(peg$c172);
5797
+ peg$fail(peg$c179);
5411
5798
  }
5412
5799
  }
5413
5800
  if (s3 !== peg$FAILED) {
5414
5801
  peg$savedPos = s0;
5415
- s1 = peg$c170(s2);
5802
+ s1 = peg$c177(s2);
5416
5803
  s0 = s1;
5417
5804
  }
5418
5805
  else {
@@ -5435,7 +5822,7 @@ function peg$parse(input, options) {
5435
5822
  }
5436
5823
  function peg$parseAnyChar() {
5437
5824
  let s0;
5438
- const key = peg$currPos * 98 + 78;
5825
+ const key = peg$currPos * 102 + 82;
5439
5826
  const cached = peg$resultsCache[key];
5440
5827
  if (cached) {
5441
5828
  peg$currPos = cached.nextPos;
@@ -5448,7 +5835,7 @@ function peg$parse(input, options) {
5448
5835
  else {
5449
5836
  s0 = peg$FAILED;
5450
5837
  if (peg$silentFails === 0) {
5451
- peg$fail(peg$c173);
5838
+ peg$fail(peg$c180);
5452
5839
  }
5453
5840
  }
5454
5841
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5456,7 +5843,7 @@ function peg$parse(input, options) {
5456
5843
  }
5457
5844
  function peg$parseDoubleStringChar() {
5458
5845
  let s0, s1, s2;
5459
- const key = peg$currPos * 98 + 79;
5846
+ const key = peg$currPos * 102 + 83;
5460
5847
  const cached = peg$resultsCache[key];
5461
5848
  if (cached) {
5462
5849
  peg$currPos = cached.nextPos;
@@ -5466,24 +5853,24 @@ function peg$parse(input, options) {
5466
5853
  s1 = peg$currPos;
5467
5854
  peg$silentFails++;
5468
5855
  if (input.charCodeAt(peg$currPos) === 34) {
5469
- s2 = peg$c171;
5856
+ s2 = peg$c178;
5470
5857
  peg$currPos++;
5471
5858
  }
5472
5859
  else {
5473
5860
  s2 = peg$FAILED;
5474
5861
  if (peg$silentFails === 0) {
5475
- peg$fail(peg$c172);
5862
+ peg$fail(peg$c179);
5476
5863
  }
5477
5864
  }
5478
5865
  if (s2 === peg$FAILED) {
5479
5866
  if (input.charCodeAt(peg$currPos) === 92) {
5480
- s2 = peg$c174;
5867
+ s2 = peg$c181;
5481
5868
  peg$currPos++;
5482
5869
  }
5483
5870
  else {
5484
5871
  s2 = peg$FAILED;
5485
5872
  if (peg$silentFails === 0) {
5486
- peg$fail(peg$c175);
5873
+ peg$fail(peg$c182);
5487
5874
  }
5488
5875
  }
5489
5876
  if (s2 === peg$FAILED) {
@@ -5517,20 +5904,20 @@ function peg$parse(input, options) {
5517
5904
  if (s0 === peg$FAILED) {
5518
5905
  s0 = peg$currPos;
5519
5906
  if (input.charCodeAt(peg$currPos) === 92) {
5520
- s1 = peg$c174;
5907
+ s1 = peg$c181;
5521
5908
  peg$currPos++;
5522
5909
  }
5523
5910
  else {
5524
5911
  s1 = peg$FAILED;
5525
5912
  if (peg$silentFails === 0) {
5526
- peg$fail(peg$c175);
5913
+ peg$fail(peg$c182);
5527
5914
  }
5528
5915
  }
5529
5916
  if (s1 !== peg$FAILED) {
5530
5917
  s2 = peg$parseEscapeSequence();
5531
5918
  if (s2 !== peg$FAILED) {
5532
5919
  peg$savedPos = s0;
5533
- s1 = peg$c176(s2);
5920
+ s1 = peg$c183(s2);
5534
5921
  s0 = s1;
5535
5922
  }
5536
5923
  else {
@@ -5551,7 +5938,7 @@ function peg$parse(input, options) {
5551
5938
  }
5552
5939
  function peg$parseSingleStringChar() {
5553
5940
  let s0, s1, s2;
5554
- const key = peg$currPos * 98 + 80;
5941
+ const key = peg$currPos * 102 + 84;
5555
5942
  const cached = peg$resultsCache[key];
5556
5943
  if (cached) {
5557
5944
  peg$currPos = cached.nextPos;
@@ -5561,24 +5948,24 @@ function peg$parse(input, options) {
5561
5948
  s1 = peg$currPos;
5562
5949
  peg$silentFails++;
5563
5950
  if (input.charCodeAt(peg$currPos) === 39) {
5564
- s2 = peg$c168;
5951
+ s2 = peg$c175;
5565
5952
  peg$currPos++;
5566
5953
  }
5567
5954
  else {
5568
5955
  s2 = peg$FAILED;
5569
5956
  if (peg$silentFails === 0) {
5570
- peg$fail(peg$c169);
5957
+ peg$fail(peg$c176);
5571
5958
  }
5572
5959
  }
5573
5960
  if (s2 === peg$FAILED) {
5574
5961
  if (input.charCodeAt(peg$currPos) === 92) {
5575
- s2 = peg$c174;
5962
+ s2 = peg$c181;
5576
5963
  peg$currPos++;
5577
5964
  }
5578
5965
  else {
5579
5966
  s2 = peg$FAILED;
5580
5967
  if (peg$silentFails === 0) {
5581
- peg$fail(peg$c175);
5968
+ peg$fail(peg$c182);
5582
5969
  }
5583
5970
  }
5584
5971
  if (s2 === peg$FAILED) {
@@ -5612,20 +5999,20 @@ function peg$parse(input, options) {
5612
5999
  if (s0 === peg$FAILED) {
5613
6000
  s0 = peg$currPos;
5614
6001
  if (input.charCodeAt(peg$currPos) === 92) {
5615
- s1 = peg$c174;
6002
+ s1 = peg$c181;
5616
6003
  peg$currPos++;
5617
6004
  }
5618
6005
  else {
5619
6006
  s1 = peg$FAILED;
5620
6007
  if (peg$silentFails === 0) {
5621
- peg$fail(peg$c175);
6008
+ peg$fail(peg$c182);
5622
6009
  }
5623
6010
  }
5624
6011
  if (s1 !== peg$FAILED) {
5625
6012
  s2 = peg$parseEscapeSequence();
5626
6013
  if (s2 !== peg$FAILED) {
5627
6014
  peg$savedPos = s0;
5628
- s1 = peg$c176(s2);
6015
+ s1 = peg$c183(s2);
5629
6016
  s0 = s1;
5630
6017
  }
5631
6018
  else {
@@ -5646,7 +6033,7 @@ function peg$parse(input, options) {
5646
6033
  }
5647
6034
  function peg$parseLineContinuation() {
5648
6035
  let s0, s1, s2;
5649
- const key = peg$currPos * 98 + 81;
6036
+ const key = peg$currPos * 102 + 85;
5650
6037
  const cached = peg$resultsCache[key];
5651
6038
  if (cached) {
5652
6039
  peg$currPos = cached.nextPos;
@@ -5654,20 +6041,20 @@ function peg$parse(input, options) {
5654
6041
  }
5655
6042
  s0 = peg$currPos;
5656
6043
  if (input.charCodeAt(peg$currPos) === 92) {
5657
- s1 = peg$c174;
6044
+ s1 = peg$c181;
5658
6045
  peg$currPos++;
5659
6046
  }
5660
6047
  else {
5661
6048
  s1 = peg$FAILED;
5662
6049
  if (peg$silentFails === 0) {
5663
- peg$fail(peg$c175);
6050
+ peg$fail(peg$c182);
5664
6051
  }
5665
6052
  }
5666
6053
  if (s1 !== peg$FAILED) {
5667
6054
  s2 = peg$parseLineTerminatorSequence();
5668
6055
  if (s2 !== peg$FAILED) {
5669
6056
  peg$savedPos = s0;
5670
- s1 = peg$c177();
6057
+ s1 = peg$c184();
5671
6058
  s0 = s1;
5672
6059
  }
5673
6060
  else {
@@ -5684,7 +6071,7 @@ function peg$parse(input, options) {
5684
6071
  }
5685
6072
  function peg$parseEscapeSequence() {
5686
6073
  let s0, s1, s2, s3;
5687
- const key = peg$currPos * 98 + 82;
6074
+ const key = peg$currPos * 102 + 86;
5688
6075
  const cached = peg$resultsCache[key];
5689
6076
  if (cached) {
5690
6077
  peg$currPos = cached.nextPos;
@@ -5694,13 +6081,13 @@ function peg$parse(input, options) {
5694
6081
  if (s0 === peg$FAILED) {
5695
6082
  s0 = peg$currPos;
5696
6083
  if (input.charCodeAt(peg$currPos) === 48) {
5697
- s1 = peg$c178;
6084
+ s1 = peg$c185;
5698
6085
  peg$currPos++;
5699
6086
  }
5700
6087
  else {
5701
6088
  s1 = peg$FAILED;
5702
6089
  if (peg$silentFails === 0) {
5703
- peg$fail(peg$c179);
6090
+ peg$fail(peg$c186);
5704
6091
  }
5705
6092
  }
5706
6093
  if (s1 !== peg$FAILED) {
@@ -5717,7 +6104,7 @@ function peg$parse(input, options) {
5717
6104
  }
5718
6105
  if (s2 !== peg$FAILED) {
5719
6106
  peg$savedPos = s0;
5720
- s1 = peg$c180();
6107
+ s1 = peg$c187();
5721
6108
  s0 = s1;
5722
6109
  }
5723
6110
  else {
@@ -5744,7 +6131,7 @@ function peg$parse(input, options) {
5744
6131
  }
5745
6132
  function peg$parseCharEscapeSequence() {
5746
6133
  let s0;
5747
- const key = peg$currPos * 98 + 83;
6134
+ const key = peg$currPos * 102 + 87;
5748
6135
  const cached = peg$resultsCache[key];
5749
6136
  if (cached) {
5750
6137
  peg$currPos = cached.nextPos;
@@ -5759,144 +6146,144 @@ function peg$parse(input, options) {
5759
6146
  }
5760
6147
  function peg$parseSingleEscapeChar() {
5761
6148
  let s0, s1;
5762
- const key = peg$currPos * 98 + 84;
6149
+ const key = peg$currPos * 102 + 88;
5763
6150
  const cached = peg$resultsCache[key];
5764
6151
  if (cached) {
5765
6152
  peg$currPos = cached.nextPos;
5766
6153
  return cached.result;
5767
6154
  }
5768
6155
  if (input.charCodeAt(peg$currPos) === 39) {
5769
- s0 = peg$c168;
6156
+ s0 = peg$c175;
5770
6157
  peg$currPos++;
5771
6158
  }
5772
6159
  else {
5773
6160
  s0 = peg$FAILED;
5774
6161
  if (peg$silentFails === 0) {
5775
- peg$fail(peg$c169);
6162
+ peg$fail(peg$c176);
5776
6163
  }
5777
6164
  }
5778
6165
  if (s0 === peg$FAILED) {
5779
6166
  if (input.charCodeAt(peg$currPos) === 34) {
5780
- s0 = peg$c171;
6167
+ s0 = peg$c178;
5781
6168
  peg$currPos++;
5782
6169
  }
5783
6170
  else {
5784
6171
  s0 = peg$FAILED;
5785
6172
  if (peg$silentFails === 0) {
5786
- peg$fail(peg$c172);
6173
+ peg$fail(peg$c179);
5787
6174
  }
5788
6175
  }
5789
6176
  if (s0 === peg$FAILED) {
5790
6177
  if (input.charCodeAt(peg$currPos) === 92) {
5791
- s0 = peg$c174;
6178
+ s0 = peg$c181;
5792
6179
  peg$currPos++;
5793
6180
  }
5794
6181
  else {
5795
6182
  s0 = peg$FAILED;
5796
6183
  if (peg$silentFails === 0) {
5797
- peg$fail(peg$c175);
6184
+ peg$fail(peg$c182);
5798
6185
  }
5799
6186
  }
5800
6187
  if (s0 === peg$FAILED) {
5801
6188
  s0 = peg$currPos;
5802
6189
  if (input.charCodeAt(peg$currPos) === 98) {
5803
- s1 = peg$c181;
6190
+ s1 = peg$c188;
5804
6191
  peg$currPos++;
5805
6192
  }
5806
6193
  else {
5807
6194
  s1 = peg$FAILED;
5808
6195
  if (peg$silentFails === 0) {
5809
- peg$fail(peg$c182);
6196
+ peg$fail(peg$c189);
5810
6197
  }
5811
6198
  }
5812
6199
  if (s1 !== peg$FAILED) {
5813
6200
  peg$savedPos = s0;
5814
- s1 = peg$c183();
6201
+ s1 = peg$c190();
5815
6202
  }
5816
6203
  s0 = s1;
5817
6204
  if (s0 === peg$FAILED) {
5818
6205
  s0 = peg$currPos;
5819
6206
  if (input.charCodeAt(peg$currPos) === 102) {
5820
- s1 = peg$c184;
6207
+ s1 = peg$c191;
5821
6208
  peg$currPos++;
5822
6209
  }
5823
6210
  else {
5824
6211
  s1 = peg$FAILED;
5825
6212
  if (peg$silentFails === 0) {
5826
- peg$fail(peg$c185);
6213
+ peg$fail(peg$c192);
5827
6214
  }
5828
6215
  }
5829
6216
  if (s1 !== peg$FAILED) {
5830
6217
  peg$savedPos = s0;
5831
- s1 = peg$c186();
6218
+ s1 = peg$c193();
5832
6219
  }
5833
6220
  s0 = s1;
5834
6221
  if (s0 === peg$FAILED) {
5835
6222
  s0 = peg$currPos;
5836
6223
  if (input.charCodeAt(peg$currPos) === 110) {
5837
- s1 = peg$c187;
6224
+ s1 = peg$c194;
5838
6225
  peg$currPos++;
5839
6226
  }
5840
6227
  else {
5841
6228
  s1 = peg$FAILED;
5842
6229
  if (peg$silentFails === 0) {
5843
- peg$fail(peg$c188);
6230
+ peg$fail(peg$c195);
5844
6231
  }
5845
6232
  }
5846
6233
  if (s1 !== peg$FAILED) {
5847
6234
  peg$savedPos = s0;
5848
- s1 = peg$c189();
6235
+ s1 = peg$c196();
5849
6236
  }
5850
6237
  s0 = s1;
5851
6238
  if (s0 === peg$FAILED) {
5852
6239
  s0 = peg$currPos;
5853
6240
  if (input.charCodeAt(peg$currPos) === 114) {
5854
- s1 = peg$c190;
6241
+ s1 = peg$c197;
5855
6242
  peg$currPos++;
5856
6243
  }
5857
6244
  else {
5858
6245
  s1 = peg$FAILED;
5859
6246
  if (peg$silentFails === 0) {
5860
- peg$fail(peg$c191);
6247
+ peg$fail(peg$c198);
5861
6248
  }
5862
6249
  }
5863
6250
  if (s1 !== peg$FAILED) {
5864
6251
  peg$savedPos = s0;
5865
- s1 = peg$c192();
6252
+ s1 = peg$c199();
5866
6253
  }
5867
6254
  s0 = s1;
5868
6255
  if (s0 === peg$FAILED) {
5869
6256
  s0 = peg$currPos;
5870
6257
  if (input.charCodeAt(peg$currPos) === 116) {
5871
- s1 = peg$c193;
6258
+ s1 = peg$c200;
5872
6259
  peg$currPos++;
5873
6260
  }
5874
6261
  else {
5875
6262
  s1 = peg$FAILED;
5876
6263
  if (peg$silentFails === 0) {
5877
- peg$fail(peg$c194);
6264
+ peg$fail(peg$c201);
5878
6265
  }
5879
6266
  }
5880
6267
  if (s1 !== peg$FAILED) {
5881
6268
  peg$savedPos = s0;
5882
- s1 = peg$c195();
6269
+ s1 = peg$c202();
5883
6270
  }
5884
6271
  s0 = s1;
5885
6272
  if (s0 === peg$FAILED) {
5886
6273
  s0 = peg$currPos;
5887
6274
  if (input.charCodeAt(peg$currPos) === 118) {
5888
- s1 = peg$c196;
6275
+ s1 = peg$c203;
5889
6276
  peg$currPos++;
5890
6277
  }
5891
6278
  else {
5892
6279
  s1 = peg$FAILED;
5893
6280
  if (peg$silentFails === 0) {
5894
- peg$fail(peg$c197);
6281
+ peg$fail(peg$c204);
5895
6282
  }
5896
6283
  }
5897
6284
  if (s1 !== peg$FAILED) {
5898
6285
  peg$savedPos = s0;
5899
- s1 = peg$c198();
6286
+ s1 = peg$c205();
5900
6287
  }
5901
6288
  s0 = s1;
5902
6289
  }
@@ -5912,7 +6299,7 @@ function peg$parse(input, options) {
5912
6299
  }
5913
6300
  function peg$parseNonEscapeChar() {
5914
6301
  let s0, s1, s2;
5915
- const key = peg$currPos * 98 + 85;
6302
+ const key = peg$currPos * 102 + 89;
5916
6303
  const cached = peg$resultsCache[key];
5917
6304
  if (cached) {
5918
6305
  peg$currPos = cached.nextPos;
@@ -5954,20 +6341,20 @@ function peg$parse(input, options) {
5954
6341
  }
5955
6342
  function peg$parseHexDigit() {
5956
6343
  let s0;
5957
- const key = peg$currPos * 98 + 86;
6344
+ const key = peg$currPos * 102 + 90;
5958
6345
  const cached = peg$resultsCache[key];
5959
6346
  if (cached) {
5960
6347
  peg$currPos = cached.nextPos;
5961
6348
  return cached.result;
5962
6349
  }
5963
- if (peg$c199.test(input.charAt(peg$currPos))) {
6350
+ if (peg$c206.test(input.charAt(peg$currPos))) {
5964
6351
  s0 = input.charAt(peg$currPos);
5965
6352
  peg$currPos++;
5966
6353
  }
5967
6354
  else {
5968
6355
  s0 = peg$FAILED;
5969
6356
  if (peg$silentFails === 0) {
5970
- peg$fail(peg$c200);
6357
+ peg$fail(peg$c207);
5971
6358
  }
5972
6359
  }
5973
6360
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5975,20 +6362,20 @@ function peg$parse(input, options) {
5975
6362
  }
5976
6363
  function peg$parseDecDigit() {
5977
6364
  let s0;
5978
- const key = peg$currPos * 98 + 87;
6365
+ const key = peg$currPos * 102 + 91;
5979
6366
  const cached = peg$resultsCache[key];
5980
6367
  if (cached) {
5981
6368
  peg$currPos = cached.nextPos;
5982
6369
  return cached.result;
5983
6370
  }
5984
- if (peg$c201.test(input.charAt(peg$currPos))) {
6371
+ if (peg$c208.test(input.charAt(peg$currPos))) {
5985
6372
  s0 = input.charAt(peg$currPos);
5986
6373
  peg$currPos++;
5987
6374
  }
5988
6375
  else {
5989
6376
  s0 = peg$FAILED;
5990
6377
  if (peg$silentFails === 0) {
5991
- peg$fail(peg$c202);
6378
+ peg$fail(peg$c209);
5992
6379
  }
5993
6380
  }
5994
6381
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
@@ -5996,7 +6383,7 @@ function peg$parse(input, options) {
5996
6383
  }
5997
6384
  function peg$parseEscapeChar() {
5998
6385
  let s0;
5999
- const key = peg$currPos * 98 + 88;
6386
+ const key = peg$currPos * 102 + 92;
6000
6387
  const cached = peg$resultsCache[key];
6001
6388
  if (cached) {
6002
6389
  peg$currPos = cached.nextPos;
@@ -6007,24 +6394,24 @@ function peg$parse(input, options) {
6007
6394
  s0 = peg$parseDecDigit();
6008
6395
  if (s0 === peg$FAILED) {
6009
6396
  if (input.charCodeAt(peg$currPos) === 120) {
6010
- s0 = peg$c203;
6397
+ s0 = peg$c210;
6011
6398
  peg$currPos++;
6012
6399
  }
6013
6400
  else {
6014
6401
  s0 = peg$FAILED;
6015
6402
  if (peg$silentFails === 0) {
6016
- peg$fail(peg$c204);
6403
+ peg$fail(peg$c211);
6017
6404
  }
6018
6405
  }
6019
6406
  if (s0 === peg$FAILED) {
6020
6407
  if (input.charCodeAt(peg$currPos) === 117) {
6021
- s0 = peg$c205;
6408
+ s0 = peg$c212;
6022
6409
  peg$currPos++;
6023
6410
  }
6024
6411
  else {
6025
6412
  s0 = peg$FAILED;
6026
6413
  if (peg$silentFails === 0) {
6027
- peg$fail(peg$c206);
6414
+ peg$fail(peg$c213);
6028
6415
  }
6029
6416
  }
6030
6417
  }
@@ -6035,7 +6422,7 @@ function peg$parse(input, options) {
6035
6422
  }
6036
6423
  function peg$parseHexEscapeSequence() {
6037
6424
  let s0, s1, s2, s3, s4, s5;
6038
- const key = peg$currPos * 98 + 89;
6425
+ const key = peg$currPos * 102 + 93;
6039
6426
  const cached = peg$resultsCache[key];
6040
6427
  if (cached) {
6041
6428
  peg$currPos = cached.nextPos;
@@ -6043,13 +6430,13 @@ function peg$parse(input, options) {
6043
6430
  }
6044
6431
  s0 = peg$currPos;
6045
6432
  if (input.charCodeAt(peg$currPos) === 120) {
6046
- s1 = peg$c203;
6433
+ s1 = peg$c210;
6047
6434
  peg$currPos++;
6048
6435
  }
6049
6436
  else {
6050
6437
  s1 = peg$FAILED;
6051
6438
  if (peg$silentFails === 0) {
6052
- peg$fail(peg$c204);
6439
+ peg$fail(peg$c211);
6053
6440
  }
6054
6441
  }
6055
6442
  if (s1 !== peg$FAILED) {
@@ -6079,7 +6466,7 @@ function peg$parse(input, options) {
6079
6466
  }
6080
6467
  if (s2 !== peg$FAILED) {
6081
6468
  peg$savedPos = s0;
6082
- s1 = peg$c207(s2);
6469
+ s1 = peg$c214(s2);
6083
6470
  s0 = s1;
6084
6471
  }
6085
6472
  else {
@@ -6096,7 +6483,7 @@ function peg$parse(input, options) {
6096
6483
  }
6097
6484
  function peg$parseUnicodeEscapeSequence() {
6098
6485
  let s0, s1, s2, s3, s4, s5, s6, s7;
6099
- const key = peg$currPos * 98 + 90;
6486
+ const key = peg$currPos * 102 + 94;
6100
6487
  const cached = peg$resultsCache[key];
6101
6488
  if (cached) {
6102
6489
  peg$currPos = cached.nextPos;
@@ -6104,13 +6491,13 @@ function peg$parse(input, options) {
6104
6491
  }
6105
6492
  s0 = peg$currPos;
6106
6493
  if (input.charCodeAt(peg$currPos) === 117) {
6107
- s1 = peg$c205;
6494
+ s1 = peg$c212;
6108
6495
  peg$currPos++;
6109
6496
  }
6110
6497
  else {
6111
6498
  s1 = peg$FAILED;
6112
6499
  if (peg$silentFails === 0) {
6113
- peg$fail(peg$c206);
6500
+ peg$fail(peg$c213);
6114
6501
  }
6115
6502
  }
6116
6503
  if (s1 !== peg$FAILED) {
@@ -6154,7 +6541,7 @@ function peg$parse(input, options) {
6154
6541
  }
6155
6542
  if (s2 !== peg$FAILED) {
6156
6543
  peg$savedPos = s0;
6157
- s1 = peg$c207(s2);
6544
+ s1 = peg$c214(s2);
6158
6545
  s0 = s1;
6159
6546
  }
6160
6547
  else {
@@ -6171,21 +6558,21 @@ function peg$parse(input, options) {
6171
6558
  }
6172
6559
  function peg$parseHexNumber() {
6173
6560
  let s0, s1, s2, s3;
6174
- const key = peg$currPos * 98 + 91;
6561
+ const key = peg$currPos * 102 + 95;
6175
6562
  const cached = peg$resultsCache[key];
6176
6563
  if (cached) {
6177
6564
  peg$currPos = cached.nextPos;
6178
6565
  return cached.result;
6179
6566
  }
6180
6567
  s0 = peg$currPos;
6181
- if (input.substr(peg$currPos, 2).toLowerCase() === peg$c208) {
6568
+ if (input.substr(peg$currPos, 2).toLowerCase() === peg$c215) {
6182
6569
  s1 = input.substr(peg$currPos, 2);
6183
6570
  peg$currPos += 2;
6184
6571
  }
6185
6572
  else {
6186
6573
  s1 = peg$FAILED;
6187
6574
  if (peg$silentFails === 0) {
6188
- peg$fail(peg$c209);
6575
+ peg$fail(peg$c216);
6189
6576
  }
6190
6577
  }
6191
6578
  if (s1 !== peg$FAILED) {
@@ -6218,31 +6605,31 @@ function peg$parse(input, options) {
6218
6605
  }
6219
6606
  function peg$parseExponentIndicator() {
6220
6607
  let s0;
6221
- const key = peg$currPos * 98 + 92;
6608
+ const key = peg$currPos * 102 + 96;
6222
6609
  const cached = peg$resultsCache[key];
6223
6610
  if (cached) {
6224
6611
  peg$currPos = cached.nextPos;
6225
6612
  return cached.result;
6226
6613
  }
6227
6614
  if (input.charCodeAt(peg$currPos) === 101) {
6228
- s0 = peg$c210;
6615
+ s0 = peg$c217;
6229
6616
  peg$currPos++;
6230
6617
  }
6231
6618
  else {
6232
6619
  s0 = peg$FAILED;
6233
6620
  if (peg$silentFails === 0) {
6234
- peg$fail(peg$c211);
6621
+ peg$fail(peg$c218);
6235
6622
  }
6236
6623
  }
6237
6624
  if (s0 === peg$FAILED) {
6238
6625
  if (input.charCodeAt(peg$currPos) === 69) {
6239
- s0 = peg$c212;
6626
+ s0 = peg$c219;
6240
6627
  peg$currPos++;
6241
6628
  }
6242
6629
  else {
6243
6630
  s0 = peg$FAILED;
6244
6631
  if (peg$silentFails === 0) {
6245
- peg$fail(peg$c213);
6632
+ peg$fail(peg$c220);
6246
6633
  }
6247
6634
  }
6248
6635
  }
@@ -6251,21 +6638,21 @@ function peg$parse(input, options) {
6251
6638
  }
6252
6639
  function peg$parseSignedInteger() {
6253
6640
  let s0, s1, s2, s3;
6254
- const key = peg$currPos * 98 + 93;
6641
+ const key = peg$currPos * 102 + 97;
6255
6642
  const cached = peg$resultsCache[key];
6256
6643
  if (cached) {
6257
6644
  peg$currPos = cached.nextPos;
6258
6645
  return cached.result;
6259
6646
  }
6260
6647
  s0 = peg$currPos;
6261
- if (peg$c214.test(input.charAt(peg$currPos))) {
6648
+ if (peg$c221.test(input.charAt(peg$currPos))) {
6262
6649
  s1 = input.charAt(peg$currPos);
6263
6650
  peg$currPos++;
6264
6651
  }
6265
6652
  else {
6266
6653
  s1 = peg$FAILED;
6267
6654
  if (peg$silentFails === 0) {
6268
- peg$fail(peg$c215);
6655
+ peg$fail(peg$c222);
6269
6656
  }
6270
6657
  }
6271
6658
  if (s1 === peg$FAILED) {
@@ -6301,7 +6688,7 @@ function peg$parse(input, options) {
6301
6688
  }
6302
6689
  function peg$parseExponentPart() {
6303
6690
  let s0, s1, s2;
6304
- const key = peg$currPos * 98 + 94;
6691
+ const key = peg$currPos * 102 + 98;
6305
6692
  const cached = peg$resultsCache[key];
6306
6693
  if (cached) {
6307
6694
  peg$currPos = cached.nextPos;
@@ -6329,7 +6716,7 @@ function peg$parse(input, options) {
6329
6716
  }
6330
6717
  function peg$parseDecNumber() {
6331
6718
  let s0, s1, s2;
6332
- const key = peg$currPos * 98 + 95;
6719
+ const key = peg$currPos * 102 + 99;
6333
6720
  const cached = peg$resultsCache[key];
6334
6721
  if (cached) {
6335
6722
  peg$currPos = cached.nextPos;
@@ -6370,7 +6757,7 @@ function peg$parse(input, options) {
6370
6757
  }
6371
6758
  function peg$parseNumber() {
6372
6759
  let s0;
6373
- const key = peg$currPos * 98 + 96;
6760
+ const key = peg$currPos * 102 + 100;
6374
6761
  const cached = peg$resultsCache[key];
6375
6762
  if (cached) {
6376
6763
  peg$currPos = cached.nextPos;
@@ -6385,7 +6772,7 @@ function peg$parse(input, options) {
6385
6772
  }
6386
6773
  function peg$parseIdentifier() {
6387
6774
  let s0, s1, s2, s3, s4;
6388
- const key = peg$currPos * 98 + 97;
6775
+ const key = peg$currPos * 102 + 101;
6389
6776
  const cached = peg$resultsCache[key];
6390
6777
  if (cached) {
6391
6778
  peg$currPos = cached.nextPos;
@@ -6393,38 +6780,38 @@ function peg$parse(input, options) {
6393
6780
  }
6394
6781
  s0 = peg$currPos;
6395
6782
  s1 = peg$currPos;
6396
- if (peg$c216.test(input.charAt(peg$currPos))) {
6783
+ if (peg$c223.test(input.charAt(peg$currPos))) {
6397
6784
  s2 = input.charAt(peg$currPos);
6398
6785
  peg$currPos++;
6399
6786
  }
6400
6787
  else {
6401
6788
  s2 = peg$FAILED;
6402
6789
  if (peg$silentFails === 0) {
6403
- peg$fail(peg$c217);
6790
+ peg$fail(peg$c224);
6404
6791
  }
6405
6792
  }
6406
6793
  if (s2 !== peg$FAILED) {
6407
6794
  s3 = [];
6408
- if (peg$c218.test(input.charAt(peg$currPos))) {
6795
+ if (peg$c225.test(input.charAt(peg$currPos))) {
6409
6796
  s4 = input.charAt(peg$currPos);
6410
6797
  peg$currPos++;
6411
6798
  }
6412
6799
  else {
6413
6800
  s4 = peg$FAILED;
6414
6801
  if (peg$silentFails === 0) {
6415
- peg$fail(peg$c219);
6802
+ peg$fail(peg$c226);
6416
6803
  }
6417
6804
  }
6418
6805
  while (s4 !== peg$FAILED) {
6419
6806
  s3.push(s4);
6420
- if (peg$c218.test(input.charAt(peg$currPos))) {
6807
+ if (peg$c225.test(input.charAt(peg$currPos))) {
6421
6808
  s4 = input.charAt(peg$currPos);
6422
6809
  peg$currPos++;
6423
6810
  }
6424
6811
  else {
6425
6812
  s4 = peg$FAILED;
6426
6813
  if (peg$silentFails === 0) {
6427
- peg$fail(peg$c219);
6814
+ peg$fail(peg$c226);
6428
6815
  }
6429
6816
  }
6430
6817
  }
@@ -6443,7 +6830,7 @@ function peg$parse(input, options) {
6443
6830
  }
6444
6831
  if (s1 !== peg$FAILED) {
6445
6832
  peg$savedPos = s0;
6446
- s1 = peg$c220(s1);
6833
+ s1 = peg$c227(s1);
6447
6834
  }
6448
6835
  s0 = s1;
6449
6836
  peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };