@wireweave/core 3.1.0-beta.5 → 3.1.0-beta.7

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.
package/dist/index.js CHANGED
@@ -4,6 +4,7 @@ var CONTAINER_TYPES = [
4
4
  "Layout",
5
5
  "Component",
6
6
  "ComponentUse",
7
+ "Repeat",
7
8
  "Header",
8
9
  "Main",
9
10
  "Footer",
@@ -318,6 +319,119 @@ function getNodeTypes(node) {
318
319
  return types;
319
320
  }
320
321
 
322
+ // src/ast/component-parameters.ts
323
+ var PARAMETER_REFERENCE = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/;
324
+ function parameterReferenceName(value) {
325
+ return typeof value === "string" ? PARAMETER_REFERENCE.exec(value)?.[1] : void 0;
326
+ }
327
+ function collectParameterReferences(children) {
328
+ const found = [];
329
+ const visitValue = (value, key, node) => {
330
+ const name = parameterReferenceName(value);
331
+ if (name !== void 0) {
332
+ found.push({ name, key, node });
333
+ return;
334
+ }
335
+ if (Array.isArray(value)) {
336
+ for (const item of value) visitValue(item, key, node);
337
+ return;
338
+ }
339
+ if (value === null || typeof value !== "object") return;
340
+ for (const [childKey, item] of Object.entries(value)) {
341
+ if (childKey === "loc") continue;
342
+ visitValue(item, childKey, node);
343
+ }
344
+ };
345
+ const visitNode = (node) => {
346
+ if (node.type === "ComponentUse") return;
347
+ for (const [key, value] of Object.entries(node)) {
348
+ if (key === "loc" || key === "children") continue;
349
+ visitValue(value, key, node);
350
+ }
351
+ if ("children" in node && Array.isArray(node.children)) {
352
+ for (const child of node.children) visitNode(child);
353
+ }
354
+ };
355
+ for (const child of children) visitNode(child);
356
+ return found;
357
+ }
358
+
359
+ // src/ast/expand-repeats.ts
360
+ var REPEAT_EXPANSION_BUDGET = 500;
361
+ var RepeatBudgetError = class extends Error {
362
+ constructor(budget) {
363
+ super(
364
+ `repeat expansion exceeds ${budget} nodes \u2014 nesting multiplies, so check the nested counts rather than the outermost one`
365
+ );
366
+ this.name = "RepeatBudgetError";
367
+ }
368
+ };
369
+ function cloneNode2(value) {
370
+ if (Array.isArray(value)) return value.map(cloneNode2);
371
+ if (value === null || typeof value !== "object") return value;
372
+ const source = value;
373
+ const result = {};
374
+ for (const [key, item] of Object.entries(source)) {
375
+ result[key] = key === "loc" ? item : cloneNode2(item);
376
+ }
377
+ return result;
378
+ }
379
+ function containsRepeat(node) {
380
+ if (node.type === "Repeat") return true;
381
+ const children = node.children;
382
+ if (Array.isArray(children)) {
383
+ for (const child of children) if (containsRepeat(child)) return true;
384
+ }
385
+ const fills = node.fills;
386
+ if (Array.isArray(fills)) {
387
+ for (const fill of fills) {
388
+ for (const child of fill.children ?? []) if (containsRepeat(child)) return true;
389
+ }
390
+ }
391
+ return false;
392
+ }
393
+ function expandOne(node, budget) {
394
+ if (node.type === "Repeat") {
395
+ const repeat = node;
396
+ const count = Number.isInteger(repeat.count) && repeat.count > 0 ? repeat.count : 0;
397
+ const result = [];
398
+ for (let i = 0; i < count; i++) {
399
+ for (const child of repeat.children) {
400
+ for (const expanded of expandOne(child, budget)) {
401
+ budget.remaining -= 1;
402
+ if (budget.remaining < 0) throw new RepeatBudgetError(REPEAT_EXPANSION_BUDGET);
403
+ result.push(cloneNode2(expanded));
404
+ }
405
+ }
406
+ }
407
+ return result;
408
+ }
409
+ if (!containsRepeat(node)) return [node];
410
+ const clone = { ...node };
411
+ const children = clone.children;
412
+ if (Array.isArray(children)) {
413
+ clone.children = children.flatMap((child) => expandOne(child, budget));
414
+ }
415
+ const fills = clone.fills;
416
+ if (Array.isArray(fills)) {
417
+ clone.fills = fills.map((fill) => ({
418
+ ...fill,
419
+ children: (fill.children ?? []).flatMap((child) => expandOne(child, budget))
420
+ }));
421
+ }
422
+ return [clone];
423
+ }
424
+ function expandRepeats(document) {
425
+ if (!document.children.some((child) => containsRepeat(child))) return document;
426
+ const budget = { remaining: REPEAT_EXPANSION_BUDGET };
427
+ return {
428
+ ...document,
429
+ children: document.children.flatMap(
430
+ (child) => expandOne(child, budget)
431
+ )
432
+ };
433
+ }
434
+
321
435
  // src/parser/generated-parser.js
322
436
  var peg$SyntaxError = class extends SyntaxError {
323
437
  constructor(message, expected, found, location) {
@@ -447,75 +561,76 @@ function peg$parse(input, options) {
447
561
  const peg$c17 = "\r\n";
448
562
  const peg$c18 = "//";
449
563
  const peg$c19 = "/*";
450
- const peg$c20 = "header";
451
- const peg$c21 = "main";
452
- const peg$c22 = "footer";
453
- const peg$c23 = "sidebar";
454
- const peg$c24 = "row";
455
- const peg$c25 = "col";
456
- const peg$c26 = "stack";
457
- const peg$c27 = "relative";
458
- const peg$c28 = "card";
459
- const peg$c29 = "modal";
460
- const peg$c30 = "drawer";
461
- const peg$c31 = "accordion";
462
- const peg$c32 = "section";
463
- const peg$c33 = "text";
464
- const peg$c34 = "title";
465
- const peg$c35 = "link";
466
- const peg$c36 = "button";
467
- const peg$c37 = "input";
468
- const peg$c38 = "textarea";
469
- const peg$c39 = "select";
470
- const peg$c40 = "checkbox";
471
- const peg$c41 = "radio";
472
- const peg$c42 = "switch";
473
- const peg$c43 = "slider";
474
- const peg$c44 = "image";
475
- const peg$c45 = "placeholder";
476
- const peg$c46 = "avatar";
477
- const peg$c47 = "badge";
478
- const peg$c48 = "icon";
479
- const peg$c49 = "table";
480
- const peg$c50 = "[";
481
- const peg$c51 = "]";
482
- const peg$c52 = "columns";
483
- const peg$c53 = "list";
484
- const peg$c54 = "item";
485
- const peg$c55 = "alert";
486
- const peg$c56 = "toast";
487
- const peg$c57 = "progress";
488
- const peg$c58 = "spinner";
489
- const peg$c59 = "tooltip";
490
- const peg$c60 = "popover";
491
- const peg$c61 = "dropdown";
492
- const peg$c62 = "divider";
493
- const peg$c63 = "nav";
494
- const peg$c64 = "group";
495
- const peg$c65 = "tabs";
496
- const peg$c66 = "tab";
497
- const peg$c67 = "breadcrumb";
498
- const peg$c68 = "marker";
499
- const peg$c69 = "annotations";
500
- const peg$c70 = "at";
501
- const peg$c71 = '"';
502
- const peg$c72 = "'";
503
- const peg$c73 = "\\";
504
- const peg$c74 = "n";
505
- const peg$c75 = "r";
506
- const peg$c76 = "t";
507
- const peg$c77 = "-";
508
- const peg$c78 = ".";
509
- const peg$c79 = "px";
510
- const peg$c80 = "%";
511
- const peg$c81 = "em";
512
- const peg$c82 = "rem";
513
- const peg$c83 = "vh";
514
- const peg$c84 = "vw";
515
- const peg$c85 = "true";
516
- const peg$c86 = "false";
517
- const peg$c87 = "\n";
518
- const peg$c88 = "*/";
564
+ const peg$c20 = "repeat";
565
+ const peg$c21 = "header";
566
+ const peg$c22 = "main";
567
+ const peg$c23 = "footer";
568
+ const peg$c24 = "sidebar";
569
+ const peg$c25 = "row";
570
+ const peg$c26 = "col";
571
+ const peg$c27 = "stack";
572
+ const peg$c28 = "relative";
573
+ const peg$c29 = "card";
574
+ const peg$c30 = "modal";
575
+ const peg$c31 = "drawer";
576
+ const peg$c32 = "accordion";
577
+ const peg$c33 = "section";
578
+ const peg$c34 = "text";
579
+ const peg$c35 = "title";
580
+ const peg$c36 = "link";
581
+ const peg$c37 = "button";
582
+ const peg$c38 = "input";
583
+ const peg$c39 = "textarea";
584
+ const peg$c40 = "select";
585
+ const peg$c41 = "checkbox";
586
+ const peg$c42 = "radio";
587
+ const peg$c43 = "switch";
588
+ const peg$c44 = "slider";
589
+ const peg$c45 = "image";
590
+ const peg$c46 = "placeholder";
591
+ const peg$c47 = "avatar";
592
+ const peg$c48 = "badge";
593
+ const peg$c49 = "icon";
594
+ const peg$c50 = "table";
595
+ const peg$c51 = "[";
596
+ const peg$c52 = "]";
597
+ const peg$c53 = "columns";
598
+ const peg$c54 = "list";
599
+ const peg$c55 = "item";
600
+ const peg$c56 = "alert";
601
+ const peg$c57 = "toast";
602
+ const peg$c58 = "progress";
603
+ const peg$c59 = "spinner";
604
+ const peg$c60 = "tooltip";
605
+ const peg$c61 = "popover";
606
+ const peg$c62 = "dropdown";
607
+ const peg$c63 = "divider";
608
+ const peg$c64 = "nav";
609
+ const peg$c65 = "group";
610
+ const peg$c66 = "tabs";
611
+ const peg$c67 = "tab";
612
+ const peg$c68 = "breadcrumb";
613
+ const peg$c69 = "marker";
614
+ const peg$c70 = "annotations";
615
+ const peg$c71 = "at";
616
+ const peg$c72 = '"';
617
+ const peg$c73 = "'";
618
+ const peg$c74 = "\\";
619
+ const peg$c75 = "n";
620
+ const peg$c76 = "r";
621
+ const peg$c77 = "t";
622
+ const peg$c78 = "-";
623
+ const peg$c79 = ".";
624
+ const peg$c80 = "px";
625
+ const peg$c81 = "%";
626
+ const peg$c82 = "em";
627
+ const peg$c83 = "rem";
628
+ const peg$c84 = "vh";
629
+ const peg$c85 = "vw";
630
+ const peg$c86 = "true";
631
+ const peg$c87 = "false";
632
+ const peg$c88 = "\n";
633
+ const peg$c89 = "*/";
519
634
  const peg$r0 = /^[ \t]/;
520
635
  const peg$r1 = /^[\n\r}]/;
521
636
  const peg$r2 = /^[0-9]/;
@@ -547,88 +662,89 @@ function peg$parse(input, options) {
547
662
  const peg$e20 = peg$literalExpectation("//", false);
548
663
  const peg$e21 = peg$literalExpectation("/*", false);
549
664
  const peg$e22 = peg$anyExpectation();
550
- const peg$e23 = peg$literalExpectation("header", false);
551
- const peg$e24 = peg$literalExpectation("main", false);
552
- const peg$e25 = peg$literalExpectation("footer", false);
553
- const peg$e26 = peg$literalExpectation("sidebar", false);
554
- const peg$e27 = peg$literalExpectation("row", false);
555
- const peg$e28 = peg$literalExpectation("col", false);
556
- const peg$e29 = peg$literalExpectation("stack", false);
557
- const peg$e30 = peg$literalExpectation("relative", false);
558
- const peg$e31 = peg$literalExpectation("card", false);
559
- const peg$e32 = peg$literalExpectation("modal", false);
560
- const peg$e33 = peg$literalExpectation("drawer", false);
561
- const peg$e34 = peg$literalExpectation("accordion", false);
562
- const peg$e35 = peg$literalExpectation("section", false);
563
- const peg$e36 = peg$literalExpectation("text", false);
564
- const peg$e37 = peg$literalExpectation("title", false);
565
- const peg$e38 = peg$literalExpectation("link", false);
566
- const peg$e39 = peg$literalExpectation("button", false);
567
- const peg$e40 = peg$literalExpectation("input", false);
568
- const peg$e41 = peg$literalExpectation("textarea", false);
569
- const peg$e42 = peg$literalExpectation("select", false);
570
- const peg$e43 = peg$literalExpectation("checkbox", false);
571
- const peg$e44 = peg$literalExpectation("radio", false);
572
- const peg$e45 = peg$literalExpectation("switch", false);
573
- const peg$e46 = peg$literalExpectation("slider", false);
574
- const peg$e47 = peg$literalExpectation("image", false);
575
- const peg$e48 = peg$literalExpectation("placeholder", false);
576
- const peg$e49 = peg$literalExpectation("avatar", false);
577
- const peg$e50 = peg$literalExpectation("badge", false);
578
- const peg$e51 = peg$literalExpectation("icon", false);
579
- const peg$e52 = peg$literalExpectation("table", false);
580
- const peg$e53 = peg$literalExpectation("[", false);
581
- const peg$e54 = peg$literalExpectation("]", false);
582
- const peg$e55 = peg$literalExpectation("columns", false);
583
- const peg$e56 = peg$literalExpectation("list", false);
584
- const peg$e57 = peg$literalExpectation("item", false);
585
- const peg$e58 = peg$literalExpectation("alert", false);
586
- const peg$e59 = peg$literalExpectation("toast", false);
587
- const peg$e60 = peg$literalExpectation("progress", false);
588
- const peg$e61 = peg$literalExpectation("spinner", false);
589
- const peg$e62 = peg$literalExpectation("tooltip", false);
590
- const peg$e63 = peg$literalExpectation("popover", false);
591
- const peg$e64 = peg$literalExpectation("dropdown", false);
592
- const peg$e65 = peg$literalExpectation("divider", false);
593
- const peg$e66 = peg$literalExpectation("nav", false);
594
- const peg$e67 = peg$literalExpectation("group", false);
595
- const peg$e68 = peg$literalExpectation("tabs", false);
596
- const peg$e69 = peg$literalExpectation("tab", false);
597
- const peg$e70 = peg$literalExpectation("breadcrumb", false);
598
- const peg$e71 = peg$literalExpectation("marker", false);
599
- const peg$e72 = peg$literalExpectation("annotations", false);
600
- const peg$e73 = peg$otherExpectation("integer");
601
- const peg$e74 = peg$classExpectation([["0", "9"]], false, false, false);
602
- const peg$e75 = peg$literalExpectation("at", false);
603
- const peg$e76 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
604
- const peg$e77 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
605
- const peg$e78 = peg$otherExpectation("string");
606
- const peg$e79 = peg$literalExpectation('"', false);
607
- const peg$e80 = peg$literalExpectation("'", false);
608
- const peg$e81 = peg$literalExpectation("\\", false);
609
- const peg$e82 = peg$literalExpectation("n", false);
610
- const peg$e83 = peg$literalExpectation("r", false);
611
- const peg$e84 = peg$literalExpectation("t", false);
612
- const peg$e85 = peg$otherExpectation("number");
613
- const peg$e86 = peg$literalExpectation("-", false);
614
- const peg$e87 = peg$literalExpectation(".", false);
615
- const peg$e88 = peg$otherExpectation("value with unit");
616
- const peg$e89 = peg$literalExpectation("px", false);
617
- const peg$e90 = peg$literalExpectation("%", false);
618
- const peg$e91 = peg$literalExpectation("em", false);
619
- const peg$e92 = peg$literalExpectation("rem", false);
620
- const peg$e93 = peg$literalExpectation("vh", false);
621
- const peg$e94 = peg$literalExpectation("vw", false);
622
- const peg$e95 = peg$otherExpectation("boolean");
623
- const peg$e96 = peg$literalExpectation("true", false);
624
- const peg$e97 = peg$literalExpectation("false", false);
625
- const peg$e98 = peg$otherExpectation("identifier");
626
- const peg$e99 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
627
- const peg$e100 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
628
- const peg$e101 = peg$otherExpectation("comment");
629
- const peg$e102 = peg$classExpectation(["\n"], true, false, false);
630
- const peg$e103 = peg$literalExpectation("\n", false);
631
- const peg$e104 = peg$literalExpectation("*/", false);
665
+ const peg$e23 = peg$literalExpectation("repeat", false);
666
+ const peg$e24 = peg$literalExpectation("header", false);
667
+ const peg$e25 = peg$literalExpectation("main", false);
668
+ const peg$e26 = peg$literalExpectation("footer", false);
669
+ const peg$e27 = peg$literalExpectation("sidebar", false);
670
+ const peg$e28 = peg$literalExpectation("row", false);
671
+ const peg$e29 = peg$literalExpectation("col", false);
672
+ const peg$e30 = peg$literalExpectation("stack", false);
673
+ const peg$e31 = peg$literalExpectation("relative", false);
674
+ const peg$e32 = peg$literalExpectation("card", false);
675
+ const peg$e33 = peg$literalExpectation("modal", false);
676
+ const peg$e34 = peg$literalExpectation("drawer", false);
677
+ const peg$e35 = peg$literalExpectation("accordion", false);
678
+ const peg$e36 = peg$literalExpectation("section", false);
679
+ const peg$e37 = peg$literalExpectation("text", false);
680
+ const peg$e38 = peg$literalExpectation("title", false);
681
+ const peg$e39 = peg$literalExpectation("link", false);
682
+ const peg$e40 = peg$literalExpectation("button", false);
683
+ const peg$e41 = peg$literalExpectation("input", false);
684
+ const peg$e42 = peg$literalExpectation("textarea", false);
685
+ const peg$e43 = peg$literalExpectation("select", false);
686
+ const peg$e44 = peg$literalExpectation("checkbox", false);
687
+ const peg$e45 = peg$literalExpectation("radio", false);
688
+ const peg$e46 = peg$literalExpectation("switch", false);
689
+ const peg$e47 = peg$literalExpectation("slider", false);
690
+ const peg$e48 = peg$literalExpectation("image", false);
691
+ const peg$e49 = peg$literalExpectation("placeholder", false);
692
+ const peg$e50 = peg$literalExpectation("avatar", false);
693
+ const peg$e51 = peg$literalExpectation("badge", false);
694
+ const peg$e52 = peg$literalExpectation("icon", false);
695
+ const peg$e53 = peg$literalExpectation("table", false);
696
+ const peg$e54 = peg$literalExpectation("[", false);
697
+ const peg$e55 = peg$literalExpectation("]", false);
698
+ const peg$e56 = peg$literalExpectation("columns", false);
699
+ const peg$e57 = peg$literalExpectation("list", false);
700
+ const peg$e58 = peg$literalExpectation("item", false);
701
+ const peg$e59 = peg$literalExpectation("alert", false);
702
+ const peg$e60 = peg$literalExpectation("toast", false);
703
+ const peg$e61 = peg$literalExpectation("progress", false);
704
+ const peg$e62 = peg$literalExpectation("spinner", false);
705
+ const peg$e63 = peg$literalExpectation("tooltip", false);
706
+ const peg$e64 = peg$literalExpectation("popover", false);
707
+ const peg$e65 = peg$literalExpectation("dropdown", false);
708
+ const peg$e66 = peg$literalExpectation("divider", false);
709
+ const peg$e67 = peg$literalExpectation("nav", false);
710
+ const peg$e68 = peg$literalExpectation("group", false);
711
+ const peg$e69 = peg$literalExpectation("tabs", false);
712
+ const peg$e70 = peg$literalExpectation("tab", false);
713
+ const peg$e71 = peg$literalExpectation("breadcrumb", false);
714
+ const peg$e72 = peg$literalExpectation("marker", false);
715
+ const peg$e73 = peg$literalExpectation("annotations", false);
716
+ const peg$e74 = peg$otherExpectation("integer");
717
+ const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
718
+ const peg$e76 = peg$literalExpectation("at", false);
719
+ const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
720
+ const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
721
+ const peg$e79 = peg$otherExpectation("string");
722
+ const peg$e80 = peg$literalExpectation('"', false);
723
+ const peg$e81 = peg$literalExpectation("'", false);
724
+ const peg$e82 = peg$literalExpectation("\\", false);
725
+ const peg$e83 = peg$literalExpectation("n", false);
726
+ const peg$e84 = peg$literalExpectation("r", false);
727
+ const peg$e85 = peg$literalExpectation("t", false);
728
+ const peg$e86 = peg$otherExpectation("number");
729
+ const peg$e87 = peg$literalExpectation("-", false);
730
+ const peg$e88 = peg$literalExpectation(".", false);
731
+ const peg$e89 = peg$otherExpectation("value with unit");
732
+ const peg$e90 = peg$literalExpectation("px", false);
733
+ const peg$e91 = peg$literalExpectation("%", false);
734
+ const peg$e92 = peg$literalExpectation("em", false);
735
+ const peg$e93 = peg$literalExpectation("rem", false);
736
+ const peg$e94 = peg$literalExpectation("vh", false);
737
+ const peg$e95 = peg$literalExpectation("vw", false);
738
+ const peg$e96 = peg$otherExpectation("boolean");
739
+ const peg$e97 = peg$literalExpectation("true", false);
740
+ const peg$e98 = peg$literalExpectation("false", false);
741
+ const peg$e99 = peg$otherExpectation("identifier");
742
+ const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
743
+ const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
744
+ const peg$e102 = peg$otherExpectation("comment");
745
+ const peg$e103 = peg$classExpectation(["\n"], true, false, false);
746
+ const peg$e104 = peg$literalExpectation("\n", false);
747
+ const peg$e105 = peg$literalExpectation("*/", false);
632
748
  function peg$f0(children) {
633
749
  return createNode("Document", {
634
750
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -709,114 +825,120 @@ function peg$parse(input, options) {
709
825
  function peg$f18() {
710
826
  return null;
711
827
  }
712
- function peg$f19(attrs2, children) {
828
+ function peg$f19(count, children) {
829
+ return createNode("Repeat", {
830
+ count,
831
+ children
832
+ });
833
+ }
834
+ function peg$f20(attrs2, children) {
713
835
  return createNode("Header", {
714
836
  ...attrsToObject(attrs2),
715
837
  children
716
838
  });
717
839
  }
718
- function peg$f20(attrs2, children) {
840
+ function peg$f21(attrs2, children) {
719
841
  return createNode("Main", {
720
842
  ...attrsToObject(attrs2),
721
843
  children
722
844
  });
723
845
  }
724
- function peg$f21(attrs2, children) {
846
+ function peg$f22(attrs2, children) {
725
847
  return createNode("Footer", {
726
848
  ...attrsToObject(attrs2),
727
849
  children
728
850
  });
729
851
  }
730
- function peg$f22(attrs2, children) {
852
+ function peg$f23(attrs2, children) {
731
853
  return createNode("Sidebar", {
732
854
  ...attrsToObject(attrs2),
733
855
  children
734
856
  });
735
857
  }
736
- function peg$f23(attrs2, children) {
858
+ function peg$f24(attrs2, children) {
737
859
  return createNode("Row", {
738
860
  ...attrsToObject(attrs2),
739
861
  children
740
862
  });
741
863
  }
742
- function peg$f24(attrs2, children) {
864
+ function peg$f25(attrs2, children) {
743
865
  return createNode("Col", {
744
866
  ...attrsToObject(attrs2),
745
867
  children
746
868
  });
747
869
  }
748
- function peg$f25(attrs2, children) {
870
+ function peg$f26(attrs2, children) {
749
871
  return createNode("Stack", {
750
872
  ...attrsToObject(attrs2),
751
873
  children
752
874
  });
753
875
  }
754
- function peg$f26(attrs2, children) {
876
+ function peg$f27(attrs2, children) {
755
877
  return createNode("Relative", {
756
878
  ...attrsToObject(attrs2),
757
879
  children
758
880
  });
759
881
  }
760
- function peg$f27(label, attrs2, children) {
882
+ function peg$f28(label, attrs2, children) {
761
883
  return createNode("Card", {
762
884
  title: label || null,
763
885
  ...attrsToObject(attrs2),
764
886
  children
765
887
  });
766
888
  }
767
- function peg$f28(label, attrs2, children) {
889
+ function peg$f29(label, attrs2, children) {
768
890
  return createNode("Modal", {
769
891
  title: label || null,
770
892
  ...attrsToObject(attrs2),
771
893
  children
772
894
  });
773
895
  }
774
- function peg$f29(label, attrs2, children) {
896
+ function peg$f30(label, attrs2, children) {
775
897
  return createNode("Drawer", {
776
898
  title: label || null,
777
899
  ...attrsToObject(attrs2),
778
900
  children
779
901
  });
780
902
  }
781
- function peg$f30(label, attrs2, children) {
903
+ function peg$f31(label, attrs2, children) {
782
904
  return createNode("Accordion", {
783
905
  title: label || null,
784
906
  ...attrsToObject(attrs2),
785
907
  children
786
908
  });
787
909
  }
788
- function peg$f31(label, attrs2, children) {
910
+ function peg$f32(label, attrs2, children) {
789
911
  return createNode("Section", {
790
912
  title: label || null,
791
913
  ...attrsToObject(attrs2),
792
914
  children
793
915
  });
794
916
  }
795
- function peg$f32(label, attrs2) {
917
+ function peg$f33(label, attrs2) {
796
918
  return createNode("Text", {
797
919
  content: label,
798
920
  ...attrsToObject(attrs2)
799
921
  });
800
922
  }
801
- function peg$f33(label, attrs2) {
923
+ function peg$f34(label, attrs2) {
802
924
  return createNode("Title", {
803
925
  content: label,
804
926
  ...attrsToObject(attrs2)
805
927
  });
806
928
  }
807
- function peg$f34(label, attrs2) {
929
+ function peg$f35(label, attrs2) {
808
930
  return createNode("Link", {
809
931
  content: label,
810
932
  ...attrsToObject(attrs2)
811
933
  });
812
934
  }
813
- function peg$f35(label, attrs2) {
935
+ function peg$f36(label, attrs2) {
814
936
  return createNode("Button", {
815
937
  content: label,
816
938
  ...attrsToObject(attrs2)
817
939
  });
818
940
  }
819
- function peg$f36(label, attrs2) {
941
+ function peg$f37(label, attrs2) {
820
942
  const obj = attrsToObject(attrs2);
821
943
  const inputType = obj.type;
822
944
  delete obj.type;
@@ -826,75 +948,75 @@ function peg$parse(input, options) {
826
948
  ...obj
827
949
  });
828
950
  }
829
- function peg$f37(label, attrs2) {
951
+ function peg$f38(label, attrs2) {
830
952
  return createNode("Textarea", {
831
953
  label: label || null,
832
954
  ...attrsToObject(attrs2)
833
955
  });
834
956
  }
835
- function peg$f38(label, options2, attrs2) {
957
+ function peg$f39(label, options2, attrs2) {
836
958
  return createNode("Select", {
837
959
  label: label || null,
838
960
  options: options2 || [],
839
961
  ...attrsToObject(attrs2)
840
962
  });
841
963
  }
842
- function peg$f39(label, attrs2) {
964
+ function peg$f40(label, attrs2) {
843
965
  return createNode("Checkbox", {
844
966
  label: label || null,
845
967
  ...attrsToObject(attrs2)
846
968
  });
847
969
  }
848
- function peg$f40(label, attrs2) {
970
+ function peg$f41(label, attrs2) {
849
971
  return createNode("Radio", {
850
972
  label: label || null,
851
973
  ...attrsToObject(attrs2)
852
974
  });
853
975
  }
854
- function peg$f41(label, attrs2) {
976
+ function peg$f42(label, attrs2) {
855
977
  return createNode("Switch", {
856
978
  label: label || null,
857
979
  ...attrsToObject(attrs2)
858
980
  });
859
981
  }
860
- function peg$f42(label, attrs2) {
982
+ function peg$f43(label, attrs2) {
861
983
  return createNode("Slider", {
862
984
  label: label || null,
863
985
  ...attrsToObject(attrs2)
864
986
  });
865
987
  }
866
- function peg$f43(src, attrs2) {
988
+ function peg$f44(src, attrs2) {
867
989
  return createNode("Image", {
868
990
  src: src || null,
869
991
  ...attrsToObject(attrs2)
870
992
  });
871
993
  }
872
- function peg$f44(label, attrs2, block) {
994
+ function peg$f45(label, attrs2, block) {
873
995
  return createNode("Placeholder", {
874
996
  label: label || null,
875
997
  ...attrsToObject(attrs2),
876
998
  children: block ? block[2] : []
877
999
  });
878
1000
  }
879
- function peg$f45(label, attrs2) {
1001
+ function peg$f46(label, attrs2) {
880
1002
  return createNode("Avatar", {
881
1003
  name: label || null,
882
1004
  ...attrsToObject(attrs2)
883
1005
  });
884
1006
  }
885
- function peg$f46(label, attrs2) {
1007
+ function peg$f47(label, attrs2) {
886
1008
  return createNode("Badge", {
887
1009
  content: label,
888
1010
  ...attrsToObject(attrs2)
889
1011
  });
890
1012
  }
891
- function peg$f47(name, attrs2) {
1013
+ function peg$f48(name, attrs2) {
892
1014
  return createNode("Icon", {
893
1015
  name,
894
1016
  ...attrsToObject(attrs2)
895
1017
  });
896
1018
  }
897
- function peg$f48(data, attrs2) {
1019
+ function peg$f49(data, attrs2) {
898
1020
  const columns = data.length > 0 ? data[0] : [];
899
1021
  const rows = data.slice(1);
900
1022
  return createNode("Table", {
@@ -903,16 +1025,16 @@ function peg$parse(input, options) {
903
1025
  ...attrsToObject(attrs2)
904
1026
  });
905
1027
  }
906
- function peg$f49(attrs2, rows) {
1028
+ function peg$f50(attrs2, rows) {
907
1029
  return createNode("Table", {
908
1030
  ...attrsToObject(attrs2),
909
1031
  ...rows
910
1032
  });
911
1033
  }
912
- function peg$f50(first, rest) {
1034
+ function peg$f51(first, rest) {
913
1035
  return [first, ...rest.map((r) => r[2])];
914
1036
  }
915
- function peg$f51(items) {
1037
+ function peg$f52(items) {
916
1038
  const columns = [];
917
1039
  const rows = [];
918
1040
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -921,72 +1043,72 @@ function peg$parse(input, options) {
921
1043
  }
922
1044
  return { columns, rows };
923
1045
  }
924
- function peg$f52(values) {
1046
+ function peg$f53(values) {
925
1047
  return { kind: "columns", values };
926
1048
  }
927
- function peg$f53(values) {
1049
+ function peg$f54(values) {
928
1050
  return { kind: "row", values };
929
1051
  }
930
- function peg$f54() {
1052
+ function peg$f55() {
931
1053
  return null;
932
1054
  }
933
- function peg$f55(items, attrs2, block) {
1055
+ function peg$f56(items, attrs2, block) {
934
1056
  return createNode("List", {
935
1057
  items: items || (block ? block : []),
936
1058
  ...attrsToObject(attrs2)
937
1059
  });
938
1060
  }
939
- function peg$f56(items) {
1061
+ function peg$f57(items) {
940
1062
  return items.map((i) => i[0]).filter((i) => i !== null);
941
1063
  }
942
- function peg$f57(label, attrs2, nested) {
1064
+ function peg$f58(label, attrs2, nested) {
943
1065
  return createBlockNode("ListItem", {
944
1066
  content: label,
945
1067
  ...attrsToObject(attrs2),
946
1068
  children: nested || []
947
1069
  });
948
1070
  }
949
- function peg$f58() {
1071
+ function peg$f59() {
950
1072
  return null;
951
1073
  }
952
- function peg$f59(label, attrs2) {
1074
+ function peg$f60(label, attrs2) {
953
1075
  return createNode("Alert", {
954
1076
  content: label,
955
1077
  ...attrsToObject(attrs2)
956
1078
  });
957
1079
  }
958
- function peg$f60(label, attrs2) {
1080
+ function peg$f61(label, attrs2) {
959
1081
  return createNode("Toast", {
960
1082
  content: label,
961
1083
  ...attrsToObject(attrs2)
962
1084
  });
963
1085
  }
964
- function peg$f61(attrs2) {
1086
+ function peg$f62(attrs2) {
965
1087
  return createNode("Progress", {
966
1088
  ...attrsToObject(attrs2)
967
1089
  });
968
1090
  }
969
- function peg$f62(label, attrs2) {
1091
+ function peg$f63(label, attrs2) {
970
1092
  return createNode("Spinner", {
971
1093
  label: label || null,
972
1094
  ...attrsToObject(attrs2)
973
1095
  });
974
1096
  }
975
- function peg$f63(label, attrs2) {
1097
+ function peg$f64(label, attrs2) {
976
1098
  return createNode("Tooltip", {
977
1099
  content: label,
978
1100
  ...attrsToObject(attrs2),
979
1101
  children: []
980
1102
  });
981
1103
  }
982
- function peg$f64(label, attrs2, children) {
1104
+ function peg$f65(label, attrs2, children) {
983
1105
  return createNode("Popover", {
984
1106
  title: label || null,
985
1107
  ...attrsToObject(attrs2),
986
1108
  children
987
1109
  });
988
1110
  }
989
- function peg$f65(items, attrs2) {
1111
+ function peg$f66(items, attrs2) {
990
1112
  const processedItems = items.map((item) => {
991
1113
  if (typeof item === "string") {
992
1114
  if (item === "---" || item === "-" || item === "divider") {
@@ -1001,106 +1123,106 @@ function peg$parse(input, options) {
1001
1123
  items: processedItems
1002
1124
  });
1003
1125
  }
1004
- function peg$f66(attrs2, items) {
1126
+ function peg$f67(attrs2, items) {
1005
1127
  return createNode("Dropdown", {
1006
1128
  ...attrsToObject(attrs2),
1007
1129
  items
1008
1130
  });
1009
1131
  }
1010
- function peg$f67(items) {
1132
+ function peg$f68(items) {
1011
1133
  return items.map((i) => i[0]).filter((i) => i !== null);
1012
1134
  }
1013
- function peg$f68(label, attrs2) {
1135
+ function peg$f69(label, attrs2) {
1014
1136
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1015
1137
  }
1016
- function peg$f69() {
1138
+ function peg$f70() {
1017
1139
  return createBlockNode("Divider", {});
1018
1140
  }
1019
- function peg$f70() {
1141
+ function peg$f71() {
1020
1142
  return null;
1021
1143
  }
1022
- function peg$f71(items, attrs2, block) {
1144
+ function peg$f72(items, attrs2, block) {
1023
1145
  return createNode("Nav", {
1024
1146
  items: items || [],
1025
1147
  ...attrsToObject(attrs2),
1026
1148
  children: block || []
1027
1149
  });
1028
1150
  }
1029
- function peg$f72(content) {
1151
+ function peg$f73(content) {
1030
1152
  return content.map((c) => c[0]).filter((c) => c !== null);
1031
1153
  }
1032
- function peg$f73() {
1154
+ function peg$f74() {
1033
1155
  return createBlockNode("Divider", {});
1034
1156
  }
1035
- function peg$f74() {
1157
+ function peg$f75() {
1036
1158
  return null;
1037
1159
  }
1038
- function peg$f75(label, attrs2, items) {
1160
+ function peg$f76(label, attrs2, items) {
1039
1161
  return createBlockNode("NavGroup", {
1040
1162
  label,
1041
1163
  ...attrsToObject(attrs2),
1042
1164
  items: items.map((i) => i[0]).filter((i) => i !== null)
1043
1165
  });
1044
1166
  }
1045
- function peg$f76() {
1167
+ function peg$f77() {
1046
1168
  return createBlockNode("Divider", {});
1047
1169
  }
1048
- function peg$f77() {
1170
+ function peg$f78() {
1049
1171
  return null;
1050
1172
  }
1051
- function peg$f78(label, attrs2) {
1173
+ function peg$f79(label, attrs2) {
1052
1174
  return createBlockNode("NavItem", {
1053
1175
  label,
1054
1176
  ...attrsToObject(attrs2)
1055
1177
  });
1056
1178
  }
1057
- function peg$f79(items, attrs2, block) {
1179
+ function peg$f80(items, attrs2, block) {
1058
1180
  return createNode("Tabs", {
1059
1181
  items: items || [],
1060
1182
  ...attrsToObject(attrs2),
1061
1183
  children: block || []
1062
1184
  });
1063
1185
  }
1064
- function peg$f80(tabs) {
1186
+ function peg$f81(tabs) {
1065
1187
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1066
1188
  }
1067
- function peg$f81(label, attrs2, children) {
1189
+ function peg$f82(label, attrs2, children) {
1068
1190
  return {
1069
1191
  label,
1070
1192
  ...attrsToObject(attrs2),
1071
1193
  children
1072
1194
  };
1073
1195
  }
1074
- function peg$f82() {
1196
+ function peg$f83() {
1075
1197
  return null;
1076
1198
  }
1077
- function peg$f83(items, attrs2) {
1199
+ function peg$f84(items, attrs2) {
1078
1200
  return createNode("Breadcrumb", {
1079
1201
  items,
1080
1202
  ...attrsToObject(attrs2)
1081
1203
  });
1082
1204
  }
1083
- function peg$f84(attrs2) {
1205
+ function peg$f85(attrs2) {
1084
1206
  return createNode("Divider", {
1085
1207
  ...attrsToObject(attrs2)
1086
1208
  });
1087
1209
  }
1088
- function peg$f85(num, attrs2) {
1210
+ function peg$f86(num, attrs2) {
1089
1211
  return createNode("Marker", {
1090
1212
  number: num,
1091
1213
  ...attrsToObject(attrs2)
1092
1214
  });
1093
1215
  }
1094
- function peg$f86(attrs2, items) {
1216
+ function peg$f87(attrs2, items) {
1095
1217
  return createNode("Annotations", {
1096
1218
  ...attrsToObject(attrs2),
1097
1219
  children: items
1098
1220
  });
1099
1221
  }
1100
- function peg$f87(items) {
1222
+ function peg$f88(items) {
1101
1223
  return items.map((i) => i[0]).filter((i) => i !== null);
1102
1224
  }
1103
- function peg$f88(num, title, attrs2, children) {
1225
+ function peg$f89(num, title, attrs2, children) {
1104
1226
  return createNode("AnnotationItem", {
1105
1227
  number: num,
1106
1228
  title,
@@ -1108,7 +1230,7 @@ function peg$parse(input, options) {
1108
1230
  children
1109
1231
  });
1110
1232
  }
1111
- function peg$f89(num, title, attrs2) {
1233
+ function peg$f90(num, title, attrs2) {
1112
1234
  return createNode("AnnotationItem", {
1113
1235
  number: num,
1114
1236
  title,
@@ -1116,90 +1238,90 @@ function peg$parse(input, options) {
1116
1238
  children: []
1117
1239
  });
1118
1240
  }
1119
- function peg$f90() {
1241
+ function peg$f91() {
1120
1242
  return null;
1121
1243
  }
1122
- function peg$f91(digits) {
1244
+ function peg$f92(digits) {
1123
1245
  return parseInt(digits.join(""), 10);
1124
1246
  }
1125
- function peg$f92(attrs2) {
1247
+ function peg$f93(attrs2) {
1126
1248
  return attrs2;
1127
1249
  }
1128
- function peg$f93(x, y) {
1250
+ function peg$f94(x, y) {
1129
1251
  return [
1130
1252
  { name: "x", value: x },
1131
1253
  { name: "y", value: y }
1132
1254
  ];
1133
1255
  }
1134
- function peg$f94(name, value) {
1256
+ function peg$f95(name, value) {
1135
1257
  return { name, value };
1136
1258
  }
1137
- function peg$f95(flag) {
1259
+ function peg$f96(flag) {
1138
1260
  return { name: flag, value: true };
1139
1261
  }
1140
- function peg$f96(name) {
1262
+ function peg$f97(name) {
1141
1263
  return name;
1142
1264
  }
1143
- function peg$f97(chars) {
1265
+ function peg$f98(chars) {
1144
1266
  return chars.join("");
1145
1267
  }
1146
- function peg$f98(chars) {
1268
+ function peg$f99(chars) {
1147
1269
  return chars.join("");
1148
1270
  }
1149
- function peg$f99(char) {
1271
+ function peg$f100(char) {
1150
1272
  return char;
1151
1273
  }
1152
- function peg$f100(seq) {
1274
+ function peg$f101(seq) {
1153
1275
  return seq;
1154
1276
  }
1155
- function peg$f101(char) {
1277
+ function peg$f102(char) {
1156
1278
  return char;
1157
1279
  }
1158
- function peg$f102(seq) {
1280
+ function peg$f103(seq) {
1159
1281
  return seq;
1160
1282
  }
1161
- function peg$f103() {
1283
+ function peg$f104() {
1162
1284
  return "\n";
1163
1285
  }
1164
- function peg$f104() {
1286
+ function peg$f105() {
1165
1287
  return "\r";
1166
1288
  }
1167
- function peg$f105() {
1289
+ function peg$f106() {
1168
1290
  return " ";
1169
1291
  }
1170
- function peg$f106() {
1292
+ function peg$f107() {
1171
1293
  return "\\";
1172
1294
  }
1173
- function peg$f107() {
1295
+ function peg$f108() {
1174
1296
  return '"';
1175
1297
  }
1176
- function peg$f108() {
1298
+ function peg$f109() {
1177
1299
  return "'";
1178
1300
  }
1179
- function peg$f109(sign, digits, decimal) {
1301
+ function peg$f110(sign, digits, decimal) {
1180
1302
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1181
1303
  return parseFloat(num);
1182
1304
  }
1183
- function peg$f110(sign, digits, decimal, unit) {
1305
+ function peg$f111(sign, digits, decimal, unit) {
1184
1306
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1185
1307
  return { value: parseFloat(num), unit };
1186
1308
  }
1187
- function peg$f111() {
1309
+ function peg$f112() {
1188
1310
  return true;
1189
1311
  }
1190
- function peg$f112() {
1312
+ function peg$f113() {
1191
1313
  return false;
1192
1314
  }
1193
- function peg$f113(head, tail) {
1315
+ function peg$f114(head, tail) {
1194
1316
  return head + tail.join("");
1195
1317
  }
1196
- function peg$f114(items) {
1318
+ function peg$f115(items) {
1197
1319
  return items || [];
1198
1320
  }
1199
- function peg$f115(head, tail) {
1321
+ function peg$f116(head, tail) {
1200
1322
  return [head, ...tail.map((t) => t[3])];
1201
1323
  }
1202
- function peg$f116(props) {
1324
+ function peg$f117(props) {
1203
1325
  const result = {};
1204
1326
  if (props) {
1205
1327
  for (const p of props) {
@@ -1208,13 +1330,13 @@ function peg$parse(input, options) {
1208
1330
  }
1209
1331
  return result;
1210
1332
  }
1211
- function peg$f117(head, tail) {
1333
+ function peg$f118(head, tail) {
1212
1334
  return [head, ...tail.map((t) => t[3])];
1213
1335
  }
1214
- function peg$f118(name, value) {
1336
+ function peg$f119(name, value) {
1215
1337
  return { name, value };
1216
1338
  }
1217
- function peg$f119(name) {
1339
+ function peg$f120(name) {
1218
1340
  return { name, value: true };
1219
1341
  }
1220
1342
  let peg$currPos = options.peg$currPos | 0;
@@ -2466,21 +2588,24 @@ function peg$parse(input, options) {
2466
2588
  let s0, s1;
2467
2589
  s0 = peg$parseComponentUse();
2468
2590
  if (s0 === peg$FAILED) {
2469
- s0 = peg$parseLayoutElement();
2591
+ s0 = peg$parseRepeat();
2470
2592
  if (s0 === peg$FAILED) {
2471
- s0 = peg$parseContainerElement();
2593
+ s0 = peg$parseLayoutElement();
2472
2594
  if (s0 === peg$FAILED) {
2473
- s0 = peg$parseUIElement();
2595
+ s0 = peg$parseContainerElement();
2474
2596
  if (s0 === peg$FAILED) {
2475
- s0 = peg$parseSlot();
2597
+ s0 = peg$parseUIElement();
2476
2598
  if (s0 === peg$FAILED) {
2477
- s0 = peg$currPos;
2478
- s1 = peg$parseComment();
2479
- if (s1 !== peg$FAILED) {
2480
- peg$savedPos = s0;
2481
- s1 = peg$f18();
2599
+ s0 = peg$parseSlot();
2600
+ if (s0 === peg$FAILED) {
2601
+ s0 = peg$currPos;
2602
+ s1 = peg$parseComment();
2603
+ if (s1 !== peg$FAILED) {
2604
+ peg$savedPos = s0;
2605
+ s1 = peg$f18();
2606
+ }
2607
+ s0 = s1;
2482
2608
  }
2483
- s0 = s1;
2484
2609
  }
2485
2610
  }
2486
2611
  }
@@ -2488,6 +2613,71 @@ function peg$parse(input, options) {
2488
2613
  }
2489
2614
  return s0;
2490
2615
  }
2616
+ function peg$parseRepeat() {
2617
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2618
+ s0 = peg$currPos;
2619
+ if (input.substr(peg$currPos, 6) === peg$c20) {
2620
+ s1 = peg$c20;
2621
+ peg$currPos += 6;
2622
+ } else {
2623
+ s1 = peg$FAILED;
2624
+ if (peg$silentFails === 0) {
2625
+ peg$fail(peg$e23);
2626
+ }
2627
+ }
2628
+ if (s1 !== peg$FAILED) {
2629
+ s2 = peg$parse_();
2630
+ s3 = peg$parseInteger();
2631
+ if (s3 !== peg$FAILED) {
2632
+ s4 = peg$parse_();
2633
+ if (input.charCodeAt(peg$currPos) === 123) {
2634
+ s5 = peg$c1;
2635
+ peg$currPos++;
2636
+ } else {
2637
+ s5 = peg$FAILED;
2638
+ if (peg$silentFails === 0) {
2639
+ peg$fail(peg$e1);
2640
+ }
2641
+ }
2642
+ if (s5 !== peg$FAILED) {
2643
+ s6 = peg$parse_();
2644
+ s7 = peg$parseChildren();
2645
+ if (s7 !== peg$FAILED) {
2646
+ s8 = peg$parse_();
2647
+ if (input.charCodeAt(peg$currPos) === 125) {
2648
+ s9 = peg$c2;
2649
+ peg$currPos++;
2650
+ } else {
2651
+ s9 = peg$FAILED;
2652
+ if (peg$silentFails === 0) {
2653
+ peg$fail(peg$e2);
2654
+ }
2655
+ }
2656
+ if (s9 !== peg$FAILED) {
2657
+ peg$savedPos = s0;
2658
+ s0 = peg$f19(s3, s7);
2659
+ } else {
2660
+ peg$currPos = s0;
2661
+ s0 = peg$FAILED;
2662
+ }
2663
+ } else {
2664
+ peg$currPos = s0;
2665
+ s0 = peg$FAILED;
2666
+ }
2667
+ } else {
2668
+ peg$currPos = s0;
2669
+ s0 = peg$FAILED;
2670
+ }
2671
+ } else {
2672
+ peg$currPos = s0;
2673
+ s0 = peg$FAILED;
2674
+ }
2675
+ } else {
2676
+ peg$currPos = s0;
2677
+ s0 = peg$FAILED;
2678
+ }
2679
+ return s0;
2680
+ }
2491
2681
  function peg$parseLayoutElement() {
2492
2682
  let s0;
2493
2683
  s0 = peg$parseHeader();
@@ -2517,13 +2707,13 @@ function peg$parse(input, options) {
2517
2707
  function peg$parseHeader() {
2518
2708
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2519
2709
  s0 = peg$currPos;
2520
- if (input.substr(peg$currPos, 6) === peg$c20) {
2521
- s1 = peg$c20;
2710
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2711
+ s1 = peg$c21;
2522
2712
  peg$currPos += 6;
2523
2713
  } else {
2524
2714
  s1 = peg$FAILED;
2525
2715
  if (peg$silentFails === 0) {
2526
- peg$fail(peg$e23);
2716
+ peg$fail(peg$e24);
2527
2717
  }
2528
2718
  }
2529
2719
  if (s1 !== peg$FAILED) {
@@ -2558,7 +2748,7 @@ function peg$parse(input, options) {
2558
2748
  }
2559
2749
  if (s9 !== peg$FAILED) {
2560
2750
  peg$savedPos = s0;
2561
- s0 = peg$f19(s3, s7);
2751
+ s0 = peg$f20(s3, s7);
2562
2752
  } else {
2563
2753
  peg$currPos = s0;
2564
2754
  s0 = peg$FAILED;
@@ -2580,13 +2770,13 @@ function peg$parse(input, options) {
2580
2770
  function peg$parseMain() {
2581
2771
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2582
2772
  s0 = peg$currPos;
2583
- if (input.substr(peg$currPos, 4) === peg$c21) {
2584
- s1 = peg$c21;
2773
+ if (input.substr(peg$currPos, 4) === peg$c22) {
2774
+ s1 = peg$c22;
2585
2775
  peg$currPos += 4;
2586
2776
  } else {
2587
2777
  s1 = peg$FAILED;
2588
2778
  if (peg$silentFails === 0) {
2589
- peg$fail(peg$e24);
2779
+ peg$fail(peg$e25);
2590
2780
  }
2591
2781
  }
2592
2782
  if (s1 !== peg$FAILED) {
@@ -2621,7 +2811,7 @@ function peg$parse(input, options) {
2621
2811
  }
2622
2812
  if (s9 !== peg$FAILED) {
2623
2813
  peg$savedPos = s0;
2624
- s0 = peg$f20(s3, s7);
2814
+ s0 = peg$f21(s3, s7);
2625
2815
  } else {
2626
2816
  peg$currPos = s0;
2627
2817
  s0 = peg$FAILED;
@@ -2643,13 +2833,13 @@ function peg$parse(input, options) {
2643
2833
  function peg$parseFooter() {
2644
2834
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2645
2835
  s0 = peg$currPos;
2646
- if (input.substr(peg$currPos, 6) === peg$c22) {
2647
- s1 = peg$c22;
2836
+ if (input.substr(peg$currPos, 6) === peg$c23) {
2837
+ s1 = peg$c23;
2648
2838
  peg$currPos += 6;
2649
2839
  } else {
2650
2840
  s1 = peg$FAILED;
2651
2841
  if (peg$silentFails === 0) {
2652
- peg$fail(peg$e25);
2842
+ peg$fail(peg$e26);
2653
2843
  }
2654
2844
  }
2655
2845
  if (s1 !== peg$FAILED) {
@@ -2684,7 +2874,7 @@ function peg$parse(input, options) {
2684
2874
  }
2685
2875
  if (s9 !== peg$FAILED) {
2686
2876
  peg$savedPos = s0;
2687
- s0 = peg$f21(s3, s7);
2877
+ s0 = peg$f22(s3, s7);
2688
2878
  } else {
2689
2879
  peg$currPos = s0;
2690
2880
  s0 = peg$FAILED;
@@ -2706,13 +2896,13 @@ function peg$parse(input, options) {
2706
2896
  function peg$parseSidebar() {
2707
2897
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2708
2898
  s0 = peg$currPos;
2709
- if (input.substr(peg$currPos, 7) === peg$c23) {
2710
- s1 = peg$c23;
2899
+ if (input.substr(peg$currPos, 7) === peg$c24) {
2900
+ s1 = peg$c24;
2711
2901
  peg$currPos += 7;
2712
2902
  } else {
2713
2903
  s1 = peg$FAILED;
2714
2904
  if (peg$silentFails === 0) {
2715
- peg$fail(peg$e26);
2905
+ peg$fail(peg$e27);
2716
2906
  }
2717
2907
  }
2718
2908
  if (s1 !== peg$FAILED) {
@@ -2747,7 +2937,7 @@ function peg$parse(input, options) {
2747
2937
  }
2748
2938
  if (s9 !== peg$FAILED) {
2749
2939
  peg$savedPos = s0;
2750
- s0 = peg$f22(s3, s7);
2940
+ s0 = peg$f23(s3, s7);
2751
2941
  } else {
2752
2942
  peg$currPos = s0;
2753
2943
  s0 = peg$FAILED;
@@ -2769,13 +2959,13 @@ function peg$parse(input, options) {
2769
2959
  function peg$parseRow() {
2770
2960
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2771
2961
  s0 = peg$currPos;
2772
- if (input.substr(peg$currPos, 3) === peg$c24) {
2773
- s1 = peg$c24;
2962
+ if (input.substr(peg$currPos, 3) === peg$c25) {
2963
+ s1 = peg$c25;
2774
2964
  peg$currPos += 3;
2775
2965
  } else {
2776
2966
  s1 = peg$FAILED;
2777
2967
  if (peg$silentFails === 0) {
2778
- peg$fail(peg$e27);
2968
+ peg$fail(peg$e28);
2779
2969
  }
2780
2970
  }
2781
2971
  if (s1 !== peg$FAILED) {
@@ -2810,7 +3000,7 @@ function peg$parse(input, options) {
2810
3000
  }
2811
3001
  if (s9 !== peg$FAILED) {
2812
3002
  peg$savedPos = s0;
2813
- s0 = peg$f23(s3, s7);
3003
+ s0 = peg$f24(s3, s7);
2814
3004
  } else {
2815
3005
  peg$currPos = s0;
2816
3006
  s0 = peg$FAILED;
@@ -2832,13 +3022,13 @@ function peg$parse(input, options) {
2832
3022
  function peg$parseCol() {
2833
3023
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2834
3024
  s0 = peg$currPos;
2835
- if (input.substr(peg$currPos, 3) === peg$c25) {
2836
- s1 = peg$c25;
3025
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3026
+ s1 = peg$c26;
2837
3027
  peg$currPos += 3;
2838
3028
  } else {
2839
3029
  s1 = peg$FAILED;
2840
3030
  if (peg$silentFails === 0) {
2841
- peg$fail(peg$e28);
3031
+ peg$fail(peg$e29);
2842
3032
  }
2843
3033
  }
2844
3034
  if (s1 !== peg$FAILED) {
@@ -2873,7 +3063,7 @@ function peg$parse(input, options) {
2873
3063
  }
2874
3064
  if (s9 !== peg$FAILED) {
2875
3065
  peg$savedPos = s0;
2876
- s0 = peg$f24(s3, s7);
3066
+ s0 = peg$f25(s3, s7);
2877
3067
  } else {
2878
3068
  peg$currPos = s0;
2879
3069
  s0 = peg$FAILED;
@@ -2895,13 +3085,13 @@ function peg$parse(input, options) {
2895
3085
  function peg$parseStack() {
2896
3086
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2897
3087
  s0 = peg$currPos;
2898
- if (input.substr(peg$currPos, 5) === peg$c26) {
2899
- s1 = peg$c26;
3088
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3089
+ s1 = peg$c27;
2900
3090
  peg$currPos += 5;
2901
3091
  } else {
2902
3092
  s1 = peg$FAILED;
2903
3093
  if (peg$silentFails === 0) {
2904
- peg$fail(peg$e29);
3094
+ peg$fail(peg$e30);
2905
3095
  }
2906
3096
  }
2907
3097
  if (s1 !== peg$FAILED) {
@@ -2936,7 +3126,7 @@ function peg$parse(input, options) {
2936
3126
  }
2937
3127
  if (s9 !== peg$FAILED) {
2938
3128
  peg$savedPos = s0;
2939
- s0 = peg$f25(s3, s7);
3129
+ s0 = peg$f26(s3, s7);
2940
3130
  } else {
2941
3131
  peg$currPos = s0;
2942
3132
  s0 = peg$FAILED;
@@ -2958,13 +3148,13 @@ function peg$parse(input, options) {
2958
3148
  function peg$parseRelative() {
2959
3149
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2960
3150
  s0 = peg$currPos;
2961
- if (input.substr(peg$currPos, 8) === peg$c27) {
2962
- s1 = peg$c27;
3151
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3152
+ s1 = peg$c28;
2963
3153
  peg$currPos += 8;
2964
3154
  } else {
2965
3155
  s1 = peg$FAILED;
2966
3156
  if (peg$silentFails === 0) {
2967
- peg$fail(peg$e30);
3157
+ peg$fail(peg$e31);
2968
3158
  }
2969
3159
  }
2970
3160
  if (s1 !== peg$FAILED) {
@@ -2999,7 +3189,7 @@ function peg$parse(input, options) {
2999
3189
  }
3000
3190
  if (s9 !== peg$FAILED) {
3001
3191
  peg$savedPos = s0;
3002
- s0 = peg$f26(s3, s7);
3192
+ s0 = peg$f27(s3, s7);
3003
3193
  } else {
3004
3194
  peg$currPos = s0;
3005
3195
  s0 = peg$FAILED;
@@ -3038,13 +3228,13 @@ function peg$parse(input, options) {
3038
3228
  function peg$parseCard() {
3039
3229
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3040
3230
  s0 = peg$currPos;
3041
- if (input.substr(peg$currPos, 4) === peg$c28) {
3042
- s1 = peg$c28;
3231
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3232
+ s1 = peg$c29;
3043
3233
  peg$currPos += 4;
3044
3234
  } else {
3045
3235
  s1 = peg$FAILED;
3046
3236
  if (peg$silentFails === 0) {
3047
- peg$fail(peg$e31);
3237
+ peg$fail(peg$e32);
3048
3238
  }
3049
3239
  }
3050
3240
  if (s1 !== peg$FAILED) {
@@ -3084,7 +3274,7 @@ function peg$parse(input, options) {
3084
3274
  }
3085
3275
  if (s11 !== peg$FAILED) {
3086
3276
  peg$savedPos = s0;
3087
- s0 = peg$f27(s3, s5, s9);
3277
+ s0 = peg$f28(s3, s5, s9);
3088
3278
  } else {
3089
3279
  peg$currPos = s0;
3090
3280
  s0 = peg$FAILED;
@@ -3106,13 +3296,13 @@ function peg$parse(input, options) {
3106
3296
  function peg$parseModal() {
3107
3297
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3108
3298
  s0 = peg$currPos;
3109
- if (input.substr(peg$currPos, 5) === peg$c29) {
3110
- s1 = peg$c29;
3299
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3300
+ s1 = peg$c30;
3111
3301
  peg$currPos += 5;
3112
3302
  } else {
3113
3303
  s1 = peg$FAILED;
3114
3304
  if (peg$silentFails === 0) {
3115
- peg$fail(peg$e32);
3305
+ peg$fail(peg$e33);
3116
3306
  }
3117
3307
  }
3118
3308
  if (s1 !== peg$FAILED) {
@@ -3152,7 +3342,7 @@ function peg$parse(input, options) {
3152
3342
  }
3153
3343
  if (s11 !== peg$FAILED) {
3154
3344
  peg$savedPos = s0;
3155
- s0 = peg$f28(s3, s5, s9);
3345
+ s0 = peg$f29(s3, s5, s9);
3156
3346
  } else {
3157
3347
  peg$currPos = s0;
3158
3348
  s0 = peg$FAILED;
@@ -3174,13 +3364,13 @@ function peg$parse(input, options) {
3174
3364
  function peg$parseDrawer() {
3175
3365
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3176
3366
  s0 = peg$currPos;
3177
- if (input.substr(peg$currPos, 6) === peg$c30) {
3178
- s1 = peg$c30;
3367
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3368
+ s1 = peg$c31;
3179
3369
  peg$currPos += 6;
3180
3370
  } else {
3181
3371
  s1 = peg$FAILED;
3182
3372
  if (peg$silentFails === 0) {
3183
- peg$fail(peg$e33);
3373
+ peg$fail(peg$e34);
3184
3374
  }
3185
3375
  }
3186
3376
  if (s1 !== peg$FAILED) {
@@ -3220,7 +3410,7 @@ function peg$parse(input, options) {
3220
3410
  }
3221
3411
  if (s11 !== peg$FAILED) {
3222
3412
  peg$savedPos = s0;
3223
- s0 = peg$f29(s3, s5, s9);
3413
+ s0 = peg$f30(s3, s5, s9);
3224
3414
  } else {
3225
3415
  peg$currPos = s0;
3226
3416
  s0 = peg$FAILED;
@@ -3242,13 +3432,13 @@ function peg$parse(input, options) {
3242
3432
  function peg$parseAccordion() {
3243
3433
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3244
3434
  s0 = peg$currPos;
3245
- if (input.substr(peg$currPos, 9) === peg$c31) {
3246
- s1 = peg$c31;
3435
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3436
+ s1 = peg$c32;
3247
3437
  peg$currPos += 9;
3248
3438
  } else {
3249
3439
  s1 = peg$FAILED;
3250
3440
  if (peg$silentFails === 0) {
3251
- peg$fail(peg$e34);
3441
+ peg$fail(peg$e35);
3252
3442
  }
3253
3443
  }
3254
3444
  if (s1 !== peg$FAILED) {
@@ -3288,7 +3478,7 @@ function peg$parse(input, options) {
3288
3478
  }
3289
3479
  if (s11 !== peg$FAILED) {
3290
3480
  peg$savedPos = s0;
3291
- s0 = peg$f30(s3, s5, s9);
3481
+ s0 = peg$f31(s3, s5, s9);
3292
3482
  } else {
3293
3483
  peg$currPos = s0;
3294
3484
  s0 = peg$FAILED;
@@ -3310,13 +3500,13 @@ function peg$parse(input, options) {
3310
3500
  function peg$parseSection() {
3311
3501
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3312
3502
  s0 = peg$currPos;
3313
- if (input.substr(peg$currPos, 7) === peg$c32) {
3314
- s1 = peg$c32;
3503
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3504
+ s1 = peg$c33;
3315
3505
  peg$currPos += 7;
3316
3506
  } else {
3317
3507
  s1 = peg$FAILED;
3318
3508
  if (peg$silentFails === 0) {
3319
- peg$fail(peg$e35);
3509
+ peg$fail(peg$e36);
3320
3510
  }
3321
3511
  }
3322
3512
  if (s1 !== peg$FAILED) {
@@ -3356,7 +3546,7 @@ function peg$parse(input, options) {
3356
3546
  }
3357
3547
  if (s11 !== peg$FAILED) {
3358
3548
  peg$savedPos = s0;
3359
- s0 = peg$f31(s3, s5, s9);
3549
+ s0 = peg$f32(s3, s5, s9);
3360
3550
  } else {
3361
3551
  peg$currPos = s0;
3362
3552
  s0 = peg$FAILED;
@@ -3473,13 +3663,13 @@ function peg$parse(input, options) {
3473
3663
  function peg$parseText() {
3474
3664
  let s0, s1, s2, s3, s4, s5;
3475
3665
  s0 = peg$currPos;
3476
- if (input.substr(peg$currPos, 4) === peg$c33) {
3477
- s1 = peg$c33;
3666
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3667
+ s1 = peg$c34;
3478
3668
  peg$currPos += 4;
3479
3669
  } else {
3480
3670
  s1 = peg$FAILED;
3481
3671
  if (peg$silentFails === 0) {
3482
- peg$fail(peg$e36);
3672
+ peg$fail(peg$e37);
3483
3673
  }
3484
3674
  }
3485
3675
  if (s1 !== peg$FAILED) {
@@ -3492,7 +3682,7 @@ function peg$parse(input, options) {
3492
3682
  s5 = null;
3493
3683
  }
3494
3684
  peg$savedPos = s0;
3495
- s0 = peg$f32(s3, s5);
3685
+ s0 = peg$f33(s3, s5);
3496
3686
  } else {
3497
3687
  peg$currPos = s0;
3498
3688
  s0 = peg$FAILED;
@@ -3506,13 +3696,13 @@ function peg$parse(input, options) {
3506
3696
  function peg$parseTitle() {
3507
3697
  let s0, s1, s2, s3, s4, s5;
3508
3698
  s0 = peg$currPos;
3509
- if (input.substr(peg$currPos, 5) === peg$c34) {
3510
- s1 = peg$c34;
3699
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3700
+ s1 = peg$c35;
3511
3701
  peg$currPos += 5;
3512
3702
  } else {
3513
3703
  s1 = peg$FAILED;
3514
3704
  if (peg$silentFails === 0) {
3515
- peg$fail(peg$e37);
3705
+ peg$fail(peg$e38);
3516
3706
  }
3517
3707
  }
3518
3708
  if (s1 !== peg$FAILED) {
@@ -3525,7 +3715,7 @@ function peg$parse(input, options) {
3525
3715
  s5 = null;
3526
3716
  }
3527
3717
  peg$savedPos = s0;
3528
- s0 = peg$f33(s3, s5);
3718
+ s0 = peg$f34(s3, s5);
3529
3719
  } else {
3530
3720
  peg$currPos = s0;
3531
3721
  s0 = peg$FAILED;
@@ -3539,13 +3729,13 @@ function peg$parse(input, options) {
3539
3729
  function peg$parseLink() {
3540
3730
  let s0, s1, s2, s3, s4, s5;
3541
3731
  s0 = peg$currPos;
3542
- if (input.substr(peg$currPos, 4) === peg$c35) {
3543
- s1 = peg$c35;
3732
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3733
+ s1 = peg$c36;
3544
3734
  peg$currPos += 4;
3545
3735
  } else {
3546
3736
  s1 = peg$FAILED;
3547
3737
  if (peg$silentFails === 0) {
3548
- peg$fail(peg$e38);
3738
+ peg$fail(peg$e39);
3549
3739
  }
3550
3740
  }
3551
3741
  if (s1 !== peg$FAILED) {
@@ -3558,7 +3748,7 @@ function peg$parse(input, options) {
3558
3748
  s5 = null;
3559
3749
  }
3560
3750
  peg$savedPos = s0;
3561
- s0 = peg$f34(s3, s5);
3751
+ s0 = peg$f35(s3, s5);
3562
3752
  } else {
3563
3753
  peg$currPos = s0;
3564
3754
  s0 = peg$FAILED;
@@ -3572,13 +3762,13 @@ function peg$parse(input, options) {
3572
3762
  function peg$parseButton() {
3573
3763
  let s0, s1, s2, s3, s4, s5;
3574
3764
  s0 = peg$currPos;
3575
- if (input.substr(peg$currPos, 6) === peg$c36) {
3576
- s1 = peg$c36;
3765
+ if (input.substr(peg$currPos, 6) === peg$c37) {
3766
+ s1 = peg$c37;
3577
3767
  peg$currPos += 6;
3578
3768
  } else {
3579
3769
  s1 = peg$FAILED;
3580
3770
  if (peg$silentFails === 0) {
3581
- peg$fail(peg$e39);
3771
+ peg$fail(peg$e40);
3582
3772
  }
3583
3773
  }
3584
3774
  if (s1 !== peg$FAILED) {
@@ -3591,7 +3781,7 @@ function peg$parse(input, options) {
3591
3781
  s5 = null;
3592
3782
  }
3593
3783
  peg$savedPos = s0;
3594
- s0 = peg$f35(s3, s5);
3784
+ s0 = peg$f36(s3, s5);
3595
3785
  } else {
3596
3786
  peg$currPos = s0;
3597
3787
  s0 = peg$FAILED;
@@ -3605,13 +3795,13 @@ function peg$parse(input, options) {
3605
3795
  function peg$parseInput() {
3606
3796
  let s0, s1, s2, s3, s4, s5;
3607
3797
  s0 = peg$currPos;
3608
- if (input.substr(peg$currPos, 5) === peg$c37) {
3609
- s1 = peg$c37;
3798
+ if (input.substr(peg$currPos, 5) === peg$c38) {
3799
+ s1 = peg$c38;
3610
3800
  peg$currPos += 5;
3611
3801
  } else {
3612
3802
  s1 = peg$FAILED;
3613
3803
  if (peg$silentFails === 0) {
3614
- peg$fail(peg$e40);
3804
+ peg$fail(peg$e41);
3615
3805
  }
3616
3806
  }
3617
3807
  if (s1 !== peg$FAILED) {
@@ -3626,7 +3816,7 @@ function peg$parse(input, options) {
3626
3816
  s5 = null;
3627
3817
  }
3628
3818
  peg$savedPos = s0;
3629
- s0 = peg$f36(s3, s5);
3819
+ s0 = peg$f37(s3, s5);
3630
3820
  } else {
3631
3821
  peg$currPos = s0;
3632
3822
  s0 = peg$FAILED;
@@ -3636,13 +3826,13 @@ function peg$parse(input, options) {
3636
3826
  function peg$parseTextarea() {
3637
3827
  let s0, s1, s2, s3, s4, s5;
3638
3828
  s0 = peg$currPos;
3639
- if (input.substr(peg$currPos, 8) === peg$c38) {
3640
- s1 = peg$c38;
3829
+ if (input.substr(peg$currPos, 8) === peg$c39) {
3830
+ s1 = peg$c39;
3641
3831
  peg$currPos += 8;
3642
3832
  } else {
3643
3833
  s1 = peg$FAILED;
3644
3834
  if (peg$silentFails === 0) {
3645
- peg$fail(peg$e41);
3835
+ peg$fail(peg$e42);
3646
3836
  }
3647
3837
  }
3648
3838
  if (s1 !== peg$FAILED) {
@@ -3657,7 +3847,7 @@ function peg$parse(input, options) {
3657
3847
  s5 = null;
3658
3848
  }
3659
3849
  peg$savedPos = s0;
3660
- s0 = peg$f37(s3, s5);
3850
+ s0 = peg$f38(s3, s5);
3661
3851
  } else {
3662
3852
  peg$currPos = s0;
3663
3853
  s0 = peg$FAILED;
@@ -3667,13 +3857,13 @@ function peg$parse(input, options) {
3667
3857
  function peg$parseSelect() {
3668
3858
  let s0, s1, s2, s3, s4, s5, s6, s7;
3669
3859
  s0 = peg$currPos;
3670
- if (input.substr(peg$currPos, 6) === peg$c39) {
3671
- s1 = peg$c39;
3860
+ if (input.substr(peg$currPos, 6) === peg$c40) {
3861
+ s1 = peg$c40;
3672
3862
  peg$currPos += 6;
3673
3863
  } else {
3674
3864
  s1 = peg$FAILED;
3675
3865
  if (peg$silentFails === 0) {
3676
- peg$fail(peg$e42);
3866
+ peg$fail(peg$e43);
3677
3867
  }
3678
3868
  }
3679
3869
  if (s1 !== peg$FAILED) {
@@ -3693,7 +3883,7 @@ function peg$parse(input, options) {
3693
3883
  s7 = null;
3694
3884
  }
3695
3885
  peg$savedPos = s0;
3696
- s0 = peg$f38(s3, s5, s7);
3886
+ s0 = peg$f39(s3, s5, s7);
3697
3887
  } else {
3698
3888
  peg$currPos = s0;
3699
3889
  s0 = peg$FAILED;
@@ -3703,13 +3893,13 @@ function peg$parse(input, options) {
3703
3893
  function peg$parseCheckbox() {
3704
3894
  let s0, s1, s2, s3, s4, s5;
3705
3895
  s0 = peg$currPos;
3706
- if (input.substr(peg$currPos, 8) === peg$c40) {
3707
- s1 = peg$c40;
3896
+ if (input.substr(peg$currPos, 8) === peg$c41) {
3897
+ s1 = peg$c41;
3708
3898
  peg$currPos += 8;
3709
3899
  } else {
3710
3900
  s1 = peg$FAILED;
3711
3901
  if (peg$silentFails === 0) {
3712
- peg$fail(peg$e43);
3902
+ peg$fail(peg$e44);
3713
3903
  }
3714
3904
  }
3715
3905
  if (s1 !== peg$FAILED) {
@@ -3724,7 +3914,7 @@ function peg$parse(input, options) {
3724
3914
  s5 = null;
3725
3915
  }
3726
3916
  peg$savedPos = s0;
3727
- s0 = peg$f39(s3, s5);
3917
+ s0 = peg$f40(s3, s5);
3728
3918
  } else {
3729
3919
  peg$currPos = s0;
3730
3920
  s0 = peg$FAILED;
@@ -3734,13 +3924,13 @@ function peg$parse(input, options) {
3734
3924
  function peg$parseRadio() {
3735
3925
  let s0, s1, s2, s3, s4, s5;
3736
3926
  s0 = peg$currPos;
3737
- if (input.substr(peg$currPos, 5) === peg$c41) {
3738
- s1 = peg$c41;
3927
+ if (input.substr(peg$currPos, 5) === peg$c42) {
3928
+ s1 = peg$c42;
3739
3929
  peg$currPos += 5;
3740
3930
  } else {
3741
3931
  s1 = peg$FAILED;
3742
3932
  if (peg$silentFails === 0) {
3743
- peg$fail(peg$e44);
3933
+ peg$fail(peg$e45);
3744
3934
  }
3745
3935
  }
3746
3936
  if (s1 !== peg$FAILED) {
@@ -3755,7 +3945,7 @@ function peg$parse(input, options) {
3755
3945
  s5 = null;
3756
3946
  }
3757
3947
  peg$savedPos = s0;
3758
- s0 = peg$f40(s3, s5);
3948
+ s0 = peg$f41(s3, s5);
3759
3949
  } else {
3760
3950
  peg$currPos = s0;
3761
3951
  s0 = peg$FAILED;
@@ -3765,13 +3955,13 @@ function peg$parse(input, options) {
3765
3955
  function peg$parseSwitch() {
3766
3956
  let s0, s1, s2, s3, s4, s5;
3767
3957
  s0 = peg$currPos;
3768
- if (input.substr(peg$currPos, 6) === peg$c42) {
3769
- s1 = peg$c42;
3958
+ if (input.substr(peg$currPos, 6) === peg$c43) {
3959
+ s1 = peg$c43;
3770
3960
  peg$currPos += 6;
3771
3961
  } else {
3772
3962
  s1 = peg$FAILED;
3773
3963
  if (peg$silentFails === 0) {
3774
- peg$fail(peg$e45);
3964
+ peg$fail(peg$e46);
3775
3965
  }
3776
3966
  }
3777
3967
  if (s1 !== peg$FAILED) {
@@ -3786,7 +3976,7 @@ function peg$parse(input, options) {
3786
3976
  s5 = null;
3787
3977
  }
3788
3978
  peg$savedPos = s0;
3789
- s0 = peg$f41(s3, s5);
3979
+ s0 = peg$f42(s3, s5);
3790
3980
  } else {
3791
3981
  peg$currPos = s0;
3792
3982
  s0 = peg$FAILED;
@@ -3796,13 +3986,13 @@ function peg$parse(input, options) {
3796
3986
  function peg$parseSlider() {
3797
3987
  let s0, s1, s2, s3, s4, s5;
3798
3988
  s0 = peg$currPos;
3799
- if (input.substr(peg$currPos, 6) === peg$c43) {
3800
- s1 = peg$c43;
3989
+ if (input.substr(peg$currPos, 6) === peg$c44) {
3990
+ s1 = peg$c44;
3801
3991
  peg$currPos += 6;
3802
3992
  } else {
3803
3993
  s1 = peg$FAILED;
3804
3994
  if (peg$silentFails === 0) {
3805
- peg$fail(peg$e46);
3995
+ peg$fail(peg$e47);
3806
3996
  }
3807
3997
  }
3808
3998
  if (s1 !== peg$FAILED) {
@@ -3817,7 +4007,7 @@ function peg$parse(input, options) {
3817
4007
  s5 = null;
3818
4008
  }
3819
4009
  peg$savedPos = s0;
3820
- s0 = peg$f42(s3, s5);
4010
+ s0 = peg$f43(s3, s5);
3821
4011
  } else {
3822
4012
  peg$currPos = s0;
3823
4013
  s0 = peg$FAILED;
@@ -3827,13 +4017,13 @@ function peg$parse(input, options) {
3827
4017
  function peg$parseImage() {
3828
4018
  let s0, s1, s2, s3, s4, s5;
3829
4019
  s0 = peg$currPos;
3830
- if (input.substr(peg$currPos, 5) === peg$c44) {
3831
- s1 = peg$c44;
4020
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4021
+ s1 = peg$c45;
3832
4022
  peg$currPos += 5;
3833
4023
  } else {
3834
4024
  s1 = peg$FAILED;
3835
4025
  if (peg$silentFails === 0) {
3836
- peg$fail(peg$e47);
4026
+ peg$fail(peg$e48);
3837
4027
  }
3838
4028
  }
3839
4029
  if (s1 !== peg$FAILED) {
@@ -3848,7 +4038,7 @@ function peg$parse(input, options) {
3848
4038
  s5 = null;
3849
4039
  }
3850
4040
  peg$savedPos = s0;
3851
- s0 = peg$f43(s3, s5);
4041
+ s0 = peg$f44(s3, s5);
3852
4042
  } else {
3853
4043
  peg$currPos = s0;
3854
4044
  s0 = peg$FAILED;
@@ -3858,13 +4048,13 @@ function peg$parse(input, options) {
3858
4048
  function peg$parsePlaceholder() {
3859
4049
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
3860
4050
  s0 = peg$currPos;
3861
- if (input.substr(peg$currPos, 11) === peg$c45) {
3862
- s1 = peg$c45;
4051
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4052
+ s1 = peg$c46;
3863
4053
  peg$currPos += 11;
3864
4054
  } else {
3865
4055
  s1 = peg$FAILED;
3866
4056
  if (peg$silentFails === 0) {
3867
- peg$fail(peg$e48);
4057
+ peg$fail(peg$e49);
3868
4058
  }
3869
4059
  }
3870
4060
  if (s1 !== peg$FAILED) {
@@ -3922,7 +4112,7 @@ function peg$parse(input, options) {
3922
4112
  s7 = null;
3923
4113
  }
3924
4114
  peg$savedPos = s0;
3925
- s0 = peg$f44(s3, s5, s7);
4115
+ s0 = peg$f45(s3, s5, s7);
3926
4116
  } else {
3927
4117
  peg$currPos = s0;
3928
4118
  s0 = peg$FAILED;
@@ -3932,13 +4122,13 @@ function peg$parse(input, options) {
3932
4122
  function peg$parseAvatar() {
3933
4123
  let s0, s1, s2, s3, s4, s5;
3934
4124
  s0 = peg$currPos;
3935
- if (input.substr(peg$currPos, 6) === peg$c46) {
3936
- s1 = peg$c46;
4125
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4126
+ s1 = peg$c47;
3937
4127
  peg$currPos += 6;
3938
4128
  } else {
3939
4129
  s1 = peg$FAILED;
3940
4130
  if (peg$silentFails === 0) {
3941
- peg$fail(peg$e49);
4131
+ peg$fail(peg$e50);
3942
4132
  }
3943
4133
  }
3944
4134
  if (s1 !== peg$FAILED) {
@@ -3953,7 +4143,7 @@ function peg$parse(input, options) {
3953
4143
  s5 = null;
3954
4144
  }
3955
4145
  peg$savedPos = s0;
3956
- s0 = peg$f45(s3, s5);
4146
+ s0 = peg$f46(s3, s5);
3957
4147
  } else {
3958
4148
  peg$currPos = s0;
3959
4149
  s0 = peg$FAILED;
@@ -3963,13 +4153,13 @@ function peg$parse(input, options) {
3963
4153
  function peg$parseBadge() {
3964
4154
  let s0, s1, s2, s3, s4, s5;
3965
4155
  s0 = peg$currPos;
3966
- if (input.substr(peg$currPos, 5) === peg$c47) {
3967
- s1 = peg$c47;
4156
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4157
+ s1 = peg$c48;
3968
4158
  peg$currPos += 5;
3969
4159
  } else {
3970
4160
  s1 = peg$FAILED;
3971
4161
  if (peg$silentFails === 0) {
3972
- peg$fail(peg$e50);
4162
+ peg$fail(peg$e51);
3973
4163
  }
3974
4164
  }
3975
4165
  if (s1 !== peg$FAILED) {
@@ -3982,7 +4172,7 @@ function peg$parse(input, options) {
3982
4172
  s5 = null;
3983
4173
  }
3984
4174
  peg$savedPos = s0;
3985
- s0 = peg$f46(s3, s5);
4175
+ s0 = peg$f47(s3, s5);
3986
4176
  } else {
3987
4177
  peg$currPos = s0;
3988
4178
  s0 = peg$FAILED;
@@ -3996,13 +4186,13 @@ function peg$parse(input, options) {
3996
4186
  function peg$parseIcon() {
3997
4187
  let s0, s1, s2, s3, s4, s5;
3998
4188
  s0 = peg$currPos;
3999
- if (input.substr(peg$currPos, 4) === peg$c48) {
4000
- s1 = peg$c48;
4189
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4190
+ s1 = peg$c49;
4001
4191
  peg$currPos += 4;
4002
4192
  } else {
4003
4193
  s1 = peg$FAILED;
4004
4194
  if (peg$silentFails === 0) {
4005
- peg$fail(peg$e51);
4195
+ peg$fail(peg$e52);
4006
4196
  }
4007
4197
  }
4008
4198
  if (s1 !== peg$FAILED) {
@@ -4015,7 +4205,7 @@ function peg$parse(input, options) {
4015
4205
  s5 = null;
4016
4206
  }
4017
4207
  peg$savedPos = s0;
4018
- s0 = peg$f47(s3, s5);
4208
+ s0 = peg$f48(s3, s5);
4019
4209
  } else {
4020
4210
  peg$currPos = s0;
4021
4211
  s0 = peg$FAILED;
@@ -4029,13 +4219,13 @@ function peg$parse(input, options) {
4029
4219
  function peg$parseTable() {
4030
4220
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4031
4221
  s0 = peg$currPos;
4032
- if (input.substr(peg$currPos, 5) === peg$c49) {
4033
- s1 = peg$c49;
4222
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4223
+ s1 = peg$c50;
4034
4224
  peg$currPos += 5;
4035
4225
  } else {
4036
4226
  s1 = peg$FAILED;
4037
4227
  if (peg$silentFails === 0) {
4038
- peg$fail(peg$e52);
4228
+ peg$fail(peg$e53);
4039
4229
  }
4040
4230
  }
4041
4231
  if (s1 !== peg$FAILED) {
@@ -4048,7 +4238,7 @@ function peg$parse(input, options) {
4048
4238
  s5 = null;
4049
4239
  }
4050
4240
  peg$savedPos = s0;
4051
- s0 = peg$f48(s3, s5);
4241
+ s0 = peg$f49(s3, s5);
4052
4242
  } else {
4053
4243
  peg$currPos = s0;
4054
4244
  s0 = peg$FAILED;
@@ -4059,13 +4249,13 @@ function peg$parse(input, options) {
4059
4249
  }
4060
4250
  if (s0 === peg$FAILED) {
4061
4251
  s0 = peg$currPos;
4062
- if (input.substr(peg$currPos, 5) === peg$c49) {
4063
- s1 = peg$c49;
4252
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4253
+ s1 = peg$c50;
4064
4254
  peg$currPos += 5;
4065
4255
  } else {
4066
4256
  s1 = peg$FAILED;
4067
4257
  if (peg$silentFails === 0) {
4068
- peg$fail(peg$e52);
4258
+ peg$fail(peg$e53);
4069
4259
  }
4070
4260
  }
4071
4261
  if (s1 !== peg$FAILED) {
@@ -4099,7 +4289,7 @@ function peg$parse(input, options) {
4099
4289
  }
4100
4290
  if (s9 !== peg$FAILED) {
4101
4291
  peg$savedPos = s0;
4102
- s0 = peg$f49(s3, s7);
4292
+ s0 = peg$f50(s3, s7);
4103
4293
  } else {
4104
4294
  peg$currPos = s0;
4105
4295
  s0 = peg$FAILED;
@@ -4119,12 +4309,12 @@ function peg$parse(input, options) {
4119
4309
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4120
4310
  s0 = peg$currPos;
4121
4311
  if (input.charCodeAt(peg$currPos) === 91) {
4122
- s1 = peg$c50;
4312
+ s1 = peg$c51;
4123
4313
  peg$currPos++;
4124
4314
  } else {
4125
4315
  s1 = peg$FAILED;
4126
4316
  if (peg$silentFails === 0) {
4127
- peg$fail(peg$e53);
4317
+ peg$fail(peg$e54);
4128
4318
  }
4129
4319
  }
4130
4320
  if (s1 !== peg$FAILED) {
@@ -4200,17 +4390,17 @@ function peg$parse(input, options) {
4200
4390
  }
4201
4391
  s7 = peg$parse_();
4202
4392
  if (input.charCodeAt(peg$currPos) === 93) {
4203
- s8 = peg$c51;
4393
+ s8 = peg$c52;
4204
4394
  peg$currPos++;
4205
4395
  } else {
4206
4396
  s8 = peg$FAILED;
4207
4397
  if (peg$silentFails === 0) {
4208
- peg$fail(peg$e54);
4398
+ peg$fail(peg$e55);
4209
4399
  }
4210
4400
  }
4211
4401
  if (s8 !== peg$FAILED) {
4212
4402
  peg$savedPos = s0;
4213
- s0 = peg$f50(s3, s5);
4403
+ s0 = peg$f51(s3, s5);
4214
4404
  } else {
4215
4405
  peg$currPos = s0;
4216
4406
  s0 = peg$FAILED;
@@ -4253,20 +4443,20 @@ function peg$parse(input, options) {
4253
4443
  }
4254
4444
  }
4255
4445
  peg$savedPos = s0;
4256
- s1 = peg$f51(s1);
4446
+ s1 = peg$f52(s1);
4257
4447
  s0 = s1;
4258
4448
  return s0;
4259
4449
  }
4260
4450
  function peg$parseTableRow() {
4261
4451
  let s0, s1, s2, s3;
4262
4452
  s0 = peg$currPos;
4263
- if (input.substr(peg$currPos, 7) === peg$c52) {
4264
- s1 = peg$c52;
4453
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4454
+ s1 = peg$c53;
4265
4455
  peg$currPos += 7;
4266
4456
  } else {
4267
4457
  s1 = peg$FAILED;
4268
4458
  if (peg$silentFails === 0) {
4269
- peg$fail(peg$e55);
4459
+ peg$fail(peg$e56);
4270
4460
  }
4271
4461
  }
4272
4462
  if (s1 !== peg$FAILED) {
@@ -4274,7 +4464,7 @@ function peg$parse(input, options) {
4274
4464
  s3 = peg$parseArray();
4275
4465
  if (s3 !== peg$FAILED) {
4276
4466
  peg$savedPos = s0;
4277
- s0 = peg$f52(s3);
4467
+ s0 = peg$f53(s3);
4278
4468
  } else {
4279
4469
  peg$currPos = s0;
4280
4470
  s0 = peg$FAILED;
@@ -4285,13 +4475,13 @@ function peg$parse(input, options) {
4285
4475
  }
4286
4476
  if (s0 === peg$FAILED) {
4287
4477
  s0 = peg$currPos;
4288
- if (input.substr(peg$currPos, 3) === peg$c24) {
4289
- s1 = peg$c24;
4478
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4479
+ s1 = peg$c25;
4290
4480
  peg$currPos += 3;
4291
4481
  } else {
4292
4482
  s1 = peg$FAILED;
4293
4483
  if (peg$silentFails === 0) {
4294
- peg$fail(peg$e27);
4484
+ peg$fail(peg$e28);
4295
4485
  }
4296
4486
  }
4297
4487
  if (s1 !== peg$FAILED) {
@@ -4299,7 +4489,7 @@ function peg$parse(input, options) {
4299
4489
  s3 = peg$parseArray();
4300
4490
  if (s3 !== peg$FAILED) {
4301
4491
  peg$savedPos = s0;
4302
- s0 = peg$f53(s3);
4492
+ s0 = peg$f54(s3);
4303
4493
  } else {
4304
4494
  peg$currPos = s0;
4305
4495
  s0 = peg$FAILED;
@@ -4313,7 +4503,7 @@ function peg$parse(input, options) {
4313
4503
  s1 = peg$parseComment();
4314
4504
  if (s1 !== peg$FAILED) {
4315
4505
  peg$savedPos = s0;
4316
- s1 = peg$f54();
4506
+ s1 = peg$f55();
4317
4507
  }
4318
4508
  s0 = s1;
4319
4509
  }
@@ -4323,13 +4513,13 @@ function peg$parse(input, options) {
4323
4513
  function peg$parseList() {
4324
4514
  let s0, s1, s2, s3, s4, s5, s6, s7;
4325
4515
  s0 = peg$currPos;
4326
- if (input.substr(peg$currPos, 4) === peg$c53) {
4327
- s1 = peg$c53;
4516
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4517
+ s1 = peg$c54;
4328
4518
  peg$currPos += 4;
4329
4519
  } else {
4330
4520
  s1 = peg$FAILED;
4331
4521
  if (peg$silentFails === 0) {
4332
- peg$fail(peg$e56);
4522
+ peg$fail(peg$e57);
4333
4523
  }
4334
4524
  }
4335
4525
  if (s1 !== peg$FAILED) {
@@ -4349,7 +4539,7 @@ function peg$parse(input, options) {
4349
4539
  s7 = null;
4350
4540
  }
4351
4541
  peg$savedPos = s0;
4352
- s0 = peg$f55(s3, s5, s7);
4542
+ s0 = peg$f56(s3, s5, s7);
4353
4543
  } else {
4354
4544
  peg$currPos = s0;
4355
4545
  s0 = peg$FAILED;
@@ -4405,7 +4595,7 @@ function peg$parse(input, options) {
4405
4595
  }
4406
4596
  if (s4 !== peg$FAILED) {
4407
4597
  peg$savedPos = s0;
4408
- s0 = peg$f56(s3);
4598
+ s0 = peg$f57(s3);
4409
4599
  } else {
4410
4600
  peg$currPos = s0;
4411
4601
  s0 = peg$FAILED;
@@ -4419,13 +4609,13 @@ function peg$parse(input, options) {
4419
4609
  function peg$parseListItem() {
4420
4610
  let s0, s1, s2, s3, s4, s5, s6, s7;
4421
4611
  s0 = peg$currPos;
4422
- if (input.substr(peg$currPos, 4) === peg$c54) {
4423
- s1 = peg$c54;
4612
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4613
+ s1 = peg$c55;
4424
4614
  peg$currPos += 4;
4425
4615
  } else {
4426
4616
  s1 = peg$FAILED;
4427
4617
  if (peg$silentFails === 0) {
4428
- peg$fail(peg$e57);
4618
+ peg$fail(peg$e58);
4429
4619
  }
4430
4620
  }
4431
4621
  if (s1 !== peg$FAILED) {
@@ -4443,7 +4633,7 @@ function peg$parse(input, options) {
4443
4633
  s7 = null;
4444
4634
  }
4445
4635
  peg$savedPos = s0;
4446
- s0 = peg$f57(s3, s5, s7);
4636
+ s0 = peg$f58(s3, s5, s7);
4447
4637
  } else {
4448
4638
  peg$currPos = s0;
4449
4639
  s0 = peg$FAILED;
@@ -4457,7 +4647,7 @@ function peg$parse(input, options) {
4457
4647
  s1 = peg$parseComment();
4458
4648
  if (s1 !== peg$FAILED) {
4459
4649
  peg$savedPos = s0;
4460
- s1 = peg$f58();
4650
+ s1 = peg$f59();
4461
4651
  }
4462
4652
  s0 = s1;
4463
4653
  }
@@ -4466,13 +4656,13 @@ function peg$parse(input, options) {
4466
4656
  function peg$parseAlert() {
4467
4657
  let s0, s1, s2, s3, s4, s5;
4468
4658
  s0 = peg$currPos;
4469
- if (input.substr(peg$currPos, 5) === peg$c55) {
4470
- s1 = peg$c55;
4659
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4660
+ s1 = peg$c56;
4471
4661
  peg$currPos += 5;
4472
4662
  } else {
4473
4663
  s1 = peg$FAILED;
4474
4664
  if (peg$silentFails === 0) {
4475
- peg$fail(peg$e58);
4665
+ peg$fail(peg$e59);
4476
4666
  }
4477
4667
  }
4478
4668
  if (s1 !== peg$FAILED) {
@@ -4485,7 +4675,7 @@ function peg$parse(input, options) {
4485
4675
  s5 = null;
4486
4676
  }
4487
4677
  peg$savedPos = s0;
4488
- s0 = peg$f59(s3, s5);
4678
+ s0 = peg$f60(s3, s5);
4489
4679
  } else {
4490
4680
  peg$currPos = s0;
4491
4681
  s0 = peg$FAILED;
@@ -4499,13 +4689,13 @@ function peg$parse(input, options) {
4499
4689
  function peg$parseToast() {
4500
4690
  let s0, s1, s2, s3, s4, s5;
4501
4691
  s0 = peg$currPos;
4502
- if (input.substr(peg$currPos, 5) === peg$c56) {
4503
- s1 = peg$c56;
4692
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4693
+ s1 = peg$c57;
4504
4694
  peg$currPos += 5;
4505
4695
  } else {
4506
4696
  s1 = peg$FAILED;
4507
4697
  if (peg$silentFails === 0) {
4508
- peg$fail(peg$e59);
4698
+ peg$fail(peg$e60);
4509
4699
  }
4510
4700
  }
4511
4701
  if (s1 !== peg$FAILED) {
@@ -4518,7 +4708,7 @@ function peg$parse(input, options) {
4518
4708
  s5 = null;
4519
4709
  }
4520
4710
  peg$savedPos = s0;
4521
- s0 = peg$f60(s3, s5);
4711
+ s0 = peg$f61(s3, s5);
4522
4712
  } else {
4523
4713
  peg$currPos = s0;
4524
4714
  s0 = peg$FAILED;
@@ -4532,13 +4722,13 @@ function peg$parse(input, options) {
4532
4722
  function peg$parseProgress() {
4533
4723
  let s0, s1, s2, s3;
4534
4724
  s0 = peg$currPos;
4535
- if (input.substr(peg$currPos, 8) === peg$c57) {
4536
- s1 = peg$c57;
4725
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4726
+ s1 = peg$c58;
4537
4727
  peg$currPos += 8;
4538
4728
  } else {
4539
4729
  s1 = peg$FAILED;
4540
4730
  if (peg$silentFails === 0) {
4541
- peg$fail(peg$e60);
4731
+ peg$fail(peg$e61);
4542
4732
  }
4543
4733
  }
4544
4734
  if (s1 !== peg$FAILED) {
@@ -4548,7 +4738,7 @@ function peg$parse(input, options) {
4548
4738
  s3 = null;
4549
4739
  }
4550
4740
  peg$savedPos = s0;
4551
- s0 = peg$f61(s3);
4741
+ s0 = peg$f62(s3);
4552
4742
  } else {
4553
4743
  peg$currPos = s0;
4554
4744
  s0 = peg$FAILED;
@@ -4558,13 +4748,13 @@ function peg$parse(input, options) {
4558
4748
  function peg$parseSpinner() {
4559
4749
  let s0, s1, s2, s3, s4, s5;
4560
4750
  s0 = peg$currPos;
4561
- if (input.substr(peg$currPos, 7) === peg$c58) {
4562
- s1 = peg$c58;
4751
+ if (input.substr(peg$currPos, 7) === peg$c59) {
4752
+ s1 = peg$c59;
4563
4753
  peg$currPos += 7;
4564
4754
  } else {
4565
4755
  s1 = peg$FAILED;
4566
4756
  if (peg$silentFails === 0) {
4567
- peg$fail(peg$e61);
4757
+ peg$fail(peg$e62);
4568
4758
  }
4569
4759
  }
4570
4760
  if (s1 !== peg$FAILED) {
@@ -4579,7 +4769,7 @@ function peg$parse(input, options) {
4579
4769
  s5 = null;
4580
4770
  }
4581
4771
  peg$savedPos = s0;
4582
- s0 = peg$f62(s3, s5);
4772
+ s0 = peg$f63(s3, s5);
4583
4773
  } else {
4584
4774
  peg$currPos = s0;
4585
4775
  s0 = peg$FAILED;
@@ -4589,13 +4779,13 @@ function peg$parse(input, options) {
4589
4779
  function peg$parseTooltip() {
4590
4780
  let s0, s1, s2, s3, s4, s5;
4591
4781
  s0 = peg$currPos;
4592
- if (input.substr(peg$currPos, 7) === peg$c59) {
4593
- s1 = peg$c59;
4782
+ if (input.substr(peg$currPos, 7) === peg$c60) {
4783
+ s1 = peg$c60;
4594
4784
  peg$currPos += 7;
4595
4785
  } else {
4596
4786
  s1 = peg$FAILED;
4597
4787
  if (peg$silentFails === 0) {
4598
- peg$fail(peg$e62);
4788
+ peg$fail(peg$e63);
4599
4789
  }
4600
4790
  }
4601
4791
  if (s1 !== peg$FAILED) {
@@ -4608,7 +4798,7 @@ function peg$parse(input, options) {
4608
4798
  s5 = null;
4609
4799
  }
4610
4800
  peg$savedPos = s0;
4611
- s0 = peg$f63(s3, s5);
4801
+ s0 = peg$f64(s3, s5);
4612
4802
  } else {
4613
4803
  peg$currPos = s0;
4614
4804
  s0 = peg$FAILED;
@@ -4622,13 +4812,13 @@ function peg$parse(input, options) {
4622
4812
  function peg$parsePopover() {
4623
4813
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4624
4814
  s0 = peg$currPos;
4625
- if (input.substr(peg$currPos, 7) === peg$c60) {
4626
- s1 = peg$c60;
4815
+ if (input.substr(peg$currPos, 7) === peg$c61) {
4816
+ s1 = peg$c61;
4627
4817
  peg$currPos += 7;
4628
4818
  } else {
4629
4819
  s1 = peg$FAILED;
4630
4820
  if (peg$silentFails === 0) {
4631
- peg$fail(peg$e63);
4821
+ peg$fail(peg$e64);
4632
4822
  }
4633
4823
  }
4634
4824
  if (s1 !== peg$FAILED) {
@@ -4668,7 +4858,7 @@ function peg$parse(input, options) {
4668
4858
  }
4669
4859
  if (s11 !== peg$FAILED) {
4670
4860
  peg$savedPos = s0;
4671
- s0 = peg$f64(s3, s5, s9);
4861
+ s0 = peg$f65(s3, s5, s9);
4672
4862
  } else {
4673
4863
  peg$currPos = s0;
4674
4864
  s0 = peg$FAILED;
@@ -4690,13 +4880,13 @@ function peg$parse(input, options) {
4690
4880
  function peg$parseDropdown() {
4691
4881
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4692
4882
  s0 = peg$currPos;
4693
- if (input.substr(peg$currPos, 8) === peg$c61) {
4694
- s1 = peg$c61;
4883
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4884
+ s1 = peg$c62;
4695
4885
  peg$currPos += 8;
4696
4886
  } else {
4697
4887
  s1 = peg$FAILED;
4698
4888
  if (peg$silentFails === 0) {
4699
- peg$fail(peg$e64);
4889
+ peg$fail(peg$e65);
4700
4890
  }
4701
4891
  }
4702
4892
  if (s1 !== peg$FAILED) {
@@ -4709,7 +4899,7 @@ function peg$parse(input, options) {
4709
4899
  s5 = null;
4710
4900
  }
4711
4901
  peg$savedPos = s0;
4712
- s0 = peg$f65(s3, s5);
4902
+ s0 = peg$f66(s3, s5);
4713
4903
  } else {
4714
4904
  peg$currPos = s0;
4715
4905
  s0 = peg$FAILED;
@@ -4720,13 +4910,13 @@ function peg$parse(input, options) {
4720
4910
  }
4721
4911
  if (s0 === peg$FAILED) {
4722
4912
  s0 = peg$currPos;
4723
- if (input.substr(peg$currPos, 8) === peg$c61) {
4724
- s1 = peg$c61;
4913
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4914
+ s1 = peg$c62;
4725
4915
  peg$currPos += 8;
4726
4916
  } else {
4727
4917
  s1 = peg$FAILED;
4728
4918
  if (peg$silentFails === 0) {
4729
- peg$fail(peg$e64);
4919
+ peg$fail(peg$e65);
4730
4920
  }
4731
4921
  }
4732
4922
  if (s1 !== peg$FAILED) {
@@ -4760,7 +4950,7 @@ function peg$parse(input, options) {
4760
4950
  }
4761
4951
  if (s9 !== peg$FAILED) {
4762
4952
  peg$savedPos = s0;
4763
- s0 = peg$f66(s3, s7);
4953
+ s0 = peg$f67(s3, s7);
4764
4954
  } else {
4765
4955
  peg$currPos = s0;
4766
4956
  s0 = peg$FAILED;
@@ -4804,20 +4994,20 @@ function peg$parse(input, options) {
4804
4994
  }
4805
4995
  }
4806
4996
  peg$savedPos = s0;
4807
- s1 = peg$f67(s1);
4997
+ s1 = peg$f68(s1);
4808
4998
  s0 = s1;
4809
4999
  return s0;
4810
5000
  }
4811
5001
  function peg$parseDropdownItem() {
4812
5002
  let s0, s1, s2, s3, s4, s5;
4813
5003
  s0 = peg$currPos;
4814
- if (input.substr(peg$currPos, 4) === peg$c54) {
4815
- s1 = peg$c54;
5004
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5005
+ s1 = peg$c55;
4816
5006
  peg$currPos += 4;
4817
5007
  } else {
4818
5008
  s1 = peg$FAILED;
4819
5009
  if (peg$silentFails === 0) {
4820
- peg$fail(peg$e57);
5010
+ peg$fail(peg$e58);
4821
5011
  }
4822
5012
  }
4823
5013
  if (s1 !== peg$FAILED) {
@@ -4830,7 +5020,7 @@ function peg$parse(input, options) {
4830
5020
  s5 = null;
4831
5021
  }
4832
5022
  peg$savedPos = s0;
4833
- s0 = peg$f68(s3, s5);
5023
+ s0 = peg$f69(s3, s5);
4834
5024
  } else {
4835
5025
  peg$currPos = s0;
4836
5026
  s0 = peg$FAILED;
@@ -4841,18 +5031,18 @@ function peg$parse(input, options) {
4841
5031
  }
4842
5032
  if (s0 === peg$FAILED) {
4843
5033
  s0 = peg$currPos;
4844
- if (input.substr(peg$currPos, 7) === peg$c62) {
4845
- s1 = peg$c62;
5034
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5035
+ s1 = peg$c63;
4846
5036
  peg$currPos += 7;
4847
5037
  } else {
4848
5038
  s1 = peg$FAILED;
4849
5039
  if (peg$silentFails === 0) {
4850
- peg$fail(peg$e65);
5040
+ peg$fail(peg$e66);
4851
5041
  }
4852
5042
  }
4853
5043
  if (s1 !== peg$FAILED) {
4854
5044
  peg$savedPos = s0;
4855
- s1 = peg$f69();
5045
+ s1 = peg$f70();
4856
5046
  }
4857
5047
  s0 = s1;
4858
5048
  if (s0 === peg$FAILED) {
@@ -4860,7 +5050,7 @@ function peg$parse(input, options) {
4860
5050
  s1 = peg$parseComment();
4861
5051
  if (s1 !== peg$FAILED) {
4862
5052
  peg$savedPos = s0;
4863
- s1 = peg$f70();
5053
+ s1 = peg$f71();
4864
5054
  }
4865
5055
  s0 = s1;
4866
5056
  }
@@ -4870,13 +5060,13 @@ function peg$parse(input, options) {
4870
5060
  function peg$parseNav() {
4871
5061
  let s0, s1, s2, s3, s4, s5, s6, s7;
4872
5062
  s0 = peg$currPos;
4873
- if (input.substr(peg$currPos, 3) === peg$c63) {
4874
- s1 = peg$c63;
5063
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5064
+ s1 = peg$c64;
4875
5065
  peg$currPos += 3;
4876
5066
  } else {
4877
5067
  s1 = peg$FAILED;
4878
5068
  if (peg$silentFails === 0) {
4879
- peg$fail(peg$e66);
5069
+ peg$fail(peg$e67);
4880
5070
  }
4881
5071
  }
4882
5072
  if (s1 !== peg$FAILED) {
@@ -4896,7 +5086,7 @@ function peg$parse(input, options) {
4896
5086
  s7 = null;
4897
5087
  }
4898
5088
  peg$savedPos = s0;
4899
- s0 = peg$f71(s3, s5, s7);
5089
+ s0 = peg$f72(s3, s5, s7);
4900
5090
  } else {
4901
5091
  peg$currPos = s0;
4902
5092
  s0 = peg$FAILED;
@@ -4952,7 +5142,7 @@ function peg$parse(input, options) {
4952
5142
  }
4953
5143
  if (s4 !== peg$FAILED) {
4954
5144
  peg$savedPos = s0;
4955
- s0 = peg$f72(s3);
5145
+ s0 = peg$f73(s3);
4956
5146
  } else {
4957
5147
  peg$currPos = s0;
4958
5148
  s0 = peg$FAILED;
@@ -4970,19 +5160,19 @@ function peg$parse(input, options) {
4970
5160
  s0 = peg$parseNavItem();
4971
5161
  if (s0 === peg$FAILED) {
4972
5162
  s0 = peg$currPos;
4973
- if (input.substr(peg$currPos, 7) === peg$c62) {
4974
- s1 = peg$c62;
5163
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5164
+ s1 = peg$c63;
4975
5165
  peg$currPos += 7;
4976
5166
  } else {
4977
5167
  s1 = peg$FAILED;
4978
5168
  if (peg$silentFails === 0) {
4979
- peg$fail(peg$e65);
5169
+ peg$fail(peg$e66);
4980
5170
  }
4981
5171
  }
4982
5172
  if (s1 !== peg$FAILED) {
4983
5173
  s2 = peg$parse_();
4984
5174
  peg$savedPos = s0;
4985
- s0 = peg$f73();
5175
+ s0 = peg$f74();
4986
5176
  } else {
4987
5177
  peg$currPos = s0;
4988
5178
  s0 = peg$FAILED;
@@ -4992,7 +5182,7 @@ function peg$parse(input, options) {
4992
5182
  s1 = peg$parseComment();
4993
5183
  if (s1 !== peg$FAILED) {
4994
5184
  peg$savedPos = s0;
4995
- s1 = peg$f74();
5185
+ s1 = peg$f75();
4996
5186
  }
4997
5187
  s0 = s1;
4998
5188
  }
@@ -5003,13 +5193,13 @@ function peg$parse(input, options) {
5003
5193
  function peg$parseNavGroup() {
5004
5194
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5005
5195
  s0 = peg$currPos;
5006
- if (input.substr(peg$currPos, 5) === peg$c64) {
5007
- s1 = peg$c64;
5196
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5197
+ s1 = peg$c65;
5008
5198
  peg$currPos += 5;
5009
5199
  } else {
5010
5200
  s1 = peg$FAILED;
5011
5201
  if (peg$silentFails === 0) {
5012
- peg$fail(peg$e67);
5202
+ peg$fail(peg$e68);
5013
5203
  }
5014
5204
  }
5015
5205
  if (s1 !== peg$FAILED) {
@@ -5068,7 +5258,7 @@ function peg$parse(input, options) {
5068
5258
  }
5069
5259
  if (s10 !== peg$FAILED) {
5070
5260
  peg$savedPos = s0;
5071
- s0 = peg$f75(s3, s5, s9);
5261
+ s0 = peg$f76(s3, s5, s9);
5072
5262
  } else {
5073
5263
  peg$currPos = s0;
5074
5264
  s0 = peg$FAILED;
@@ -5092,19 +5282,19 @@ function peg$parse(input, options) {
5092
5282
  s0 = peg$parseNavItem();
5093
5283
  if (s0 === peg$FAILED) {
5094
5284
  s0 = peg$currPos;
5095
- if (input.substr(peg$currPos, 7) === peg$c62) {
5096
- s1 = peg$c62;
5285
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5286
+ s1 = peg$c63;
5097
5287
  peg$currPos += 7;
5098
5288
  } else {
5099
5289
  s1 = peg$FAILED;
5100
5290
  if (peg$silentFails === 0) {
5101
- peg$fail(peg$e65);
5291
+ peg$fail(peg$e66);
5102
5292
  }
5103
5293
  }
5104
5294
  if (s1 !== peg$FAILED) {
5105
5295
  s2 = peg$parse_();
5106
5296
  peg$savedPos = s0;
5107
- s0 = peg$f76();
5297
+ s0 = peg$f77();
5108
5298
  } else {
5109
5299
  peg$currPos = s0;
5110
5300
  s0 = peg$FAILED;
@@ -5114,7 +5304,7 @@ function peg$parse(input, options) {
5114
5304
  s1 = peg$parseComment();
5115
5305
  if (s1 !== peg$FAILED) {
5116
5306
  peg$savedPos = s0;
5117
- s1 = peg$f77();
5307
+ s1 = peg$f78();
5118
5308
  }
5119
5309
  s0 = s1;
5120
5310
  }
@@ -5124,13 +5314,13 @@ function peg$parse(input, options) {
5124
5314
  function peg$parseNavItem() {
5125
5315
  let s0, s1, s2, s3, s4, s5;
5126
5316
  s0 = peg$currPos;
5127
- if (input.substr(peg$currPos, 4) === peg$c54) {
5128
- s1 = peg$c54;
5317
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5318
+ s1 = peg$c55;
5129
5319
  peg$currPos += 4;
5130
5320
  } else {
5131
5321
  s1 = peg$FAILED;
5132
5322
  if (peg$silentFails === 0) {
5133
- peg$fail(peg$e57);
5323
+ peg$fail(peg$e58);
5134
5324
  }
5135
5325
  }
5136
5326
  if (s1 !== peg$FAILED) {
@@ -5143,7 +5333,7 @@ function peg$parse(input, options) {
5143
5333
  s5 = null;
5144
5334
  }
5145
5335
  peg$savedPos = s0;
5146
- s0 = peg$f78(s3, s5);
5336
+ s0 = peg$f79(s3, s5);
5147
5337
  } else {
5148
5338
  peg$currPos = s0;
5149
5339
  s0 = peg$FAILED;
@@ -5157,13 +5347,13 @@ function peg$parse(input, options) {
5157
5347
  function peg$parseTabs() {
5158
5348
  let s0, s1, s2, s3, s4, s5, s6, s7;
5159
5349
  s0 = peg$currPos;
5160
- if (input.substr(peg$currPos, 4) === peg$c65) {
5161
- s1 = peg$c65;
5350
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5351
+ s1 = peg$c66;
5162
5352
  peg$currPos += 4;
5163
5353
  } else {
5164
5354
  s1 = peg$FAILED;
5165
5355
  if (peg$silentFails === 0) {
5166
- peg$fail(peg$e68);
5356
+ peg$fail(peg$e69);
5167
5357
  }
5168
5358
  }
5169
5359
  if (s1 !== peg$FAILED) {
@@ -5183,7 +5373,7 @@ function peg$parse(input, options) {
5183
5373
  s7 = null;
5184
5374
  }
5185
5375
  peg$savedPos = s0;
5186
- s0 = peg$f79(s3, s5, s7);
5376
+ s0 = peg$f80(s3, s5, s7);
5187
5377
  } else {
5188
5378
  peg$currPos = s0;
5189
5379
  s0 = peg$FAILED;
@@ -5239,7 +5429,7 @@ function peg$parse(input, options) {
5239
5429
  }
5240
5430
  if (s4 !== peg$FAILED) {
5241
5431
  peg$savedPos = s0;
5242
- s0 = peg$f80(s3);
5432
+ s0 = peg$f81(s3);
5243
5433
  } else {
5244
5434
  peg$currPos = s0;
5245
5435
  s0 = peg$FAILED;
@@ -5253,13 +5443,13 @@ function peg$parse(input, options) {
5253
5443
  function peg$parseTabItem() {
5254
5444
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5255
5445
  s0 = peg$currPos;
5256
- if (input.substr(peg$currPos, 3) === peg$c66) {
5257
- s1 = peg$c66;
5446
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5447
+ s1 = peg$c67;
5258
5448
  peg$currPos += 3;
5259
5449
  } else {
5260
5450
  s1 = peg$FAILED;
5261
5451
  if (peg$silentFails === 0) {
5262
- peg$fail(peg$e69);
5452
+ peg$fail(peg$e70);
5263
5453
  }
5264
5454
  }
5265
5455
  if (s1 !== peg$FAILED) {
@@ -5297,7 +5487,7 @@ function peg$parse(input, options) {
5297
5487
  }
5298
5488
  if (s11 !== peg$FAILED) {
5299
5489
  peg$savedPos = s0;
5300
- s0 = peg$f81(s3, s5, s9);
5490
+ s0 = peg$f82(s3, s5, s9);
5301
5491
  } else {
5302
5492
  peg$currPos = s0;
5303
5493
  s0 = peg$FAILED;
@@ -5323,7 +5513,7 @@ function peg$parse(input, options) {
5323
5513
  s1 = peg$parseComment();
5324
5514
  if (s1 !== peg$FAILED) {
5325
5515
  peg$savedPos = s0;
5326
- s1 = peg$f82();
5516
+ s1 = peg$f83();
5327
5517
  }
5328
5518
  s0 = s1;
5329
5519
  }
@@ -5332,13 +5522,13 @@ function peg$parse(input, options) {
5332
5522
  function peg$parseBreadcrumb() {
5333
5523
  let s0, s1, s2, s3, s4, s5;
5334
5524
  s0 = peg$currPos;
5335
- if (input.substr(peg$currPos, 10) === peg$c67) {
5336
- s1 = peg$c67;
5525
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5526
+ s1 = peg$c68;
5337
5527
  peg$currPos += 10;
5338
5528
  } else {
5339
5529
  s1 = peg$FAILED;
5340
5530
  if (peg$silentFails === 0) {
5341
- peg$fail(peg$e70);
5531
+ peg$fail(peg$e71);
5342
5532
  }
5343
5533
  }
5344
5534
  if (s1 !== peg$FAILED) {
@@ -5351,7 +5541,7 @@ function peg$parse(input, options) {
5351
5541
  s5 = null;
5352
5542
  }
5353
5543
  peg$savedPos = s0;
5354
- s0 = peg$f83(s3, s5);
5544
+ s0 = peg$f84(s3, s5);
5355
5545
  } else {
5356
5546
  peg$currPos = s0;
5357
5547
  s0 = peg$FAILED;
@@ -5365,13 +5555,13 @@ function peg$parse(input, options) {
5365
5555
  function peg$parseDivider() {
5366
5556
  let s0, s1, s2, s3;
5367
5557
  s0 = peg$currPos;
5368
- if (input.substr(peg$currPos, 7) === peg$c62) {
5369
- s1 = peg$c62;
5558
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5559
+ s1 = peg$c63;
5370
5560
  peg$currPos += 7;
5371
5561
  } else {
5372
5562
  s1 = peg$FAILED;
5373
5563
  if (peg$silentFails === 0) {
5374
- peg$fail(peg$e65);
5564
+ peg$fail(peg$e66);
5375
5565
  }
5376
5566
  }
5377
5567
  if (s1 !== peg$FAILED) {
@@ -5381,7 +5571,7 @@ function peg$parse(input, options) {
5381
5571
  s3 = null;
5382
5572
  }
5383
5573
  peg$savedPos = s0;
5384
- s0 = peg$f84(s3);
5574
+ s0 = peg$f85(s3);
5385
5575
  } else {
5386
5576
  peg$currPos = s0;
5387
5577
  s0 = peg$FAILED;
@@ -5391,13 +5581,13 @@ function peg$parse(input, options) {
5391
5581
  function peg$parseMarker() {
5392
5582
  let s0, s1, s2, s3, s4, s5;
5393
5583
  s0 = peg$currPos;
5394
- if (input.substr(peg$currPos, 6) === peg$c68) {
5395
- s1 = peg$c68;
5584
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5585
+ s1 = peg$c69;
5396
5586
  peg$currPos += 6;
5397
5587
  } else {
5398
5588
  s1 = peg$FAILED;
5399
5589
  if (peg$silentFails === 0) {
5400
- peg$fail(peg$e71);
5590
+ peg$fail(peg$e72);
5401
5591
  }
5402
5592
  }
5403
5593
  if (s1 !== peg$FAILED) {
@@ -5410,7 +5600,7 @@ function peg$parse(input, options) {
5410
5600
  s5 = null;
5411
5601
  }
5412
5602
  peg$savedPos = s0;
5413
- s0 = peg$f85(s3, s5);
5603
+ s0 = peg$f86(s3, s5);
5414
5604
  } else {
5415
5605
  peg$currPos = s0;
5416
5606
  s0 = peg$FAILED;
@@ -5424,13 +5614,13 @@ function peg$parse(input, options) {
5424
5614
  function peg$parseAnnotations() {
5425
5615
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5426
5616
  s0 = peg$currPos;
5427
- if (input.substr(peg$currPos, 11) === peg$c69) {
5428
- s1 = peg$c69;
5617
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5618
+ s1 = peg$c70;
5429
5619
  peg$currPos += 11;
5430
5620
  } else {
5431
5621
  s1 = peg$FAILED;
5432
5622
  if (peg$silentFails === 0) {
5433
- peg$fail(peg$e72);
5623
+ peg$fail(peg$e73);
5434
5624
  }
5435
5625
  }
5436
5626
  if (s1 !== peg$FAILED) {
@@ -5464,7 +5654,7 @@ function peg$parse(input, options) {
5464
5654
  }
5465
5655
  if (s9 !== peg$FAILED) {
5466
5656
  peg$savedPos = s0;
5467
- s0 = peg$f86(s3, s7);
5657
+ s0 = peg$f87(s3, s7);
5468
5658
  } else {
5469
5659
  peg$currPos = s0;
5470
5660
  s0 = peg$FAILED;
@@ -5507,20 +5697,20 @@ function peg$parse(input, options) {
5507
5697
  }
5508
5698
  }
5509
5699
  peg$savedPos = s0;
5510
- s1 = peg$f87(s1);
5700
+ s1 = peg$f88(s1);
5511
5701
  s0 = s1;
5512
5702
  return s0;
5513
5703
  }
5514
5704
  function peg$parseAnnotationItem() {
5515
5705
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5516
5706
  s0 = peg$currPos;
5517
- if (input.substr(peg$currPos, 4) === peg$c54) {
5518
- s1 = peg$c54;
5707
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5708
+ s1 = peg$c55;
5519
5709
  peg$currPos += 4;
5520
5710
  } else {
5521
5711
  s1 = peg$FAILED;
5522
5712
  if (peg$silentFails === 0) {
5523
- peg$fail(peg$e57);
5713
+ peg$fail(peg$e58);
5524
5714
  }
5525
5715
  }
5526
5716
  if (s1 !== peg$FAILED) {
@@ -5561,7 +5751,7 @@ function peg$parse(input, options) {
5561
5751
  }
5562
5752
  if (s13 !== peg$FAILED) {
5563
5753
  peg$savedPos = s0;
5564
- s0 = peg$f88(s3, s5, s7, s11);
5754
+ s0 = peg$f89(s3, s5, s7, s11);
5565
5755
  } else {
5566
5756
  peg$currPos = s0;
5567
5757
  s0 = peg$FAILED;
@@ -5588,13 +5778,13 @@ function peg$parse(input, options) {
5588
5778
  }
5589
5779
  if (s0 === peg$FAILED) {
5590
5780
  s0 = peg$currPos;
5591
- if (input.substr(peg$currPos, 4) === peg$c54) {
5592
- s1 = peg$c54;
5781
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5782
+ s1 = peg$c55;
5593
5783
  peg$currPos += 4;
5594
5784
  } else {
5595
5785
  s1 = peg$FAILED;
5596
5786
  if (peg$silentFails === 0) {
5597
- peg$fail(peg$e57);
5787
+ peg$fail(peg$e58);
5598
5788
  }
5599
5789
  }
5600
5790
  if (s1 !== peg$FAILED) {
@@ -5610,7 +5800,7 @@ function peg$parse(input, options) {
5610
5800
  s7 = null;
5611
5801
  }
5612
5802
  peg$savedPos = s0;
5613
- s0 = peg$f89(s3, s5, s7);
5803
+ s0 = peg$f90(s3, s5, s7);
5614
5804
  } else {
5615
5805
  peg$currPos = s0;
5616
5806
  s0 = peg$FAILED;
@@ -5628,7 +5818,7 @@ function peg$parse(input, options) {
5628
5818
  s1 = peg$parseComment();
5629
5819
  if (s1 !== peg$FAILED) {
5630
5820
  peg$savedPos = s0;
5631
- s1 = peg$f90();
5821
+ s1 = peg$f91();
5632
5822
  }
5633
5823
  s0 = s1;
5634
5824
  }
@@ -5646,7 +5836,7 @@ function peg$parse(input, options) {
5646
5836
  } else {
5647
5837
  s2 = peg$FAILED;
5648
5838
  if (peg$silentFails === 0) {
5649
- peg$fail(peg$e74);
5839
+ peg$fail(peg$e75);
5650
5840
  }
5651
5841
  }
5652
5842
  if (s2 !== peg$FAILED) {
@@ -5658,7 +5848,7 @@ function peg$parse(input, options) {
5658
5848
  } else {
5659
5849
  s2 = peg$FAILED;
5660
5850
  if (peg$silentFails === 0) {
5661
- peg$fail(peg$e74);
5851
+ peg$fail(peg$e75);
5662
5852
  }
5663
5853
  }
5664
5854
  }
@@ -5667,14 +5857,14 @@ function peg$parse(input, options) {
5667
5857
  }
5668
5858
  if (s1 !== peg$FAILED) {
5669
5859
  peg$savedPos = s0;
5670
- s1 = peg$f91(s1);
5860
+ s1 = peg$f92(s1);
5671
5861
  }
5672
5862
  s0 = s1;
5673
5863
  peg$silentFails--;
5674
5864
  if (s0 === peg$FAILED) {
5675
5865
  s1 = peg$FAILED;
5676
5866
  if (peg$silentFails === 0) {
5677
- peg$fail(peg$e73);
5867
+ peg$fail(peg$e74);
5678
5868
  }
5679
5869
  }
5680
5870
  return s0;
@@ -5694,7 +5884,7 @@ function peg$parse(input, options) {
5694
5884
  }
5695
5885
  if (s1 !== peg$FAILED) {
5696
5886
  peg$savedPos = s0;
5697
- s1 = peg$f92(s1);
5887
+ s1 = peg$f93(s1);
5698
5888
  }
5699
5889
  s0 = s1;
5700
5890
  return s0;
@@ -5703,13 +5893,13 @@ function peg$parse(input, options) {
5703
5893
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5704
5894
  s0 = peg$currPos;
5705
5895
  s1 = peg$parse_();
5706
- if (input.substr(peg$currPos, 2) === peg$c70) {
5707
- s2 = peg$c70;
5896
+ if (input.substr(peg$currPos, 2) === peg$c71) {
5897
+ s2 = peg$c71;
5708
5898
  peg$currPos += 2;
5709
5899
  } else {
5710
5900
  s2 = peg$FAILED;
5711
5901
  if (peg$silentFails === 0) {
5712
- peg$fail(peg$e75);
5902
+ peg$fail(peg$e76);
5713
5903
  }
5714
5904
  }
5715
5905
  if (s2 !== peg$FAILED) {
@@ -5764,7 +5954,7 @@ function peg$parse(input, options) {
5764
5954
  }
5765
5955
  if (s13 !== peg$FAILED) {
5766
5956
  peg$savedPos = s0;
5767
- s0 = peg$f93(s7, s11);
5957
+ s0 = peg$f94(s7, s11);
5768
5958
  } else {
5769
5959
  peg$currPos = s0;
5770
5960
  s0 = peg$FAILED;
@@ -5813,7 +6003,7 @@ function peg$parse(input, options) {
5813
6003
  s6 = peg$parseAttributeValue();
5814
6004
  if (s6 !== peg$FAILED) {
5815
6005
  peg$savedPos = s0;
5816
- s0 = peg$f94(s2, s6);
6006
+ s0 = peg$f95(s2, s6);
5817
6007
  } else {
5818
6008
  peg$currPos = s0;
5819
6009
  s0 = peg$FAILED;
@@ -5845,7 +6035,7 @@ function peg$parse(input, options) {
5845
6035
  } else {
5846
6036
  s6 = peg$FAILED;
5847
6037
  if (peg$silentFails === 0) {
5848
- peg$fail(peg$e76);
6038
+ peg$fail(peg$e77);
5849
6039
  }
5850
6040
  }
5851
6041
  if (s6 === peg$FAILED) {
@@ -5908,7 +6098,7 @@ function peg$parse(input, options) {
5908
6098
  }
5909
6099
  if (s3 !== peg$FAILED) {
5910
6100
  peg$savedPos = s0;
5911
- s0 = peg$f95(s2);
6101
+ s0 = peg$f96(s2);
5912
6102
  } else {
5913
6103
  peg$currPos = s0;
5914
6104
  s0 = peg$FAILED;
@@ -5938,7 +6128,7 @@ function peg$parse(input, options) {
5938
6128
  s2 = peg$parseIdentifier();
5939
6129
  if (s2 !== peg$FAILED) {
5940
6130
  peg$savedPos = s0;
5941
- s0 = peg$f96(s2);
6131
+ s0 = peg$f97(s2);
5942
6132
  } else {
5943
6133
  peg$currPos = s0;
5944
6134
  s0 = peg$FAILED;
@@ -5962,503 +6152,514 @@ function peg$parse(input, options) {
5962
6152
  }
5963
6153
  }
5964
6154
  if (s1 === peg$FAILED) {
5965
- if (input.substr(peg$currPos, 6) === peg$c20) {
5966
- s1 = peg$c20;
6155
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6156
+ s1 = peg$c21;
5967
6157
  peg$currPos += 6;
5968
6158
  } else {
5969
6159
  s1 = peg$FAILED;
5970
6160
  if (peg$silentFails === 0) {
5971
- peg$fail(peg$e23);
6161
+ peg$fail(peg$e24);
5972
6162
  }
5973
6163
  }
5974
6164
  if (s1 === peg$FAILED) {
5975
- if (input.substr(peg$currPos, 4) === peg$c21) {
5976
- s1 = peg$c21;
6165
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6166
+ s1 = peg$c22;
5977
6167
  peg$currPos += 4;
5978
6168
  } else {
5979
6169
  s1 = peg$FAILED;
5980
6170
  if (peg$silentFails === 0) {
5981
- peg$fail(peg$e24);
6171
+ peg$fail(peg$e25);
5982
6172
  }
5983
6173
  }
5984
6174
  if (s1 === peg$FAILED) {
5985
- if (input.substr(peg$currPos, 6) === peg$c22) {
5986
- s1 = peg$c22;
6175
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6176
+ s1 = peg$c23;
5987
6177
  peg$currPos += 6;
5988
6178
  } else {
5989
6179
  s1 = peg$FAILED;
5990
6180
  if (peg$silentFails === 0) {
5991
- peg$fail(peg$e25);
6181
+ peg$fail(peg$e26);
5992
6182
  }
5993
6183
  }
5994
6184
  if (s1 === peg$FAILED) {
5995
- if (input.substr(peg$currPos, 7) === peg$c23) {
5996
- s1 = peg$c23;
6185
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6186
+ s1 = peg$c24;
5997
6187
  peg$currPos += 7;
5998
6188
  } else {
5999
6189
  s1 = peg$FAILED;
6000
6190
  if (peg$silentFails === 0) {
6001
- peg$fail(peg$e26);
6191
+ peg$fail(peg$e27);
6002
6192
  }
6003
6193
  }
6004
6194
  if (s1 === peg$FAILED) {
6005
- if (input.substr(peg$currPos, 3) === peg$c24) {
6006
- s1 = peg$c24;
6195
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6196
+ s1 = peg$c25;
6007
6197
  peg$currPos += 3;
6008
6198
  } else {
6009
6199
  s1 = peg$FAILED;
6010
6200
  if (peg$silentFails === 0) {
6011
- peg$fail(peg$e27);
6201
+ peg$fail(peg$e28);
6012
6202
  }
6013
6203
  }
6014
6204
  if (s1 === peg$FAILED) {
6015
- if (input.substr(peg$currPos, 3) === peg$c25) {
6016
- s1 = peg$c25;
6205
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6206
+ s1 = peg$c26;
6017
6207
  peg$currPos += 3;
6018
6208
  } else {
6019
6209
  s1 = peg$FAILED;
6020
6210
  if (peg$silentFails === 0) {
6021
- peg$fail(peg$e28);
6211
+ peg$fail(peg$e29);
6022
6212
  }
6023
6213
  }
6024
6214
  if (s1 === peg$FAILED) {
6025
- if (input.substr(peg$currPos, 5) === peg$c26) {
6026
- s1 = peg$c26;
6215
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6216
+ s1 = peg$c27;
6027
6217
  peg$currPos += 5;
6028
6218
  } else {
6029
6219
  s1 = peg$FAILED;
6030
6220
  if (peg$silentFails === 0) {
6031
- peg$fail(peg$e29);
6221
+ peg$fail(peg$e30);
6032
6222
  }
6033
6223
  }
6034
6224
  if (s1 === peg$FAILED) {
6035
- if (input.substr(peg$currPos, 8) === peg$c27) {
6036
- s1 = peg$c27;
6225
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6226
+ s1 = peg$c28;
6037
6227
  peg$currPos += 8;
6038
6228
  } else {
6039
6229
  s1 = peg$FAILED;
6040
6230
  if (peg$silentFails === 0) {
6041
- peg$fail(peg$e30);
6231
+ peg$fail(peg$e31);
6042
6232
  }
6043
6233
  }
6044
6234
  if (s1 === peg$FAILED) {
6045
- if (input.substr(peg$currPos, 4) === peg$c28) {
6046
- s1 = peg$c28;
6235
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6236
+ s1 = peg$c29;
6047
6237
  peg$currPos += 4;
6048
6238
  } else {
6049
6239
  s1 = peg$FAILED;
6050
6240
  if (peg$silentFails === 0) {
6051
- peg$fail(peg$e31);
6241
+ peg$fail(peg$e32);
6052
6242
  }
6053
6243
  }
6054
6244
  if (s1 === peg$FAILED) {
6055
- if (input.substr(peg$currPos, 5) === peg$c29) {
6056
- s1 = peg$c29;
6245
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6246
+ s1 = peg$c30;
6057
6247
  peg$currPos += 5;
6058
6248
  } else {
6059
6249
  s1 = peg$FAILED;
6060
6250
  if (peg$silentFails === 0) {
6061
- peg$fail(peg$e32);
6251
+ peg$fail(peg$e33);
6062
6252
  }
6063
6253
  }
6064
6254
  if (s1 === peg$FAILED) {
6065
- if (input.substr(peg$currPos, 6) === peg$c30) {
6066
- s1 = peg$c30;
6255
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6256
+ s1 = peg$c31;
6067
6257
  peg$currPos += 6;
6068
6258
  } else {
6069
6259
  s1 = peg$FAILED;
6070
6260
  if (peg$silentFails === 0) {
6071
- peg$fail(peg$e33);
6261
+ peg$fail(peg$e34);
6072
6262
  }
6073
6263
  }
6074
6264
  if (s1 === peg$FAILED) {
6075
- if (input.substr(peg$currPos, 9) === peg$c31) {
6076
- s1 = peg$c31;
6265
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6266
+ s1 = peg$c32;
6077
6267
  peg$currPos += 9;
6078
6268
  } else {
6079
6269
  s1 = peg$FAILED;
6080
6270
  if (peg$silentFails === 0) {
6081
- peg$fail(peg$e34);
6271
+ peg$fail(peg$e35);
6082
6272
  }
6083
6273
  }
6084
6274
  if (s1 === peg$FAILED) {
6085
- if (input.substr(peg$currPos, 7) === peg$c32) {
6086
- s1 = peg$c32;
6275
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6276
+ s1 = peg$c33;
6087
6277
  peg$currPos += 7;
6088
6278
  } else {
6089
6279
  s1 = peg$FAILED;
6090
6280
  if (peg$silentFails === 0) {
6091
- peg$fail(peg$e35);
6281
+ peg$fail(peg$e36);
6092
6282
  }
6093
6283
  }
6094
6284
  if (s1 === peg$FAILED) {
6095
- if (input.substr(peg$currPos, 4) === peg$c33) {
6096
- s1 = peg$c33;
6285
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6286
+ s1 = peg$c34;
6097
6287
  peg$currPos += 4;
6098
6288
  } else {
6099
6289
  s1 = peg$FAILED;
6100
6290
  if (peg$silentFails === 0) {
6101
- peg$fail(peg$e36);
6291
+ peg$fail(peg$e37);
6102
6292
  }
6103
6293
  }
6104
6294
  if (s1 === peg$FAILED) {
6105
- if (input.substr(peg$currPos, 4) === peg$c35) {
6106
- s1 = peg$c35;
6295
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6296
+ s1 = peg$c36;
6107
6297
  peg$currPos += 4;
6108
6298
  } else {
6109
6299
  s1 = peg$FAILED;
6110
6300
  if (peg$silentFails === 0) {
6111
- peg$fail(peg$e38);
6301
+ peg$fail(peg$e39);
6112
6302
  }
6113
6303
  }
6114
6304
  if (s1 === peg$FAILED) {
6115
- if (input.substr(peg$currPos, 6) === peg$c36) {
6116
- s1 = peg$c36;
6305
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6306
+ s1 = peg$c37;
6117
6307
  peg$currPos += 6;
6118
6308
  } else {
6119
6309
  s1 = peg$FAILED;
6120
6310
  if (peg$silentFails === 0) {
6121
- peg$fail(peg$e39);
6311
+ peg$fail(peg$e40);
6122
6312
  }
6123
6313
  }
6124
6314
  if (s1 === peg$FAILED) {
6125
- if (input.substr(peg$currPos, 5) === peg$c37) {
6126
- s1 = peg$c37;
6315
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6316
+ s1 = peg$c38;
6127
6317
  peg$currPos += 5;
6128
6318
  } else {
6129
6319
  s1 = peg$FAILED;
6130
6320
  if (peg$silentFails === 0) {
6131
- peg$fail(peg$e40);
6321
+ peg$fail(peg$e41);
6132
6322
  }
6133
6323
  }
6134
6324
  if (s1 === peg$FAILED) {
6135
- if (input.substr(peg$currPos, 8) === peg$c38) {
6136
- s1 = peg$c38;
6325
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6326
+ s1 = peg$c39;
6137
6327
  peg$currPos += 8;
6138
6328
  } else {
6139
6329
  s1 = peg$FAILED;
6140
6330
  if (peg$silentFails === 0) {
6141
- peg$fail(peg$e41);
6331
+ peg$fail(peg$e42);
6142
6332
  }
6143
6333
  }
6144
6334
  if (s1 === peg$FAILED) {
6145
- if (input.substr(peg$currPos, 6) === peg$c39) {
6146
- s1 = peg$c39;
6335
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6336
+ s1 = peg$c40;
6147
6337
  peg$currPos += 6;
6148
6338
  } else {
6149
6339
  s1 = peg$FAILED;
6150
6340
  if (peg$silentFails === 0) {
6151
- peg$fail(peg$e42);
6341
+ peg$fail(peg$e43);
6152
6342
  }
6153
6343
  }
6154
6344
  if (s1 === peg$FAILED) {
6155
- if (input.substr(peg$currPos, 8) === peg$c40) {
6156
- s1 = peg$c40;
6345
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6346
+ s1 = peg$c41;
6157
6347
  peg$currPos += 8;
6158
6348
  } else {
6159
6349
  s1 = peg$FAILED;
6160
6350
  if (peg$silentFails === 0) {
6161
- peg$fail(peg$e43);
6351
+ peg$fail(peg$e44);
6162
6352
  }
6163
6353
  }
6164
6354
  if (s1 === peg$FAILED) {
6165
- if (input.substr(peg$currPos, 5) === peg$c41) {
6166
- s1 = peg$c41;
6355
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6356
+ s1 = peg$c42;
6167
6357
  peg$currPos += 5;
6168
6358
  } else {
6169
6359
  s1 = peg$FAILED;
6170
6360
  if (peg$silentFails === 0) {
6171
- peg$fail(peg$e44);
6361
+ peg$fail(peg$e45);
6172
6362
  }
6173
6363
  }
6174
6364
  if (s1 === peg$FAILED) {
6175
- if (input.substr(peg$currPos, 6) === peg$c42) {
6176
- s1 = peg$c42;
6365
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6366
+ s1 = peg$c43;
6177
6367
  peg$currPos += 6;
6178
6368
  } else {
6179
6369
  s1 = peg$FAILED;
6180
6370
  if (peg$silentFails === 0) {
6181
- peg$fail(peg$e45);
6371
+ peg$fail(peg$e46);
6182
6372
  }
6183
6373
  }
6184
6374
  if (s1 === peg$FAILED) {
6185
- if (input.substr(peg$currPos, 6) === peg$c43) {
6186
- s1 = peg$c43;
6375
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6376
+ s1 = peg$c44;
6187
6377
  peg$currPos += 6;
6188
6378
  } else {
6189
6379
  s1 = peg$FAILED;
6190
6380
  if (peg$silentFails === 0) {
6191
- peg$fail(peg$e46);
6381
+ peg$fail(peg$e47);
6192
6382
  }
6193
6383
  }
6194
6384
  if (s1 === peg$FAILED) {
6195
- if (input.substr(peg$currPos, 5) === peg$c44) {
6196
- s1 = peg$c44;
6385
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6386
+ s1 = peg$c45;
6197
6387
  peg$currPos += 5;
6198
6388
  } else {
6199
6389
  s1 = peg$FAILED;
6200
6390
  if (peg$silentFails === 0) {
6201
- peg$fail(peg$e47);
6391
+ peg$fail(peg$e48);
6202
6392
  }
6203
6393
  }
6204
6394
  if (s1 === peg$FAILED) {
6205
- if (input.substr(peg$currPos, 6) === peg$c46) {
6206
- s1 = peg$c46;
6395
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6396
+ s1 = peg$c47;
6207
6397
  peg$currPos += 6;
6208
6398
  } else {
6209
6399
  s1 = peg$FAILED;
6210
6400
  if (peg$silentFails === 0) {
6211
- peg$fail(peg$e49);
6401
+ peg$fail(peg$e50);
6212
6402
  }
6213
6403
  }
6214
6404
  if (s1 === peg$FAILED) {
6215
- if (input.substr(peg$currPos, 5) === peg$c47) {
6216
- s1 = peg$c47;
6405
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6406
+ s1 = peg$c48;
6217
6407
  peg$currPos += 5;
6218
6408
  } else {
6219
6409
  s1 = peg$FAILED;
6220
6410
  if (peg$silentFails === 0) {
6221
- peg$fail(peg$e50);
6411
+ peg$fail(peg$e51);
6222
6412
  }
6223
6413
  }
6224
6414
  if (s1 === peg$FAILED) {
6225
- if (input.substr(peg$currPos, 5) === peg$c49) {
6226
- s1 = peg$c49;
6415
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6416
+ s1 = peg$c50;
6227
6417
  peg$currPos += 5;
6228
6418
  } else {
6229
6419
  s1 = peg$FAILED;
6230
6420
  if (peg$silentFails === 0) {
6231
- peg$fail(peg$e52);
6421
+ peg$fail(peg$e53);
6232
6422
  }
6233
6423
  }
6234
6424
  if (s1 === peg$FAILED) {
6235
- if (input.substr(peg$currPos, 7) === peg$c52) {
6236
- s1 = peg$c52;
6425
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6426
+ s1 = peg$c53;
6237
6427
  peg$currPos += 7;
6238
6428
  } else {
6239
6429
  s1 = peg$FAILED;
6240
6430
  if (peg$silentFails === 0) {
6241
- peg$fail(peg$e55);
6431
+ peg$fail(peg$e56);
6242
6432
  }
6243
6433
  }
6244
6434
  if (s1 === peg$FAILED) {
6245
- if (input.substr(peg$currPos, 4) === peg$c53) {
6246
- s1 = peg$c53;
6435
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6436
+ s1 = peg$c54;
6247
6437
  peg$currPos += 4;
6248
6438
  } else {
6249
6439
  s1 = peg$FAILED;
6250
6440
  if (peg$silentFails === 0) {
6251
- peg$fail(peg$e56);
6441
+ peg$fail(peg$e57);
6252
6442
  }
6253
6443
  }
6254
6444
  if (s1 === peg$FAILED) {
6255
- if (input.substr(peg$currPos, 4) === peg$c54) {
6256
- s1 = peg$c54;
6445
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6446
+ s1 = peg$c55;
6257
6447
  peg$currPos += 4;
6258
6448
  } else {
6259
6449
  s1 = peg$FAILED;
6260
6450
  if (peg$silentFails === 0) {
6261
- peg$fail(peg$e57);
6451
+ peg$fail(peg$e58);
6262
6452
  }
6263
6453
  }
6264
6454
  if (s1 === peg$FAILED) {
6265
- if (input.substr(peg$currPos, 5) === peg$c55) {
6266
- s1 = peg$c55;
6455
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6456
+ s1 = peg$c56;
6267
6457
  peg$currPos += 5;
6268
6458
  } else {
6269
6459
  s1 = peg$FAILED;
6270
6460
  if (peg$silentFails === 0) {
6271
- peg$fail(peg$e58);
6461
+ peg$fail(peg$e59);
6272
6462
  }
6273
6463
  }
6274
6464
  if (s1 === peg$FAILED) {
6275
- if (input.substr(peg$currPos, 5) === peg$c56) {
6276
- s1 = peg$c56;
6465
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6466
+ s1 = peg$c57;
6277
6467
  peg$currPos += 5;
6278
6468
  } else {
6279
6469
  s1 = peg$FAILED;
6280
6470
  if (peg$silentFails === 0) {
6281
- peg$fail(peg$e59);
6471
+ peg$fail(peg$e60);
6282
6472
  }
6283
6473
  }
6284
6474
  if (s1 === peg$FAILED) {
6285
- if (input.substr(peg$currPos, 8) === peg$c57) {
6286
- s1 = peg$c57;
6475
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6476
+ s1 = peg$c58;
6287
6477
  peg$currPos += 8;
6288
6478
  } else {
6289
6479
  s1 = peg$FAILED;
6290
6480
  if (peg$silentFails === 0) {
6291
- peg$fail(peg$e60);
6481
+ peg$fail(peg$e61);
6292
6482
  }
6293
6483
  }
6294
6484
  if (s1 === peg$FAILED) {
6295
- if (input.substr(peg$currPos, 7) === peg$c58) {
6296
- s1 = peg$c58;
6485
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6486
+ s1 = peg$c59;
6297
6487
  peg$currPos += 7;
6298
6488
  } else {
6299
6489
  s1 = peg$FAILED;
6300
6490
  if (peg$silentFails === 0) {
6301
- peg$fail(peg$e61);
6491
+ peg$fail(peg$e62);
6302
6492
  }
6303
6493
  }
6304
6494
  if (s1 === peg$FAILED) {
6305
- if (input.substr(peg$currPos, 7) === peg$c59) {
6306
- s1 = peg$c59;
6495
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6496
+ s1 = peg$c60;
6307
6497
  peg$currPos += 7;
6308
6498
  } else {
6309
6499
  s1 = peg$FAILED;
6310
6500
  if (peg$silentFails === 0) {
6311
- peg$fail(peg$e62);
6501
+ peg$fail(peg$e63);
6312
6502
  }
6313
6503
  }
6314
6504
  if (s1 === peg$FAILED) {
6315
- if (input.substr(peg$currPos, 7) === peg$c60) {
6316
- s1 = peg$c60;
6505
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6506
+ s1 = peg$c61;
6317
6507
  peg$currPos += 7;
6318
6508
  } else {
6319
6509
  s1 = peg$FAILED;
6320
6510
  if (peg$silentFails === 0) {
6321
- peg$fail(peg$e63);
6511
+ peg$fail(peg$e64);
6322
6512
  }
6323
6513
  }
6324
6514
  if (s1 === peg$FAILED) {
6325
- if (input.substr(peg$currPos, 8) === peg$c61) {
6326
- s1 = peg$c61;
6515
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6516
+ s1 = peg$c62;
6327
6517
  peg$currPos += 8;
6328
6518
  } else {
6329
6519
  s1 = peg$FAILED;
6330
6520
  if (peg$silentFails === 0) {
6331
- peg$fail(peg$e64);
6521
+ peg$fail(peg$e65);
6332
6522
  }
6333
6523
  }
6334
6524
  if (s1 === peg$FAILED) {
6335
- if (input.substr(peg$currPos, 7) === peg$c62) {
6336
- s1 = peg$c62;
6525
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6526
+ s1 = peg$c63;
6337
6527
  peg$currPos += 7;
6338
6528
  } else {
6339
6529
  s1 = peg$FAILED;
6340
6530
  if (peg$silentFails === 0) {
6341
- peg$fail(peg$e65);
6531
+ peg$fail(peg$e66);
6342
6532
  }
6343
6533
  }
6344
6534
  if (s1 === peg$FAILED) {
6345
- if (input.substr(peg$currPos, 3) === peg$c63) {
6346
- s1 = peg$c63;
6535
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6536
+ s1 = peg$c64;
6347
6537
  peg$currPos += 3;
6348
6538
  } else {
6349
6539
  s1 = peg$FAILED;
6350
6540
  if (peg$silentFails === 0) {
6351
- peg$fail(peg$e66);
6541
+ peg$fail(peg$e67);
6352
6542
  }
6353
6543
  }
6354
6544
  if (s1 === peg$FAILED) {
6355
- if (input.substr(peg$currPos, 4) === peg$c65) {
6356
- s1 = peg$c65;
6545
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6546
+ s1 = peg$c66;
6357
6547
  peg$currPos += 4;
6358
6548
  } else {
6359
6549
  s1 = peg$FAILED;
6360
6550
  if (peg$silentFails === 0) {
6361
- peg$fail(peg$e68);
6551
+ peg$fail(peg$e69);
6362
6552
  }
6363
6553
  }
6364
6554
  if (s1 === peg$FAILED) {
6365
- if (input.substr(peg$currPos, 3) === peg$c66) {
6366
- s1 = peg$c66;
6555
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6556
+ s1 = peg$c67;
6367
6557
  peg$currPos += 3;
6368
6558
  } else {
6369
6559
  s1 = peg$FAILED;
6370
6560
  if (peg$silentFails === 0) {
6371
- peg$fail(peg$e69);
6561
+ peg$fail(peg$e70);
6372
6562
  }
6373
6563
  }
6374
6564
  if (s1 === peg$FAILED) {
6375
- if (input.substr(peg$currPos, 10) === peg$c67) {
6376
- s1 = peg$c67;
6565
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6566
+ s1 = peg$c68;
6377
6567
  peg$currPos += 10;
6378
6568
  } else {
6379
6569
  s1 = peg$FAILED;
6380
6570
  if (peg$silentFails === 0) {
6381
- peg$fail(peg$e70);
6571
+ peg$fail(peg$e71);
6382
6572
  }
6383
6573
  }
6384
6574
  if (s1 === peg$FAILED) {
6385
- if (input.substr(peg$currPos, 5) === peg$c64) {
6386
- s1 = peg$c64;
6575
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6576
+ s1 = peg$c65;
6387
6577
  peg$currPos += 5;
6388
6578
  } else {
6389
6579
  s1 = peg$FAILED;
6390
6580
  if (peg$silentFails === 0) {
6391
- peg$fail(peg$e67);
6581
+ peg$fail(peg$e68);
6392
6582
  }
6393
6583
  }
6394
6584
  if (s1 === peg$FAILED) {
6395
- if (input.substr(peg$currPos, 6) === peg$c68) {
6396
- s1 = peg$c68;
6585
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6586
+ s1 = peg$c69;
6397
6587
  peg$currPos += 6;
6398
6588
  } else {
6399
6589
  s1 = peg$FAILED;
6400
6590
  if (peg$silentFails === 0) {
6401
- peg$fail(peg$e71);
6591
+ peg$fail(peg$e72);
6402
6592
  }
6403
6593
  }
6404
6594
  if (s1 === peg$FAILED) {
6405
- if (input.substr(peg$currPos, 11) === peg$c69) {
6406
- s1 = peg$c69;
6595
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6596
+ s1 = peg$c70;
6407
6597
  peg$currPos += 11;
6408
6598
  } else {
6409
6599
  s1 = peg$FAILED;
6410
6600
  if (peg$silentFails === 0) {
6411
- peg$fail(peg$e72);
6601
+ peg$fail(peg$e73);
6412
6602
  }
6413
6603
  }
6414
6604
  if (s1 === peg$FAILED) {
6415
- if (input.substr(peg$currPos, 6) === peg$c3) {
6416
- s1 = peg$c3;
6605
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6606
+ s1 = peg$c20;
6417
6607
  peg$currPos += 6;
6418
6608
  } else {
6419
6609
  s1 = peg$FAILED;
6420
6610
  if (peg$silentFails === 0) {
6421
- peg$fail(peg$e3);
6611
+ peg$fail(peg$e23);
6422
6612
  }
6423
6613
  }
6424
6614
  if (s1 === peg$FAILED) {
6425
- if (input.substr(peg$currPos, 9) === peg$c4) {
6426
- s1 = peg$c4;
6427
- peg$currPos += 9;
6615
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6616
+ s1 = peg$c3;
6617
+ peg$currPos += 6;
6428
6618
  } else {
6429
6619
  s1 = peg$FAILED;
6430
6620
  if (peg$silentFails === 0) {
6431
- peg$fail(peg$e4);
6621
+ peg$fail(peg$e3);
6432
6622
  }
6433
6623
  }
6434
6624
  if (s1 === peg$FAILED) {
6435
- if (input.substr(peg$currPos, 3) === peg$c12) {
6436
- s1 = peg$c12;
6437
- peg$currPos += 3;
6625
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6626
+ s1 = peg$c4;
6627
+ peg$currPos += 9;
6438
6628
  } else {
6439
6629
  s1 = peg$FAILED;
6440
6630
  if (peg$silentFails === 0) {
6441
- peg$fail(peg$e12);
6631
+ peg$fail(peg$e4);
6442
6632
  }
6443
6633
  }
6444
6634
  if (s1 === peg$FAILED) {
6445
- if (input.substr(peg$currPos, 4) === peg$c15) {
6446
- s1 = peg$c15;
6447
- peg$currPos += 4;
6635
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6636
+ s1 = peg$c12;
6637
+ peg$currPos += 3;
6448
6638
  } else {
6449
6639
  s1 = peg$FAILED;
6450
6640
  if (peg$silentFails === 0) {
6451
- peg$fail(peg$e15);
6641
+ peg$fail(peg$e12);
6452
6642
  }
6453
6643
  }
6454
6644
  if (s1 === peg$FAILED) {
6455
- if (input.substr(peg$currPos, 4) === peg$c16) {
6456
- s1 = peg$c16;
6645
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6646
+ s1 = peg$c15;
6457
6647
  peg$currPos += 4;
6458
6648
  } else {
6459
6649
  s1 = peg$FAILED;
6460
6650
  if (peg$silentFails === 0) {
6461
- peg$fail(peg$e16);
6651
+ peg$fail(peg$e15);
6652
+ }
6653
+ }
6654
+ if (s1 === peg$FAILED) {
6655
+ if (input.substr(peg$currPos, 4) === peg$c16) {
6656
+ s1 = peg$c16;
6657
+ peg$currPos += 4;
6658
+ } else {
6659
+ s1 = peg$FAILED;
6660
+ if (peg$silentFails === 0) {
6661
+ peg$fail(peg$e16);
6662
+ }
6462
6663
  }
6463
6664
  }
6464
6665
  }
@@ -6543,7 +6744,7 @@ function peg$parse(input, options) {
6543
6744
  } else {
6544
6745
  s0 = peg$FAILED;
6545
6746
  if (peg$silentFails === 0) {
6546
- peg$fail(peg$e77);
6747
+ peg$fail(peg$e78);
6547
6748
  }
6548
6749
  }
6549
6750
  return s0;
@@ -6576,12 +6777,12 @@ function peg$parse(input, options) {
6576
6777
  peg$silentFails++;
6577
6778
  s0 = peg$currPos;
6578
6779
  if (input.charCodeAt(peg$currPos) === 34) {
6579
- s1 = peg$c71;
6780
+ s1 = peg$c72;
6580
6781
  peg$currPos++;
6581
6782
  } else {
6582
6783
  s1 = peg$FAILED;
6583
6784
  if (peg$silentFails === 0) {
6584
- peg$fail(peg$e79);
6785
+ peg$fail(peg$e80);
6585
6786
  }
6586
6787
  }
6587
6788
  if (s1 !== peg$FAILED) {
@@ -6592,17 +6793,17 @@ function peg$parse(input, options) {
6592
6793
  s3 = peg$parseDoubleStringChar();
6593
6794
  }
6594
6795
  if (input.charCodeAt(peg$currPos) === 34) {
6595
- s3 = peg$c71;
6796
+ s3 = peg$c72;
6596
6797
  peg$currPos++;
6597
6798
  } else {
6598
6799
  s3 = peg$FAILED;
6599
6800
  if (peg$silentFails === 0) {
6600
- peg$fail(peg$e79);
6801
+ peg$fail(peg$e80);
6601
6802
  }
6602
6803
  }
6603
6804
  if (s3 !== peg$FAILED) {
6604
6805
  peg$savedPos = s0;
6605
- s0 = peg$f97(s2);
6806
+ s0 = peg$f98(s2);
6606
6807
  } else {
6607
6808
  peg$currPos = s0;
6608
6809
  s0 = peg$FAILED;
@@ -6614,12 +6815,12 @@ function peg$parse(input, options) {
6614
6815
  if (s0 === peg$FAILED) {
6615
6816
  s0 = peg$currPos;
6616
6817
  if (input.charCodeAt(peg$currPos) === 39) {
6617
- s1 = peg$c72;
6818
+ s1 = peg$c73;
6618
6819
  peg$currPos++;
6619
6820
  } else {
6620
6821
  s1 = peg$FAILED;
6621
6822
  if (peg$silentFails === 0) {
6622
- peg$fail(peg$e80);
6823
+ peg$fail(peg$e81);
6623
6824
  }
6624
6825
  }
6625
6826
  if (s1 !== peg$FAILED) {
@@ -6630,17 +6831,17 @@ function peg$parse(input, options) {
6630
6831
  s3 = peg$parseSingleStringChar();
6631
6832
  }
6632
6833
  if (input.charCodeAt(peg$currPos) === 39) {
6633
- s3 = peg$c72;
6834
+ s3 = peg$c73;
6634
6835
  peg$currPos++;
6635
6836
  } else {
6636
6837
  s3 = peg$FAILED;
6637
6838
  if (peg$silentFails === 0) {
6638
- peg$fail(peg$e80);
6839
+ peg$fail(peg$e81);
6639
6840
  }
6640
6841
  }
6641
6842
  if (s3 !== peg$FAILED) {
6642
6843
  peg$savedPos = s0;
6643
- s0 = peg$f98(s2);
6844
+ s0 = peg$f99(s2);
6644
6845
  } else {
6645
6846
  peg$currPos = s0;
6646
6847
  s0 = peg$FAILED;
@@ -6654,7 +6855,7 @@ function peg$parse(input, options) {
6654
6855
  if (s0 === peg$FAILED) {
6655
6856
  s1 = peg$FAILED;
6656
6857
  if (peg$silentFails === 0) {
6657
- peg$fail(peg$e78);
6858
+ peg$fail(peg$e79);
6658
6859
  }
6659
6860
  }
6660
6861
  return s0;
@@ -6665,12 +6866,12 @@ function peg$parse(input, options) {
6665
6866
  s1 = peg$currPos;
6666
6867
  peg$silentFails++;
6667
6868
  if (input.charCodeAt(peg$currPos) === 34) {
6668
- s2 = peg$c71;
6869
+ s2 = peg$c72;
6669
6870
  peg$currPos++;
6670
6871
  } else {
6671
6872
  s2 = peg$FAILED;
6672
6873
  if (peg$silentFails === 0) {
6673
- peg$fail(peg$e79);
6874
+ peg$fail(peg$e80);
6674
6875
  }
6675
6876
  }
6676
6877
  peg$silentFails--;
@@ -6684,12 +6885,12 @@ function peg$parse(input, options) {
6684
6885
  s2 = peg$currPos;
6685
6886
  peg$silentFails++;
6686
6887
  if (input.charCodeAt(peg$currPos) === 92) {
6687
- s3 = peg$c73;
6888
+ s3 = peg$c74;
6688
6889
  peg$currPos++;
6689
6890
  } else {
6690
6891
  s3 = peg$FAILED;
6691
6892
  if (peg$silentFails === 0) {
6692
- peg$fail(peg$e81);
6893
+ peg$fail(peg$e82);
6693
6894
  }
6694
6895
  }
6695
6896
  peg$silentFails--;
@@ -6711,7 +6912,7 @@ function peg$parse(input, options) {
6711
6912
  }
6712
6913
  if (s3 !== peg$FAILED) {
6713
6914
  peg$savedPos = s0;
6714
- s0 = peg$f99(s3);
6915
+ s0 = peg$f100(s3);
6715
6916
  } else {
6716
6917
  peg$currPos = s0;
6717
6918
  s0 = peg$FAILED;
@@ -6727,19 +6928,19 @@ function peg$parse(input, options) {
6727
6928
  if (s0 === peg$FAILED) {
6728
6929
  s0 = peg$currPos;
6729
6930
  if (input.charCodeAt(peg$currPos) === 92) {
6730
- s1 = peg$c73;
6931
+ s1 = peg$c74;
6731
6932
  peg$currPos++;
6732
6933
  } else {
6733
6934
  s1 = peg$FAILED;
6734
6935
  if (peg$silentFails === 0) {
6735
- peg$fail(peg$e81);
6936
+ peg$fail(peg$e82);
6736
6937
  }
6737
6938
  }
6738
6939
  if (s1 !== peg$FAILED) {
6739
6940
  s2 = peg$parseEscapeSequence();
6740
6941
  if (s2 !== peg$FAILED) {
6741
6942
  peg$savedPos = s0;
6742
- s0 = peg$f100(s2);
6943
+ s0 = peg$f101(s2);
6743
6944
  } else {
6744
6945
  peg$currPos = s0;
6745
6946
  s0 = peg$FAILED;
@@ -6757,12 +6958,12 @@ function peg$parse(input, options) {
6757
6958
  s1 = peg$currPos;
6758
6959
  peg$silentFails++;
6759
6960
  if (input.charCodeAt(peg$currPos) === 39) {
6760
- s2 = peg$c72;
6961
+ s2 = peg$c73;
6761
6962
  peg$currPos++;
6762
6963
  } else {
6763
6964
  s2 = peg$FAILED;
6764
6965
  if (peg$silentFails === 0) {
6765
- peg$fail(peg$e80);
6966
+ peg$fail(peg$e81);
6766
6967
  }
6767
6968
  }
6768
6969
  peg$silentFails--;
@@ -6776,12 +6977,12 @@ function peg$parse(input, options) {
6776
6977
  s2 = peg$currPos;
6777
6978
  peg$silentFails++;
6778
6979
  if (input.charCodeAt(peg$currPos) === 92) {
6779
- s3 = peg$c73;
6980
+ s3 = peg$c74;
6780
6981
  peg$currPos++;
6781
6982
  } else {
6782
6983
  s3 = peg$FAILED;
6783
6984
  if (peg$silentFails === 0) {
6784
- peg$fail(peg$e81);
6985
+ peg$fail(peg$e82);
6785
6986
  }
6786
6987
  }
6787
6988
  peg$silentFails--;
@@ -6803,7 +7004,7 @@ function peg$parse(input, options) {
6803
7004
  }
6804
7005
  if (s3 !== peg$FAILED) {
6805
7006
  peg$savedPos = s0;
6806
- s0 = peg$f101(s3);
7007
+ s0 = peg$f102(s3);
6807
7008
  } else {
6808
7009
  peg$currPos = s0;
6809
7010
  s0 = peg$FAILED;
@@ -6819,19 +7020,19 @@ function peg$parse(input, options) {
6819
7020
  if (s0 === peg$FAILED) {
6820
7021
  s0 = peg$currPos;
6821
7022
  if (input.charCodeAt(peg$currPos) === 92) {
6822
- s1 = peg$c73;
7023
+ s1 = peg$c74;
6823
7024
  peg$currPos++;
6824
7025
  } else {
6825
7026
  s1 = peg$FAILED;
6826
7027
  if (peg$silentFails === 0) {
6827
- peg$fail(peg$e81);
7028
+ peg$fail(peg$e82);
6828
7029
  }
6829
7030
  }
6830
7031
  if (s1 !== peg$FAILED) {
6831
7032
  s2 = peg$parseEscapeSequence();
6832
7033
  if (s2 !== peg$FAILED) {
6833
7034
  peg$savedPos = s0;
6834
- s0 = peg$f102(s2);
7035
+ s0 = peg$f103(s2);
6835
7036
  } else {
6836
7037
  peg$currPos = s0;
6837
7038
  s0 = peg$FAILED;
@@ -6847,97 +7048,97 @@ function peg$parse(input, options) {
6847
7048
  let s0, s1;
6848
7049
  s0 = peg$currPos;
6849
7050
  if (input.charCodeAt(peg$currPos) === 110) {
6850
- s1 = peg$c74;
7051
+ s1 = peg$c75;
6851
7052
  peg$currPos++;
6852
7053
  } else {
6853
7054
  s1 = peg$FAILED;
6854
7055
  if (peg$silentFails === 0) {
6855
- peg$fail(peg$e82);
7056
+ peg$fail(peg$e83);
6856
7057
  }
6857
7058
  }
6858
7059
  if (s1 !== peg$FAILED) {
6859
7060
  peg$savedPos = s0;
6860
- s1 = peg$f103();
7061
+ s1 = peg$f104();
6861
7062
  }
6862
7063
  s0 = s1;
6863
7064
  if (s0 === peg$FAILED) {
6864
7065
  s0 = peg$currPos;
6865
7066
  if (input.charCodeAt(peg$currPos) === 114) {
6866
- s1 = peg$c75;
7067
+ s1 = peg$c76;
6867
7068
  peg$currPos++;
6868
7069
  } else {
6869
7070
  s1 = peg$FAILED;
6870
7071
  if (peg$silentFails === 0) {
6871
- peg$fail(peg$e83);
7072
+ peg$fail(peg$e84);
6872
7073
  }
6873
7074
  }
6874
7075
  if (s1 !== peg$FAILED) {
6875
7076
  peg$savedPos = s0;
6876
- s1 = peg$f104();
7077
+ s1 = peg$f105();
6877
7078
  }
6878
7079
  s0 = s1;
6879
7080
  if (s0 === peg$FAILED) {
6880
7081
  s0 = peg$currPos;
6881
7082
  if (input.charCodeAt(peg$currPos) === 116) {
6882
- s1 = peg$c76;
7083
+ s1 = peg$c77;
6883
7084
  peg$currPos++;
6884
7085
  } else {
6885
7086
  s1 = peg$FAILED;
6886
7087
  if (peg$silentFails === 0) {
6887
- peg$fail(peg$e84);
7088
+ peg$fail(peg$e85);
6888
7089
  }
6889
7090
  }
6890
7091
  if (s1 !== peg$FAILED) {
6891
7092
  peg$savedPos = s0;
6892
- s1 = peg$f105();
7093
+ s1 = peg$f106();
6893
7094
  }
6894
7095
  s0 = s1;
6895
7096
  if (s0 === peg$FAILED) {
6896
7097
  s0 = peg$currPos;
6897
7098
  if (input.charCodeAt(peg$currPos) === 92) {
6898
- s1 = peg$c73;
7099
+ s1 = peg$c74;
6899
7100
  peg$currPos++;
6900
7101
  } else {
6901
7102
  s1 = peg$FAILED;
6902
7103
  if (peg$silentFails === 0) {
6903
- peg$fail(peg$e81);
7104
+ peg$fail(peg$e82);
6904
7105
  }
6905
7106
  }
6906
7107
  if (s1 !== peg$FAILED) {
6907
7108
  peg$savedPos = s0;
6908
- s1 = peg$f106();
7109
+ s1 = peg$f107();
6909
7110
  }
6910
7111
  s0 = s1;
6911
7112
  if (s0 === peg$FAILED) {
6912
7113
  s0 = peg$currPos;
6913
7114
  if (input.charCodeAt(peg$currPos) === 34) {
6914
- s1 = peg$c71;
7115
+ s1 = peg$c72;
6915
7116
  peg$currPos++;
6916
7117
  } else {
6917
7118
  s1 = peg$FAILED;
6918
7119
  if (peg$silentFails === 0) {
6919
- peg$fail(peg$e79);
7120
+ peg$fail(peg$e80);
6920
7121
  }
6921
7122
  }
6922
7123
  if (s1 !== peg$FAILED) {
6923
7124
  peg$savedPos = s0;
6924
- s1 = peg$f107();
7125
+ s1 = peg$f108();
6925
7126
  }
6926
7127
  s0 = s1;
6927
7128
  if (s0 === peg$FAILED) {
6928
7129
  s0 = peg$currPos;
6929
7130
  if (input.charCodeAt(peg$currPos) === 39) {
6930
- s1 = peg$c72;
7131
+ s1 = peg$c73;
6931
7132
  peg$currPos++;
6932
7133
  } else {
6933
7134
  s1 = peg$FAILED;
6934
7135
  if (peg$silentFails === 0) {
6935
- peg$fail(peg$e80);
7136
+ peg$fail(peg$e81);
6936
7137
  }
6937
7138
  }
6938
7139
  if (s1 !== peg$FAILED) {
6939
7140
  peg$savedPos = s0;
6940
- s1 = peg$f108();
7141
+ s1 = peg$f109();
6941
7142
  }
6942
7143
  s0 = s1;
6943
7144
  }
@@ -6952,12 +7153,12 @@ function peg$parse(input, options) {
6952
7153
  peg$silentFails++;
6953
7154
  s0 = peg$currPos;
6954
7155
  if (input.charCodeAt(peg$currPos) === 45) {
6955
- s1 = peg$c77;
7156
+ s1 = peg$c78;
6956
7157
  peg$currPos++;
6957
7158
  } else {
6958
7159
  s1 = peg$FAILED;
6959
7160
  if (peg$silentFails === 0) {
6960
- peg$fail(peg$e86);
7161
+ peg$fail(peg$e87);
6961
7162
  }
6962
7163
  }
6963
7164
  if (s1 === peg$FAILED) {
@@ -6970,7 +7171,7 @@ function peg$parse(input, options) {
6970
7171
  } else {
6971
7172
  s3 = peg$FAILED;
6972
7173
  if (peg$silentFails === 0) {
6973
- peg$fail(peg$e74);
7174
+ peg$fail(peg$e75);
6974
7175
  }
6975
7176
  }
6976
7177
  if (s3 !== peg$FAILED) {
@@ -6982,7 +7183,7 @@ function peg$parse(input, options) {
6982
7183
  } else {
6983
7184
  s3 = peg$FAILED;
6984
7185
  if (peg$silentFails === 0) {
6985
- peg$fail(peg$e74);
7186
+ peg$fail(peg$e75);
6986
7187
  }
6987
7188
  }
6988
7189
  }
@@ -6992,12 +7193,12 @@ function peg$parse(input, options) {
6992
7193
  if (s2 !== peg$FAILED) {
6993
7194
  s3 = peg$currPos;
6994
7195
  if (input.charCodeAt(peg$currPos) === 46) {
6995
- s4 = peg$c78;
7196
+ s4 = peg$c79;
6996
7197
  peg$currPos++;
6997
7198
  } else {
6998
7199
  s4 = peg$FAILED;
6999
7200
  if (peg$silentFails === 0) {
7000
- peg$fail(peg$e87);
7201
+ peg$fail(peg$e88);
7001
7202
  }
7002
7203
  }
7003
7204
  if (s4 !== peg$FAILED) {
@@ -7008,7 +7209,7 @@ function peg$parse(input, options) {
7008
7209
  } else {
7009
7210
  s6 = peg$FAILED;
7010
7211
  if (peg$silentFails === 0) {
7011
- peg$fail(peg$e74);
7212
+ peg$fail(peg$e75);
7012
7213
  }
7013
7214
  }
7014
7215
  if (s6 !== peg$FAILED) {
@@ -7020,7 +7221,7 @@ function peg$parse(input, options) {
7020
7221
  } else {
7021
7222
  s6 = peg$FAILED;
7022
7223
  if (peg$silentFails === 0) {
7023
- peg$fail(peg$e74);
7224
+ peg$fail(peg$e75);
7024
7225
  }
7025
7226
  }
7026
7227
  }
@@ -7042,7 +7243,7 @@ function peg$parse(input, options) {
7042
7243
  s3 = null;
7043
7244
  }
7044
7245
  peg$savedPos = s0;
7045
- s0 = peg$f109(s1, s2, s3);
7246
+ s0 = peg$f110(s1, s2, s3);
7046
7247
  } else {
7047
7248
  peg$currPos = s0;
7048
7249
  s0 = peg$FAILED;
@@ -7051,7 +7252,7 @@ function peg$parse(input, options) {
7051
7252
  if (s0 === peg$FAILED) {
7052
7253
  s1 = peg$FAILED;
7053
7254
  if (peg$silentFails === 0) {
7054
- peg$fail(peg$e85);
7255
+ peg$fail(peg$e86);
7055
7256
  }
7056
7257
  }
7057
7258
  return s0;
@@ -7061,12 +7262,12 @@ function peg$parse(input, options) {
7061
7262
  peg$silentFails++;
7062
7263
  s0 = peg$currPos;
7063
7264
  if (input.charCodeAt(peg$currPos) === 45) {
7064
- s1 = peg$c77;
7265
+ s1 = peg$c78;
7065
7266
  peg$currPos++;
7066
7267
  } else {
7067
7268
  s1 = peg$FAILED;
7068
7269
  if (peg$silentFails === 0) {
7069
- peg$fail(peg$e86);
7270
+ peg$fail(peg$e87);
7070
7271
  }
7071
7272
  }
7072
7273
  if (s1 === peg$FAILED) {
@@ -7079,7 +7280,7 @@ function peg$parse(input, options) {
7079
7280
  } else {
7080
7281
  s3 = peg$FAILED;
7081
7282
  if (peg$silentFails === 0) {
7082
- peg$fail(peg$e74);
7283
+ peg$fail(peg$e75);
7083
7284
  }
7084
7285
  }
7085
7286
  if (s3 !== peg$FAILED) {
@@ -7091,7 +7292,7 @@ function peg$parse(input, options) {
7091
7292
  } else {
7092
7293
  s3 = peg$FAILED;
7093
7294
  if (peg$silentFails === 0) {
7094
- peg$fail(peg$e74);
7295
+ peg$fail(peg$e75);
7095
7296
  }
7096
7297
  }
7097
7298
  }
@@ -7101,12 +7302,12 @@ function peg$parse(input, options) {
7101
7302
  if (s2 !== peg$FAILED) {
7102
7303
  s3 = peg$currPos;
7103
7304
  if (input.charCodeAt(peg$currPos) === 46) {
7104
- s4 = peg$c78;
7305
+ s4 = peg$c79;
7105
7306
  peg$currPos++;
7106
7307
  } else {
7107
7308
  s4 = peg$FAILED;
7108
7309
  if (peg$silentFails === 0) {
7109
- peg$fail(peg$e87);
7310
+ peg$fail(peg$e88);
7110
7311
  }
7111
7312
  }
7112
7313
  if (s4 !== peg$FAILED) {
@@ -7117,7 +7318,7 @@ function peg$parse(input, options) {
7117
7318
  } else {
7118
7319
  s6 = peg$FAILED;
7119
7320
  if (peg$silentFails === 0) {
7120
- peg$fail(peg$e74);
7321
+ peg$fail(peg$e75);
7121
7322
  }
7122
7323
  }
7123
7324
  if (s6 !== peg$FAILED) {
@@ -7129,7 +7330,7 @@ function peg$parse(input, options) {
7129
7330
  } else {
7130
7331
  s6 = peg$FAILED;
7131
7332
  if (peg$silentFails === 0) {
7132
- peg$fail(peg$e74);
7333
+ peg$fail(peg$e75);
7133
7334
  }
7134
7335
  }
7135
7336
  }
@@ -7150,63 +7351,63 @@ function peg$parse(input, options) {
7150
7351
  if (s3 === peg$FAILED) {
7151
7352
  s3 = null;
7152
7353
  }
7153
- if (input.substr(peg$currPos, 2) === peg$c79) {
7154
- s4 = peg$c79;
7354
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7355
+ s4 = peg$c80;
7155
7356
  peg$currPos += 2;
7156
7357
  } else {
7157
7358
  s4 = peg$FAILED;
7158
7359
  if (peg$silentFails === 0) {
7159
- peg$fail(peg$e89);
7360
+ peg$fail(peg$e90);
7160
7361
  }
7161
7362
  }
7162
7363
  if (s4 === peg$FAILED) {
7163
7364
  if (input.charCodeAt(peg$currPos) === 37) {
7164
- s4 = peg$c80;
7365
+ s4 = peg$c81;
7165
7366
  peg$currPos++;
7166
7367
  } else {
7167
7368
  s4 = peg$FAILED;
7168
7369
  if (peg$silentFails === 0) {
7169
- peg$fail(peg$e90);
7370
+ peg$fail(peg$e91);
7170
7371
  }
7171
7372
  }
7172
7373
  if (s4 === peg$FAILED) {
7173
- if (input.substr(peg$currPos, 2) === peg$c81) {
7174
- s4 = peg$c81;
7374
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7375
+ s4 = peg$c82;
7175
7376
  peg$currPos += 2;
7176
7377
  } else {
7177
7378
  s4 = peg$FAILED;
7178
7379
  if (peg$silentFails === 0) {
7179
- peg$fail(peg$e91);
7380
+ peg$fail(peg$e92);
7180
7381
  }
7181
7382
  }
7182
7383
  if (s4 === peg$FAILED) {
7183
- if (input.substr(peg$currPos, 3) === peg$c82) {
7184
- s4 = peg$c82;
7384
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7385
+ s4 = peg$c83;
7185
7386
  peg$currPos += 3;
7186
7387
  } else {
7187
7388
  s4 = peg$FAILED;
7188
7389
  if (peg$silentFails === 0) {
7189
- peg$fail(peg$e92);
7390
+ peg$fail(peg$e93);
7190
7391
  }
7191
7392
  }
7192
7393
  if (s4 === peg$FAILED) {
7193
- if (input.substr(peg$currPos, 2) === peg$c83) {
7194
- s4 = peg$c83;
7394
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7395
+ s4 = peg$c84;
7195
7396
  peg$currPos += 2;
7196
7397
  } else {
7197
7398
  s4 = peg$FAILED;
7198
7399
  if (peg$silentFails === 0) {
7199
- peg$fail(peg$e93);
7400
+ peg$fail(peg$e94);
7200
7401
  }
7201
7402
  }
7202
7403
  if (s4 === peg$FAILED) {
7203
- if (input.substr(peg$currPos, 2) === peg$c84) {
7204
- s4 = peg$c84;
7404
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7405
+ s4 = peg$c85;
7205
7406
  peg$currPos += 2;
7206
7407
  } else {
7207
7408
  s4 = peg$FAILED;
7208
7409
  if (peg$silentFails === 0) {
7209
- peg$fail(peg$e94);
7410
+ peg$fail(peg$e95);
7210
7411
  }
7211
7412
  }
7212
7413
  }
@@ -7216,7 +7417,7 @@ function peg$parse(input, options) {
7216
7417
  }
7217
7418
  if (s4 !== peg$FAILED) {
7218
7419
  peg$savedPos = s0;
7219
- s0 = peg$f110(s1, s2, s3, s4);
7420
+ s0 = peg$f111(s1, s2, s3, s4);
7220
7421
  } else {
7221
7422
  peg$currPos = s0;
7222
7423
  s0 = peg$FAILED;
@@ -7229,7 +7430,7 @@ function peg$parse(input, options) {
7229
7430
  if (s0 === peg$FAILED) {
7230
7431
  s1 = peg$FAILED;
7231
7432
  if (peg$silentFails === 0) {
7232
- peg$fail(peg$e88);
7433
+ peg$fail(peg$e89);
7233
7434
  }
7234
7435
  }
7235
7436
  return s0;
@@ -7238,34 +7439,34 @@ function peg$parse(input, options) {
7238
7439
  let s0, s1;
7239
7440
  peg$silentFails++;
7240
7441
  s0 = peg$currPos;
7241
- if (input.substr(peg$currPos, 4) === peg$c85) {
7242
- s1 = peg$c85;
7442
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7443
+ s1 = peg$c86;
7243
7444
  peg$currPos += 4;
7244
7445
  } else {
7245
7446
  s1 = peg$FAILED;
7246
7447
  if (peg$silentFails === 0) {
7247
- peg$fail(peg$e96);
7448
+ peg$fail(peg$e97);
7248
7449
  }
7249
7450
  }
7250
7451
  if (s1 !== peg$FAILED) {
7251
7452
  peg$savedPos = s0;
7252
- s1 = peg$f111();
7453
+ s1 = peg$f112();
7253
7454
  }
7254
7455
  s0 = s1;
7255
7456
  if (s0 === peg$FAILED) {
7256
7457
  s0 = peg$currPos;
7257
- if (input.substr(peg$currPos, 5) === peg$c86) {
7258
- s1 = peg$c86;
7458
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7459
+ s1 = peg$c87;
7259
7460
  peg$currPos += 5;
7260
7461
  } else {
7261
7462
  s1 = peg$FAILED;
7262
7463
  if (peg$silentFails === 0) {
7263
- peg$fail(peg$e97);
7464
+ peg$fail(peg$e98);
7264
7465
  }
7265
7466
  }
7266
7467
  if (s1 !== peg$FAILED) {
7267
7468
  peg$savedPos = s0;
7268
- s1 = peg$f112();
7469
+ s1 = peg$f113();
7269
7470
  }
7270
7471
  s0 = s1;
7271
7472
  }
@@ -7273,7 +7474,7 @@ function peg$parse(input, options) {
7273
7474
  if (s0 === peg$FAILED) {
7274
7475
  s1 = peg$FAILED;
7275
7476
  if (peg$silentFails === 0) {
7276
- peg$fail(peg$e95);
7477
+ peg$fail(peg$e96);
7277
7478
  }
7278
7479
  }
7279
7480
  return s0;
@@ -7288,7 +7489,7 @@ function peg$parse(input, options) {
7288
7489
  } else {
7289
7490
  s1 = peg$FAILED;
7290
7491
  if (peg$silentFails === 0) {
7291
- peg$fail(peg$e99);
7492
+ peg$fail(peg$e100);
7292
7493
  }
7293
7494
  }
7294
7495
  if (s1 !== peg$FAILED) {
@@ -7299,7 +7500,7 @@ function peg$parse(input, options) {
7299
7500
  } else {
7300
7501
  s3 = peg$FAILED;
7301
7502
  if (peg$silentFails === 0) {
7302
- peg$fail(peg$e77);
7503
+ peg$fail(peg$e78);
7303
7504
  }
7304
7505
  }
7305
7506
  while (s3 !== peg$FAILED) {
@@ -7310,12 +7511,12 @@ function peg$parse(input, options) {
7310
7511
  } else {
7311
7512
  s3 = peg$FAILED;
7312
7513
  if (peg$silentFails === 0) {
7313
- peg$fail(peg$e77);
7514
+ peg$fail(peg$e78);
7314
7515
  }
7315
7516
  }
7316
7517
  }
7317
7518
  peg$savedPos = s0;
7318
- s0 = peg$f113(s1, s2);
7519
+ s0 = peg$f114(s1, s2);
7319
7520
  } else {
7320
7521
  peg$currPos = s0;
7321
7522
  s0 = peg$FAILED;
@@ -7324,7 +7525,7 @@ function peg$parse(input, options) {
7324
7525
  if (s0 === peg$FAILED) {
7325
7526
  s1 = peg$FAILED;
7326
7527
  if (peg$silentFails === 0) {
7327
- peg$fail(peg$e98);
7528
+ peg$fail(peg$e99);
7328
7529
  }
7329
7530
  }
7330
7531
  return s0;
@@ -7333,12 +7534,12 @@ function peg$parse(input, options) {
7333
7534
  let s0, s1, s2, s3, s4, s5;
7334
7535
  s0 = peg$currPos;
7335
7536
  if (input.charCodeAt(peg$currPos) === 91) {
7336
- s1 = peg$c50;
7537
+ s1 = peg$c51;
7337
7538
  peg$currPos++;
7338
7539
  } else {
7339
7540
  s1 = peg$FAILED;
7340
7541
  if (peg$silentFails === 0) {
7341
- peg$fail(peg$e53);
7542
+ peg$fail(peg$e54);
7342
7543
  }
7343
7544
  }
7344
7545
  if (s1 !== peg$FAILED) {
@@ -7349,17 +7550,17 @@ function peg$parse(input, options) {
7349
7550
  }
7350
7551
  s4 = peg$parse_();
7351
7552
  if (input.charCodeAt(peg$currPos) === 93) {
7352
- s5 = peg$c51;
7553
+ s5 = peg$c52;
7353
7554
  peg$currPos++;
7354
7555
  } else {
7355
7556
  s5 = peg$FAILED;
7356
7557
  if (peg$silentFails === 0) {
7357
- peg$fail(peg$e54);
7558
+ peg$fail(peg$e55);
7358
7559
  }
7359
7560
  }
7360
7561
  if (s5 !== peg$FAILED) {
7361
7562
  peg$savedPos = s0;
7362
- s0 = peg$f114(s3);
7563
+ s0 = peg$f115(s3);
7363
7564
  } else {
7364
7565
  peg$currPos = s0;
7365
7566
  s0 = peg$FAILED;
@@ -7447,7 +7648,7 @@ function peg$parse(input, options) {
7447
7648
  s3 = null;
7448
7649
  }
7449
7650
  peg$savedPos = s0;
7450
- s0 = peg$f115(s1, s2);
7651
+ s0 = peg$f116(s1, s2);
7451
7652
  } else {
7452
7653
  peg$currPos = s0;
7453
7654
  s0 = peg$FAILED;
@@ -7501,7 +7702,7 @@ function peg$parse(input, options) {
7501
7702
  }
7502
7703
  if (s5 !== peg$FAILED) {
7503
7704
  peg$savedPos = s0;
7504
- s0 = peg$f116(s3);
7705
+ s0 = peg$f117(s3);
7505
7706
  } else {
7506
7707
  peg$currPos = s0;
7507
7708
  s0 = peg$FAILED;
@@ -7568,7 +7769,7 @@ function peg$parse(input, options) {
7568
7769
  }
7569
7770
  }
7570
7771
  peg$savedPos = s0;
7571
- s0 = peg$f117(s1, s2);
7772
+ s0 = peg$f118(s1, s2);
7572
7773
  } else {
7573
7774
  peg$currPos = s0;
7574
7775
  s0 = peg$FAILED;
@@ -7595,7 +7796,7 @@ function peg$parse(input, options) {
7595
7796
  s5 = peg$parseAttributeValue();
7596
7797
  if (s5 !== peg$FAILED) {
7597
7798
  peg$savedPos = s0;
7598
- s0 = peg$f118(s1, s5);
7799
+ s0 = peg$f119(s1, s5);
7599
7800
  } else {
7600
7801
  peg$currPos = s0;
7601
7802
  s0 = peg$FAILED;
@@ -7613,7 +7814,7 @@ function peg$parse(input, options) {
7613
7814
  s1 = peg$parseIdentifier();
7614
7815
  if (s1 !== peg$FAILED) {
7615
7816
  peg$savedPos = s0;
7616
- s1 = peg$f119(s1);
7817
+ s1 = peg$f120(s1);
7617
7818
  }
7618
7819
  s0 = s1;
7619
7820
  }
@@ -7646,7 +7847,7 @@ function peg$parse(input, options) {
7646
7847
  } else {
7647
7848
  s1 = peg$FAILED;
7648
7849
  if (peg$silentFails === 0) {
7649
- peg$fail(peg$e100);
7850
+ peg$fail(peg$e101);
7650
7851
  }
7651
7852
  }
7652
7853
  if (s1 !== peg$FAILED) {
@@ -7658,7 +7859,7 @@ function peg$parse(input, options) {
7658
7859
  } else {
7659
7860
  s1 = peg$FAILED;
7660
7861
  if (peg$silentFails === 0) {
7661
- peg$fail(peg$e100);
7862
+ peg$fail(peg$e101);
7662
7863
  }
7663
7864
  }
7664
7865
  }
@@ -7678,7 +7879,7 @@ function peg$parse(input, options) {
7678
7879
  if (s0 === peg$FAILED) {
7679
7880
  s1 = peg$FAILED;
7680
7881
  if (peg$silentFails === 0) {
7681
- peg$fail(peg$e101);
7882
+ peg$fail(peg$e102);
7682
7883
  }
7683
7884
  }
7684
7885
  return s0;
@@ -7703,7 +7904,7 @@ function peg$parse(input, options) {
7703
7904
  } else {
7704
7905
  s3 = peg$FAILED;
7705
7906
  if (peg$silentFails === 0) {
7706
- peg$fail(peg$e102);
7907
+ peg$fail(peg$e103);
7707
7908
  }
7708
7909
  }
7709
7910
  while (s3 !== peg$FAILED) {
@@ -7714,17 +7915,17 @@ function peg$parse(input, options) {
7714
7915
  } else {
7715
7916
  s3 = peg$FAILED;
7716
7917
  if (peg$silentFails === 0) {
7717
- peg$fail(peg$e102);
7918
+ peg$fail(peg$e103);
7718
7919
  }
7719
7920
  }
7720
7921
  }
7721
7922
  if (input.charCodeAt(peg$currPos) === 10) {
7722
- s3 = peg$c87;
7923
+ s3 = peg$c88;
7723
7924
  peg$currPos++;
7724
7925
  } else {
7725
7926
  s3 = peg$FAILED;
7726
7927
  if (peg$silentFails === 0) {
7727
- peg$fail(peg$e103);
7928
+ peg$fail(peg$e104);
7728
7929
  }
7729
7930
  }
7730
7931
  if (s3 === peg$FAILED) {
@@ -7777,13 +7978,13 @@ function peg$parse(input, options) {
7777
7978
  s3 = peg$currPos;
7778
7979
  s4 = peg$currPos;
7779
7980
  peg$silentFails++;
7780
- if (input.substr(peg$currPos, 2) === peg$c88) {
7781
- s5 = peg$c88;
7981
+ if (input.substr(peg$currPos, 2) === peg$c89) {
7982
+ s5 = peg$c89;
7782
7983
  peg$currPos += 2;
7783
7984
  } else {
7784
7985
  s5 = peg$FAILED;
7785
7986
  if (peg$silentFails === 0) {
7786
- peg$fail(peg$e104);
7987
+ peg$fail(peg$e105);
7787
7988
  }
7788
7989
  }
7789
7990
  peg$silentFails--;
@@ -7819,13 +8020,13 @@ function peg$parse(input, options) {
7819
8020
  s3 = peg$currPos;
7820
8021
  s4 = peg$currPos;
7821
8022
  peg$silentFails++;
7822
- if (input.substr(peg$currPos, 2) === peg$c88) {
7823
- s5 = peg$c88;
8023
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8024
+ s5 = peg$c89;
7824
8025
  peg$currPos += 2;
7825
8026
  } else {
7826
8027
  s5 = peg$FAILED;
7827
8028
  if (peg$silentFails === 0) {
7828
- peg$fail(peg$e104);
8029
+ peg$fail(peg$e105);
7829
8030
  }
7830
8031
  }
7831
8032
  peg$silentFails--;
@@ -7857,13 +8058,13 @@ function peg$parse(input, options) {
7857
8058
  s3 = peg$FAILED;
7858
8059
  }
7859
8060
  }
7860
- if (input.substr(peg$currPos, 2) === peg$c88) {
7861
- s3 = peg$c88;
8061
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8062
+ s3 = peg$c89;
7862
8063
  peg$currPos += 2;
7863
8064
  } else {
7864
8065
  s3 = peg$FAILED;
7865
8066
  if (peg$silentFails === 0) {
7866
- peg$fail(peg$e104);
8067
+ peg$fail(peg$e105);
7867
8068
  }
7868
8069
  }
7869
8070
  if (s3 !== peg$FAILED) {
@@ -8038,6 +8239,7 @@ var GRAMMAR_ELEMENTS = {
8038
8239
  component: "Component",
8039
8240
  use: "ComponentUse",
8040
8241
  slot: "Slot",
8242
+ repeat: "Repeat",
8041
8243
  header: "Header",
8042
8244
  main: "Main",
8043
8245
  footer: "Footer",
@@ -8137,6 +8339,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8137
8339
  "group",
8138
8340
  "marker",
8139
8341
  "annotations",
8342
+ "repeat",
8140
8343
  "layout",
8141
8344
  "component",
8142
8345
  "use",
@@ -8528,6 +8731,16 @@ function printNodeLines(node, depth) {
8528
8731
  return componentDefinitionLines(node, depth);
8529
8732
  case "ComponentUse":
8530
8733
  return componentUseLines(node, depth);
8734
+ // `repeat 6 { … }` — the count prints bare, as the grammar's positional
8735
+ // `Integer`, which is why this cannot go through `containerLines` (that
8736
+ // helper's only pre-attribute segment is an optional *quoted* label).
8737
+ case "Repeat":
8738
+ return blockLines(
8739
+ depth,
8740
+ ["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
8741
+ childrenLines(node, depth),
8742
+ "required"
8743
+ );
8531
8744
  // -- containers without a label ----------------------------------------
8532
8745
  case "Header":
8533
8746
  case "Main":
@@ -13054,6 +13267,12 @@ var COMPONENT_METADATA = {
13054
13267
  hasChildren: false,
13055
13268
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13056
13269
  },
13270
+ repeat: {
13271
+ category: "structure",
13272
+ attributes: [],
13273
+ hasChildren: true,
13274
+ description: "Draw the same body a fixed number of times: `repeat 6 { use skeletonCard() }`. The count is positional, and there is deliberately no index variable \u2014 every copy is identical, because copies that differ are data binding rather than a wireframe."
13275
+ },
13057
13276
  header: {
13058
13277
  category: "layout",
13059
13278
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -61627,6 +61846,7 @@ var HtmlRenderer = class extends BaseRenderer {
61627
61846
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61628
61847
  */
61629
61848
  render(document) {
61849
+ document = expandRepeats(document);
61630
61850
  if (this.context.options.sourceAnchors) {
61631
61851
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61632
61852
  }
@@ -62975,6 +63195,7 @@ function compactRuntimeInteractions(model, interactions) {
62975
63195
  }
62976
63196
  function renderSite(document, options = {}) {
62977
63197
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63198
+ document = expandRepeats(document);
62978
63199
  const model = buildSiteModel(document);
62979
63200
  const interactionModel = collectInteractions(document);
62980
63201
  const make = (idScope) => new HtmlRenderer({
@@ -63165,7 +63386,8 @@ var POSITIONAL_PROPS = {
63165
63386
  Layout: ["name"],
63166
63387
  Component: ["name"],
63167
63388
  ComponentUse: ["name", "namespace"],
63168
- Slot: ["name"]
63389
+ Slot: ["name"],
63390
+ Repeat: ["count"]
63169
63391
  };
63170
63392
  function declaredName(value) {
63171
63393
  const name = value?.trim();
@@ -63307,18 +63529,6 @@ function checkComponentContracts(ast, addError) {
63307
63529
  }
63308
63530
  slots.add(name);
63309
63531
  }
63310
- for (const [key, value] of Object.entries(node)) {
63311
- if (key === "loc" || key === "children" || typeof value !== "string") continue;
63312
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
63313
- if (name !== void 0 && !parameters.has(name) && !report(
63314
- node,
63315
- path,
63316
- `Unknown component parameter reference "$${name}" in component "${definition.name}"`,
63317
- key
63318
- )) {
63319
- return false;
63320
- }
63321
- }
63322
63532
  for (let childIndex = 0; childIndex < childrenOf2(node).length; childIndex++) {
63323
63533
  const child = childrenOf2(node)[childIndex];
63324
63534
  if (child && !inspect(child, `${path}.children[${childIndex}]`)) return false;
@@ -63329,6 +63539,17 @@ function checkComponentContracts(ast, addError) {
63329
63539
  const child = definition.children[childIndex];
63330
63540
  if (child && !inspect(child, `pages[${index}].children[${childIndex}]`)) return false;
63331
63541
  }
63542
+ for (const reference of collectParameterReferences(definition.children)) {
63543
+ if (parameters.has(reference.name)) continue;
63544
+ if (!report(
63545
+ reference.node,
63546
+ `pages[${index}]`,
63547
+ `Unknown component parameter reference "$${reference.name}" in component "${definition.name}"`,
63548
+ reference.key
63549
+ )) {
63550
+ return false;
63551
+ }
63552
+ }
63332
63553
  }
63333
63554
  const validateUse = (use, path) => {
63334
63555
  const definition = use.namespace === void 0 ? definitions.get(use.name) : void 0;
@@ -65109,27 +65330,24 @@ function validateComponentDefinitions(definitions, diagnostics) {
65109
65330
  slotNames.add(name);
65110
65331
  }
65111
65332
  }
65112
- for (const [key, value] of Object.entries(node)) {
65113
- if (key === "loc" || key === "children" || typeof value !== "string") continue;
65114
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
65115
- if (name !== void 0 && !parameterNames.has(name)) {
65116
- diagnostics.push({
65117
- code: "invalid-component-definition",
65118
- message: `Unknown parameter reference "$${name}" in component "${pending.namespace}:${pending.input.id}"`,
65119
- source: pending.input.source
65120
- });
65121
- invalid.add(pending.nodeId);
65122
- }
65123
- }
65124
65333
  for (const child of childNodes(node)) inspect(child);
65125
65334
  };
65126
65335
  for (const child of definition.children) inspect(child);
65336
+ for (const reference of collectParameterReferences(definition.children)) {
65337
+ if (parameterNames.has(reference.name)) continue;
65338
+ diagnostics.push({
65339
+ code: "invalid-component-definition",
65340
+ message: `Unknown parameter reference "$${reference.name}" in component "${pending.namespace}:${pending.input.id}"`,
65341
+ source: pending.input.source
65342
+ });
65343
+ invalid.add(pending.nodeId);
65344
+ }
65127
65345
  }
65128
65346
  return invalid;
65129
65347
  }
65130
65348
  function substituteTemplate(value, inputs) {
65131
65349
  if (typeof value === "string") {
65132
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
65350
+ const name = parameterReferenceName(value);
65133
65351
  return name !== void 0 && name in inputs ? inputs[name] : value;
65134
65352
  }
65135
65353
  if (Array.isArray(value)) return value.map((item) => substituteTemplate(item, inputs));
@@ -65480,6 +65698,8 @@ export {
65480
65698
  INTERACTIVE_ATTR_NAMES,
65481
65699
  LUCIDE_ICON_NAMES,
65482
65700
  NODE_TYPE_MAP,
65701
+ REPEAT_EXPANSION_BUDGET,
65702
+ RepeatBudgetError,
65483
65703
  TYPED_INTERACTION_ATTR,
65484
65704
  VALID_ATTRIBUTE_NAMES,
65485
65705
  VALID_COMPONENT_NAMES,
@@ -65494,6 +65714,7 @@ export {
65494
65714
  calculateViewportScale,
65495
65715
  cloneNode,
65496
65716
  collectInteractions,
65717
+ collectParameterReferences,
65497
65718
  compileApp,
65498
65719
  contains,
65499
65720
  countNodes,
@@ -65505,6 +65726,7 @@ export {
65505
65726
  diff,
65506
65727
  documentDefinitions,
65507
65728
  documentPages,
65729
+ expandRepeats,
65508
65730
  exportToFigma,
65509
65731
  exportToFigmaString,
65510
65732
  exportToJson,
@@ -65606,6 +65828,7 @@ export {
65606
65828
  mapNodes,
65607
65829
  normalizeInteractionHandlers,
65608
65830
  normalizeStateGuard,
65831
+ parameterReferenceName,
65609
65832
  parse,
65610
65833
  parseViewportString,
65611
65834
  printWireframe,