@gmb/bitmark-parser-generator 3.16.0 → 3.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/dist/browser/bitmark-parser-generator.min.js +1 -1
  2. package/dist/browser/bundle-report.html +2 -2
  3. package/dist/cjs/config/raw/bits.js +1 -1
  4. package/dist/cjs/config/raw/bits.js.map +1 -1
  5. package/dist/cjs/generated/build-info.js +1 -1
  6. package/dist/cjs/generated/parser/text/text-peggy-parser.js +368 -998
  7. package/dist/cjs/generated/parser/text/text-peggy-parser.js.map +1 -1
  8. package/dist/cjs/generator/bitmark/BitmarkGenerator.js +28 -3
  9. package/dist/cjs/generator/bitmark/BitmarkGenerator.js.map +1 -1
  10. package/dist/cjs/generator/text/TextGenerator.js +22 -2
  11. package/dist/cjs/generator/text/TextGenerator.js.map +1 -1
  12. package/dist/cjs/model/ast/NodeType.js +2 -0
  13. package/dist/cjs/model/ast/NodeType.js.map +1 -1
  14. package/dist/cjs/model/enum/BitType.js +1 -0
  15. package/dist/cjs/model/enum/BitType.js.map +1 -1
  16. package/dist/esm/config/raw/bits.js +1 -1
  17. package/dist/esm/config/raw/bits.js.map +1 -1
  18. package/dist/esm/generated/build-info.js +1 -1
  19. package/dist/esm/generated/parser/text/text-peggy-parser.js +368 -998
  20. package/dist/esm/generated/parser/text/text-peggy-parser.js.map +1 -1
  21. package/dist/esm/generator/bitmark/BitmarkGenerator.js +28 -3
  22. package/dist/esm/generator/bitmark/BitmarkGenerator.js.map +1 -1
  23. package/dist/esm/generator/text/TextGenerator.js +22 -2
  24. package/dist/esm/generator/text/TextGenerator.js.map +1 -1
  25. package/dist/esm/model/ast/NodeType.js +2 -0
  26. package/dist/esm/model/ast/NodeType.js.map +1 -1
  27. package/dist/esm/model/enum/BitType.js +1 -0
  28. package/dist/esm/model/enum/BitType.js.map +1 -1
  29. package/dist/types/generated/parser/text/text-peggy-parser.d.ts.map +1 -1
  30. package/dist/types/generator/bitmark/BitmarkGenerator.d.ts +2 -2
  31. package/dist/types/generator/bitmark/BitmarkGenerator.d.ts.map +1 -1
  32. package/dist/types/generator/text/TextGenerator.d.ts +3 -0
  33. package/dist/types/generator/text/TextGenerator.d.ts.map +1 -1
  34. package/dist/types/model/ast/NodeType.d.ts +4 -0
  35. package/dist/types/model/ast/NodeType.d.ts.map +1 -1
  36. package/dist/types/model/enum/BitType.d.ts +2 -0
  37. package/dist/types/model/enum/BitType.d.ts.map +1 -1
  38. package/package.json +1 -1
package/dist/esm/generated/parser/text/text-peggy-parser.js CHANGED
@@ -2,7 +2,7 @@
2
2
  //
3
3
  // https://peggyjs.org/
4
4
  import { Breakscape } from "../../../breakscaping/Breakscape";
5
- const VERSION = "8.24.2";
5
+ const VERSION = "8.25.1";
6
6
  //Parser peggy.js
7
7
  // parser options (parameter when running parser):
8
8
  // allowedStartRules: ["bitmarkPlusPlus", "bitmarkPlus", "bitmarkMinusMinus", "bitmarkPlusString", "bitmarkMinusMinusString"]
@@ -4240,7 +4240,7 @@ function peg$parse(input, options) {
4240
4240
  return s0;
4241
4241
  }
4242
4242
  function peg$parseInlineStyledText() {
4243
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4243
+ var s0, s1, s2, s3, s4, s5, s6, s7;
4244
4244
  s0 = peg$currPos;
4245
4245
  s1 = peg$parseBodyBitOpenTag();
4246
4246
  if (s1 !== peg$FAILED) {
@@ -4552,160 +4552,90 @@ function peg$parse(input, options) {
4552
4552
  s0 = peg$currPos;
4553
4553
  s1 = peg$parseInlineTag();
4554
4554
  if (s1 !== peg$FAILED) {
4555
- if (input.charCodeAt(peg$currPos) === 32) {
4556
- s2 = peg$c12;
4557
- peg$currPos++;
4558
- }
4559
- else {
4560
- s2 = peg$FAILED;
4561
- if (peg$silentFails === 0) {
4562
- peg$fail(peg$e16);
4563
- }
4564
- }
4565
- if (s2 === peg$FAILED) {
4566
- s2 = null;
4567
- }
4568
- s3 = peg$currPos;
4569
- s4 = [];
4555
+ s2 = peg$currPos;
4556
+ s3 = [];
4557
+ s4 = peg$currPos;
4570
4558
  s5 = peg$currPos;
4571
- s6 = peg$currPos;
4572
4559
  peg$silentFails++;
4573
- s7 = peg$currPos;
4574
- if (input.charCodeAt(peg$currPos) === 32) {
4575
- s8 = peg$c12;
4576
- peg$currPos++;
4577
- }
4578
- else {
4579
- s8 = peg$FAILED;
4580
- if (peg$silentFails === 0) {
4581
- peg$fail(peg$e16);
4582
- }
4583
- }
4584
- if (s8 === peg$FAILED) {
4585
- s8 = null;
4586
- }
4587
- s9 = peg$parseInlineTag();
4588
- if (s9 !== peg$FAILED) {
4589
- s8 = [s8, s9];
4590
- s7 = s8;
4591
- }
4592
- else {
4593
- peg$currPos = s7;
4594
- s7 = peg$FAILED;
4595
- }
4560
+ s6 = peg$parseInlineTag();
4596
4561
  peg$silentFails--;
4597
- if (s7 === peg$FAILED) {
4598
- s6 = undefined;
4562
+ if (s6 === peg$FAILED) {
4563
+ s5 = undefined;
4599
4564
  }
4600
4565
  else {
4601
- peg$currPos = s6;
4602
- s6 = peg$FAILED;
4566
+ peg$currPos = s5;
4567
+ s5 = peg$FAILED;
4603
4568
  }
4604
- if (s6 !== peg$FAILED) {
4569
+ if (s5 !== peg$FAILED) {
4605
4570
  if (input.length > peg$currPos) {
4606
- s7 = input.charAt(peg$currPos);
4571
+ s6 = input.charAt(peg$currPos);
4607
4572
  peg$currPos++;
4608
4573
  }
4609
4574
  else {
4610
- s7 = peg$FAILED;
4575
+ s6 = peg$FAILED;
4611
4576
  if (peg$silentFails === 0) {
4612
4577
  peg$fail(peg$e0);
4613
4578
  }
4614
4579
  }
4615
- if (s7 !== peg$FAILED) {
4616
- s6 = [s6, s7];
4617
- s5 = s6;
4580
+ if (s6 !== peg$FAILED) {
4581
+ s5 = [s5, s6];
4582
+ s4 = s5;
4618
4583
  }
4619
4584
  else {
4620
- peg$currPos = s5;
4621
- s5 = peg$FAILED;
4585
+ peg$currPos = s4;
4586
+ s4 = peg$FAILED;
4622
4587
  }
4623
4588
  }
4624
4589
  else {
4625
- peg$currPos = s5;
4626
- s5 = peg$FAILED;
4590
+ peg$currPos = s4;
4591
+ s4 = peg$FAILED;
4627
4592
  }
4628
- while (s5 !== peg$FAILED) {
4629
- s4.push(s5);
4593
+ while (s4 !== peg$FAILED) {
4594
+ s3.push(s4);
4595
+ s4 = peg$currPos;
4630
4596
  s5 = peg$currPos;
4631
- s6 = peg$currPos;
4632
4597
  peg$silentFails++;
4633
- s7 = peg$currPos;
4634
- if (input.charCodeAt(peg$currPos) === 32) {
4635
- s8 = peg$c12;
4636
- peg$currPos++;
4637
- }
4638
- else {
4639
- s8 = peg$FAILED;
4640
- if (peg$silentFails === 0) {
4641
- peg$fail(peg$e16);
4642
- }
4643
- }
4644
- if (s8 === peg$FAILED) {
4645
- s8 = null;
4646
- }
4647
- s9 = peg$parseInlineTag();
4648
- if (s9 !== peg$FAILED) {
4649
- s8 = [s8, s9];
4650
- s7 = s8;
4651
- }
4652
- else {
4653
- peg$currPos = s7;
4654
- s7 = peg$FAILED;
4655
- }
4598
+ s6 = peg$parseInlineTag();
4656
4599
  peg$silentFails--;
4657
- if (s7 === peg$FAILED) {
4658
- s6 = undefined;
4600
+ if (s6 === peg$FAILED) {
4601
+ s5 = undefined;
4659
4602
  }
4660
4603
  else {
4661
- peg$currPos = s6;
4662
- s6 = peg$FAILED;
4604
+ peg$currPos = s5;
4605
+ s5 = peg$FAILED;
4663
4606
  }
4664
- if (s6 !== peg$FAILED) {
4607
+ if (s5 !== peg$FAILED) {
4665
4608
  if (input.length > peg$currPos) {
4666
- s7 = input.charAt(peg$currPos);
4609
+ s6 = input.charAt(peg$currPos);
4667
4610
  peg$currPos++;
4668
4611
  }
4669
4612
  else {
4670
- s7 = peg$FAILED;
4613
+ s6 = peg$FAILED;
4671
4614
  if (peg$silentFails === 0) {
4672
4615
  peg$fail(peg$e0);
4673
4616
  }
4674
4617
  }
4675
- if (s7 !== peg$FAILED) {
4676
- s6 = [s6, s7];
4677
- s5 = s6;
4618
+ if (s6 !== peg$FAILED) {
4619
+ s5 = [s5, s6];
4620
+ s4 = s5;
4678
4621
  }
4679
4622
  else {
4680
- peg$currPos = s5;
4681
- s5 = peg$FAILED;
4623
+ peg$currPos = s4;
4624
+ s4 = peg$FAILED;
4682
4625
  }
4683
4626
  }
4684
4627
  else {
4685
- peg$currPos = s5;
4686
- s5 = peg$FAILED;
4687
- }
4688
- }
4689
- s3 = input.substring(s3, peg$currPos);
4690
- if (input.charCodeAt(peg$currPos) === 32) {
4691
- s4 = peg$c12;
4692
- peg$currPos++;
4693
- }
4694
- else {
4695
- s4 = peg$FAILED;
4696
- if (peg$silentFails === 0) {
4697
- peg$fail(peg$e16);
4628
+ peg$currPos = s4;
4629
+ s4 = peg$FAILED;
4698
4630
  }
4699
4631
  }
4700
- if (s4 === peg$FAILED) {
4701
- s4 = null;
4702
- }
4703
- s5 = peg$parseInlineTag();
4704
- if (s5 !== peg$FAILED) {
4705
- s6 = peg$parseAttrChain();
4706
- if (s6 !== peg$FAILED) {
4632
+ s2 = input.substring(s2, peg$currPos);
4633
+ s3 = peg$parseInlineTag();
4634
+ if (s3 !== peg$FAILED) {
4635
+ s4 = peg$parseAttrChain();
4636
+ if (s4 !== peg$FAILED) {
4707
4637
  peg$savedPos = s0;
4708
- s0 = peg$f58(s3, s6);
4638
+ s0 = peg$f58(s2, s4);
4709
4639
  }
4710
4640
  else {
4711
4641
  peg$currPos = s0;
@@ -4725,158 +4655,88 @@ function peg$parse(input, options) {
4725
4655
  s0 = peg$currPos;
4726
4656
  s1 = peg$parseBoldTag();
4727
4657
  if (s1 !== peg$FAILED) {
4728
- if (input.charCodeAt(peg$currPos) === 32) {
4729
- s2 = peg$c12;
4730
- peg$currPos++;
4731
- }
4732
- else {
4733
- s2 = peg$FAILED;
4734
- if (peg$silentFails === 0) {
4735
- peg$fail(peg$e16);
4736
- }
4737
- }
4738
- if (s2 === peg$FAILED) {
4739
- s2 = null;
4740
- }
4741
- s3 = peg$currPos;
4742
- s4 = [];
4658
+ s2 = peg$currPos;
4659
+ s3 = [];
4660
+ s4 = peg$currPos;
4743
4661
  s5 = peg$currPos;
4744
- s6 = peg$currPos;
4745
4662
  peg$silentFails++;
4746
- s7 = peg$currPos;
4747
- if (input.charCodeAt(peg$currPos) === 32) {
4748
- s8 = peg$c12;
4749
- peg$currPos++;
4750
- }
4751
- else {
4752
- s8 = peg$FAILED;
4753
- if (peg$silentFails === 0) {
4754
- peg$fail(peg$e16);
4755
- }
4756
- }
4757
- if (s8 === peg$FAILED) {
4758
- s8 = null;
4759
- }
4760
- s9 = peg$parseBoldTag();
4761
- if (s9 !== peg$FAILED) {
4762
- s8 = [s8, s9];
4763
- s7 = s8;
4764
- }
4765
- else {
4766
- peg$currPos = s7;
4767
- s7 = peg$FAILED;
4768
- }
4663
+ s6 = peg$parseBoldTag();
4769
4664
  peg$silentFails--;
4770
- if (s7 === peg$FAILED) {
4771
- s6 = undefined;
4665
+ if (s6 === peg$FAILED) {
4666
+ s5 = undefined;
4772
4667
  }
4773
4668
  else {
4774
- peg$currPos = s6;
4775
- s6 = peg$FAILED;
4669
+ peg$currPos = s5;
4670
+ s5 = peg$FAILED;
4776
4671
  }
4777
- if (s6 !== peg$FAILED) {
4672
+ if (s5 !== peg$FAILED) {
4778
4673
  if (input.length > peg$currPos) {
4779
- s7 = input.charAt(peg$currPos);
4674
+ s6 = input.charAt(peg$currPos);
4780
4675
  peg$currPos++;
4781
4676
  }
4782
4677
  else {
4783
- s7 = peg$FAILED;
4678
+ s6 = peg$FAILED;
4784
4679
  if (peg$silentFails === 0) {
4785
4680
  peg$fail(peg$e0);
4786
4681
  }
4787
4682
  }
4788
- if (s7 !== peg$FAILED) {
4789
- s6 = [s6, s7];
4790
- s5 = s6;
4683
+ if (s6 !== peg$FAILED) {
4684
+ s5 = [s5, s6];
4685
+ s4 = s5;
4791
4686
  }
4792
4687
  else {
4793
- peg$currPos = s5;
4794
- s5 = peg$FAILED;
4688
+ peg$currPos = s4;
4689
+ s4 = peg$FAILED;
4795
4690
  }
4796
4691
  }
4797
4692
  else {
4798
- peg$currPos = s5;
4799
- s5 = peg$FAILED;
4693
+ peg$currPos = s4;
4694
+ s4 = peg$FAILED;
4800
4695
  }
4801
- while (s5 !== peg$FAILED) {
4802
- s4.push(s5);
4696
+ while (s4 !== peg$FAILED) {
4697
+ s3.push(s4);
4698
+ s4 = peg$currPos;
4803
4699
  s5 = peg$currPos;
4804
- s6 = peg$currPos;
4805
4700
  peg$silentFails++;
4806
- s7 = peg$currPos;
4807
- if (input.charCodeAt(peg$currPos) === 32) {
4808
- s8 = peg$c12;
4809
- peg$currPos++;
4810
- }
4811
- else {
4812
- s8 = peg$FAILED;
4813
- if (peg$silentFails === 0) {
4814
- peg$fail(peg$e16);
4815
- }
4816
- }
4817
- if (s8 === peg$FAILED) {
4818
- s8 = null;
4819
- }
4820
- s9 = peg$parseBoldTag();
4821
- if (s9 !== peg$FAILED) {
4822
- s8 = [s8, s9];
4823
- s7 = s8;
4824
- }
4825
- else {
4826
- peg$currPos = s7;
4827
- s7 = peg$FAILED;
4828
- }
4701
+ s6 = peg$parseBoldTag();
4829
4702
  peg$silentFails--;
4830
- if (s7 === peg$FAILED) {
4831
- s6 = undefined;
4703
+ if (s6 === peg$FAILED) {
4704
+ s5 = undefined;
4832
4705
  }
4833
4706
  else {
4834
- peg$currPos = s6;
4835
- s6 = peg$FAILED;
4707
+ peg$currPos = s5;
4708
+ s5 = peg$FAILED;
4836
4709
  }
4837
- if (s6 !== peg$FAILED) {
4710
+ if (s5 !== peg$FAILED) {
4838
4711
  if (input.length > peg$currPos) {
4839
- s7 = input.charAt(peg$currPos);
4712
+ s6 = input.charAt(peg$currPos);
4840
4713
  peg$currPos++;
4841
4714
  }
4842
4715
  else {
4843
- s7 = peg$FAILED;
4716
+ s6 = peg$FAILED;
4844
4717
  if (peg$silentFails === 0) {
4845
4718
  peg$fail(peg$e0);
4846
4719
  }
4847
4720
  }
4848
- if (s7 !== peg$FAILED) {
4849
- s6 = [s6, s7];
4850
- s5 = s6;
4721
+ if (s6 !== peg$FAILED) {
4722
+ s5 = [s5, s6];
4723
+ s4 = s5;
4851
4724
  }
4852
4725
  else {
4853
- peg$currPos = s5;
4854
- s5 = peg$FAILED;
4726
+ peg$currPos = s4;
4727
+ s4 = peg$FAILED;
4855
4728
  }
4856
4729
  }
4857
4730
  else {
4858
- peg$currPos = s5;
4859
- s5 = peg$FAILED;
4860
- }
4861
- }
4862
- s3 = input.substring(s3, peg$currPos);
4863
- if (input.charCodeAt(peg$currPos) === 32) {
4864
- s4 = peg$c12;
4865
- peg$currPos++;
4866
- }
4867
- else {
4868
- s4 = peg$FAILED;
4869
- if (peg$silentFails === 0) {
4870
- peg$fail(peg$e16);
4731
+ peg$currPos = s4;
4732
+ s4 = peg$FAILED;
4871
4733
  }
4872
4734
  }
4873
- if (s4 === peg$FAILED) {
4874
- s4 = null;
4875
- }
4876
- s5 = peg$parseBoldTag();
4877
- if (s5 !== peg$FAILED) {
4735
+ s2 = input.substring(s2, peg$currPos);
4736
+ s3 = peg$parseBoldTag();
4737
+ if (s3 !== peg$FAILED) {
4878
4738
  peg$savedPos = s0;
4879
- s0 = peg$f59(s3);
4739
+ s0 = peg$f59(s2);
4880
4740
  }
4881
4741
  else {
4882
4742
  peg$currPos = s0;
@@ -4891,158 +4751,88 @@ function peg$parse(input, options) {
4891
4751
  s0 = peg$currPos;
4892
4752
  s1 = peg$parseItalicTag();
4893
4753
  if (s1 !== peg$FAILED) {
4894
- if (input.charCodeAt(peg$currPos) === 32) {
4895
- s2 = peg$c12;
4896
- peg$currPos++;
4754
+ s2 = peg$currPos;
4755
+ s3 = [];
4756
+ s4 = peg$currPos;
4757
+ s5 = peg$currPos;
4758
+ peg$silentFails++;
4759
+ s6 = peg$parseItalicTag();
4760
+ peg$silentFails--;
4761
+ if (s6 === peg$FAILED) {
4762
+ s5 = undefined;
4897
4763
  }
4898
4764
  else {
4899
- s2 = peg$FAILED;
4900
- if (peg$silentFails === 0) {
4901
- peg$fail(peg$e16);
4902
- }
4903
- }
4904
- if (s2 === peg$FAILED) {
4905
- s2 = null;
4906
- }
4907
- s3 = peg$currPos;
4908
- s4 = [];
4909
- s5 = peg$currPos;
4910
- s6 = peg$currPos;
4911
- peg$silentFails++;
4912
- s7 = peg$currPos;
4913
- if (input.charCodeAt(peg$currPos) === 32) {
4914
- s8 = peg$c12;
4915
- peg$currPos++;
4916
- }
4917
- else {
4918
- s8 = peg$FAILED;
4919
- if (peg$silentFails === 0) {
4920
- peg$fail(peg$e16);
4921
- }
4922
- }
4923
- if (s8 === peg$FAILED) {
4924
- s8 = null;
4925
- }
4926
- s9 = peg$parseItalicTag();
4927
- if (s9 !== peg$FAILED) {
4928
- s8 = [s8, s9];
4929
- s7 = s8;
4930
- }
4931
- else {
4932
- peg$currPos = s7;
4933
- s7 = peg$FAILED;
4934
- }
4935
- peg$silentFails--;
4936
- if (s7 === peg$FAILED) {
4937
- s6 = undefined;
4938
- }
4939
- else {
4940
- peg$currPos = s6;
4941
- s6 = peg$FAILED;
4765
+ peg$currPos = s5;
4766
+ s5 = peg$FAILED;
4942
4767
  }
4943
- if (s6 !== peg$FAILED) {
4768
+ if (s5 !== peg$FAILED) {
4944
4769
  if (input.length > peg$currPos) {
4945
- s7 = input.charAt(peg$currPos);
4770
+ s6 = input.charAt(peg$currPos);
4946
4771
  peg$currPos++;
4947
4772
  }
4948
4773
  else {
4949
- s7 = peg$FAILED;
4774
+ s6 = peg$FAILED;
4950
4775
  if (peg$silentFails === 0) {
4951
4776
  peg$fail(peg$e0);
4952
4777
  }
4953
4778
  }
4954
- if (s7 !== peg$FAILED) {
4955
- s6 = [s6, s7];
4956
- s5 = s6;
4779
+ if (s6 !== peg$FAILED) {
4780
+ s5 = [s5, s6];
4781
+ s4 = s5;
4957
4782
  }
4958
4783
  else {
4959
- peg$currPos = s5;
4960
- s5 = peg$FAILED;
4784
+ peg$currPos = s4;
4785
+ s4 = peg$FAILED;
4961
4786
  }
4962
4787
  }
4963
4788
  else {
4964
- peg$currPos = s5;
4965
- s5 = peg$FAILED;
4789
+ peg$currPos = s4;
4790
+ s4 = peg$FAILED;
4966
4791
  }
4967
- while (s5 !== peg$FAILED) {
4968
- s4.push(s5);
4792
+ while (s4 !== peg$FAILED) {
4793
+ s3.push(s4);
4794
+ s4 = peg$currPos;
4969
4795
  s5 = peg$currPos;
4970
- s6 = peg$currPos;
4971
4796
  peg$silentFails++;
4972
- s7 = peg$currPos;
4973
- if (input.charCodeAt(peg$currPos) === 32) {
4974
- s8 = peg$c12;
4975
- peg$currPos++;
4976
- }
4977
- else {
4978
- s8 = peg$FAILED;
4979
- if (peg$silentFails === 0) {
4980
- peg$fail(peg$e16);
4981
- }
4982
- }
4983
- if (s8 === peg$FAILED) {
4984
- s8 = null;
4985
- }
4986
- s9 = peg$parseItalicTag();
4987
- if (s9 !== peg$FAILED) {
4988
- s8 = [s8, s9];
4989
- s7 = s8;
4990
- }
4991
- else {
4992
- peg$currPos = s7;
4993
- s7 = peg$FAILED;
4994
- }
4797
+ s6 = peg$parseItalicTag();
4995
4798
  peg$silentFails--;
4996
- if (s7 === peg$FAILED) {
4997
- s6 = undefined;
4799
+ if (s6 === peg$FAILED) {
4800
+ s5 = undefined;
4998
4801
  }
4999
4802
  else {
5000
- peg$currPos = s6;
5001
- s6 = peg$FAILED;
4803
+ peg$currPos = s5;
4804
+ s5 = peg$FAILED;
5002
4805
  }
5003
- if (s6 !== peg$FAILED) {
4806
+ if (s5 !== peg$FAILED) {
5004
4807
  if (input.length > peg$currPos) {
5005
- s7 = input.charAt(peg$currPos);
4808
+ s6 = input.charAt(peg$currPos);
5006
4809
  peg$currPos++;
5007
4810
  }
5008
4811
  else {
5009
- s7 = peg$FAILED;
4812
+ s6 = peg$FAILED;
5010
4813
  if (peg$silentFails === 0) {
5011
4814
  peg$fail(peg$e0);
5012
4815
  }
5013
4816
  }
5014
- if (s7 !== peg$FAILED) {
5015
- s6 = [s6, s7];
5016
- s5 = s6;
4817
+ if (s6 !== peg$FAILED) {
4818
+ s5 = [s5, s6];
4819
+ s4 = s5;
5017
4820
  }
5018
4821
  else {
5019
- peg$currPos = s5;
5020
- s5 = peg$FAILED;
4822
+ peg$currPos = s4;
4823
+ s4 = peg$FAILED;
5021
4824
  }
5022
4825
  }
5023
4826
  else {
5024
- peg$currPos = s5;
5025
- s5 = peg$FAILED;
5026
- }
5027
- }
5028
- s3 = input.substring(s3, peg$currPos);
5029
- if (input.charCodeAt(peg$currPos) === 32) {
5030
- s4 = peg$c12;
5031
- peg$currPos++;
5032
- }
5033
- else {
5034
- s4 = peg$FAILED;
5035
- if (peg$silentFails === 0) {
5036
- peg$fail(peg$e16);
4827
+ peg$currPos = s4;
4828
+ s4 = peg$FAILED;
5037
4829
  }
5038
4830
  }
5039
- if (s4 === peg$FAILED) {
5040
- s4 = null;
5041
- }
5042
- s5 = peg$parseItalicTag();
5043
- if (s5 !== peg$FAILED) {
4831
+ s2 = input.substring(s2, peg$currPos);
4832
+ s3 = peg$parseItalicTag();
4833
+ if (s3 !== peg$FAILED) {
5044
4834
  peg$savedPos = s0;
5045
- s0 = peg$f60(s3);
4835
+ s0 = peg$f60(s2);
5046
4836
  }
5047
4837
  else {
5048
4838
  peg$currPos = s0;
@@ -5057,158 +4847,88 @@ function peg$parse(input, options) {
5057
4847
  s0 = peg$currPos;
5058
4848
  s1 = peg$parseLightTag();
5059
4849
  if (s1 !== peg$FAILED) {
5060
- if (input.charCodeAt(peg$currPos) === 32) {
5061
- s2 = peg$c12;
5062
- peg$currPos++;
5063
- }
5064
- else {
5065
- s2 = peg$FAILED;
5066
- if (peg$silentFails === 0) {
5067
- peg$fail(peg$e16);
5068
- }
5069
- }
5070
- if (s2 === peg$FAILED) {
5071
- s2 = null;
5072
- }
5073
- s3 = peg$currPos;
5074
- s4 = [];
4850
+ s2 = peg$currPos;
4851
+ s3 = [];
4852
+ s4 = peg$currPos;
5075
4853
  s5 = peg$currPos;
5076
- s6 = peg$currPos;
5077
4854
  peg$silentFails++;
5078
- s7 = peg$currPos;
5079
- if (input.charCodeAt(peg$currPos) === 32) {
5080
- s8 = peg$c12;
5081
- peg$currPos++;
5082
- }
5083
- else {
5084
- s8 = peg$FAILED;
5085
- if (peg$silentFails === 0) {
5086
- peg$fail(peg$e16);
5087
- }
5088
- }
5089
- if (s8 === peg$FAILED) {
5090
- s8 = null;
5091
- }
5092
- s9 = peg$parseLightTag();
5093
- if (s9 !== peg$FAILED) {
5094
- s8 = [s8, s9];
5095
- s7 = s8;
5096
- }
5097
- else {
5098
- peg$currPos = s7;
5099
- s7 = peg$FAILED;
5100
- }
4855
+ s6 = peg$parseLightTag();
5101
4856
  peg$silentFails--;
5102
- if (s7 === peg$FAILED) {
5103
- s6 = undefined;
4857
+ if (s6 === peg$FAILED) {
4858
+ s5 = undefined;
5104
4859
  }
5105
4860
  else {
5106
- peg$currPos = s6;
5107
- s6 = peg$FAILED;
4861
+ peg$currPos = s5;
4862
+ s5 = peg$FAILED;
5108
4863
  }
5109
- if (s6 !== peg$FAILED) {
4864
+ if (s5 !== peg$FAILED) {
5110
4865
  if (input.length > peg$currPos) {
5111
- s7 = input.charAt(peg$currPos);
4866
+ s6 = input.charAt(peg$currPos);
5112
4867
  peg$currPos++;
5113
4868
  }
5114
4869
  else {
5115
- s7 = peg$FAILED;
4870
+ s6 = peg$FAILED;
5116
4871
  if (peg$silentFails === 0) {
5117
4872
  peg$fail(peg$e0);
5118
4873
  }
5119
4874
  }
5120
- if (s7 !== peg$FAILED) {
5121
- s6 = [s6, s7];
5122
- s5 = s6;
4875
+ if (s6 !== peg$FAILED) {
4876
+ s5 = [s5, s6];
4877
+ s4 = s5;
5123
4878
  }
5124
4879
  else {
5125
- peg$currPos = s5;
5126
- s5 = peg$FAILED;
4880
+ peg$currPos = s4;
4881
+ s4 = peg$FAILED;
5127
4882
  }
5128
4883
  }
5129
4884
  else {
5130
- peg$currPos = s5;
5131
- s5 = peg$FAILED;
4885
+ peg$currPos = s4;
4886
+ s4 = peg$FAILED;
5132
4887
  }
5133
- while (s5 !== peg$FAILED) {
5134
- s4.push(s5);
4888
+ while (s4 !== peg$FAILED) {
4889
+ s3.push(s4);
4890
+ s4 = peg$currPos;
5135
4891
  s5 = peg$currPos;
5136
- s6 = peg$currPos;
5137
4892
  peg$silentFails++;
5138
- s7 = peg$currPos;
5139
- if (input.charCodeAt(peg$currPos) === 32) {
5140
- s8 = peg$c12;
5141
- peg$currPos++;
5142
- }
5143
- else {
5144
- s8 = peg$FAILED;
5145
- if (peg$silentFails === 0) {
5146
- peg$fail(peg$e16);
5147
- }
5148
- }
5149
- if (s8 === peg$FAILED) {
5150
- s8 = null;
5151
- }
5152
- s9 = peg$parseLightTag();
5153
- if (s9 !== peg$FAILED) {
5154
- s8 = [s8, s9];
5155
- s7 = s8;
5156
- }
5157
- else {
5158
- peg$currPos = s7;
5159
- s7 = peg$FAILED;
5160
- }
4893
+ s6 = peg$parseLightTag();
5161
4894
  peg$silentFails--;
5162
- if (s7 === peg$FAILED) {
5163
- s6 = undefined;
4895
+ if (s6 === peg$FAILED) {
4896
+ s5 = undefined;
5164
4897
  }
5165
4898
  else {
5166
- peg$currPos = s6;
5167
- s6 = peg$FAILED;
4899
+ peg$currPos = s5;
4900
+ s5 = peg$FAILED;
5168
4901
  }
5169
- if (s6 !== peg$FAILED) {
4902
+ if (s5 !== peg$FAILED) {
5170
4903
  if (input.length > peg$currPos) {
5171
- s7 = input.charAt(peg$currPos);
4904
+ s6 = input.charAt(peg$currPos);
5172
4905
  peg$currPos++;
5173
4906
  }
5174
4907
  else {
5175
- s7 = peg$FAILED;
4908
+ s6 = peg$FAILED;
5176
4909
  if (peg$silentFails === 0) {
5177
4910
  peg$fail(peg$e0);
5178
4911
  }
5179
4912
  }
5180
- if (s7 !== peg$FAILED) {
5181
- s6 = [s6, s7];
5182
- s5 = s6;
4913
+ if (s6 !== peg$FAILED) {
4914
+ s5 = [s5, s6];
4915
+ s4 = s5;
5183
4916
  }
5184
4917
  else {
5185
- peg$currPos = s5;
5186
- s5 = peg$FAILED;
4918
+ peg$currPos = s4;
4919
+ s4 = peg$FAILED;
5187
4920
  }
5188
4921
  }
5189
4922
  else {
5190
- peg$currPos = s5;
5191
- s5 = peg$FAILED;
5192
- }
5193
- }
5194
- s3 = input.substring(s3, peg$currPos);
5195
- if (input.charCodeAt(peg$currPos) === 32) {
5196
- s4 = peg$c12;
5197
- peg$currPos++;
5198
- }
5199
- else {
5200
- s4 = peg$FAILED;
5201
- if (peg$silentFails === 0) {
5202
- peg$fail(peg$e16);
4923
+ peg$currPos = s4;
4924
+ s4 = peg$FAILED;
5203
4925
  }
5204
4926
  }
5205
- if (s4 === peg$FAILED) {
5206
- s4 = null;
5207
- }
5208
- s5 = peg$parseLightTag();
5209
- if (s5 !== peg$FAILED) {
4927
+ s2 = input.substring(s2, peg$currPos);
4928
+ s3 = peg$parseLightTag();
4929
+ if (s3 !== peg$FAILED) {
5210
4930
  peg$savedPos = s0;
5211
- s0 = peg$f61(s3);
4931
+ s0 = peg$f61(s2);
5212
4932
  }
5213
4933
  else {
5214
4934
  peg$currPos = s0;
@@ -5223,158 +4943,88 @@ function peg$parse(input, options) {
5223
4943
  s0 = peg$currPos;
5224
4944
  s1 = peg$parseHighlightTag();
5225
4945
  if (s1 !== peg$FAILED) {
5226
- if (input.charCodeAt(peg$currPos) === 32) {
5227
- s2 = peg$c12;
5228
- peg$currPos++;
5229
- }
5230
- else {
5231
- s2 = peg$FAILED;
5232
- if (peg$silentFails === 0) {
5233
- peg$fail(peg$e16);
5234
- }
5235
- }
5236
- if (s2 === peg$FAILED) {
5237
- s2 = null;
5238
- }
5239
- s3 = peg$currPos;
5240
- s4 = [];
4946
+ s2 = peg$currPos;
4947
+ s3 = [];
4948
+ s4 = peg$currPos;
5241
4949
  s5 = peg$currPos;
5242
- s6 = peg$currPos;
5243
4950
  peg$silentFails++;
5244
- s7 = peg$currPos;
5245
- if (input.charCodeAt(peg$currPos) === 32) {
5246
- s8 = peg$c12;
5247
- peg$currPos++;
5248
- }
5249
- else {
5250
- s8 = peg$FAILED;
5251
- if (peg$silentFails === 0) {
5252
- peg$fail(peg$e16);
5253
- }
5254
- }
5255
- if (s8 === peg$FAILED) {
5256
- s8 = null;
5257
- }
5258
- s9 = peg$parseHighlightTag();
5259
- if (s9 !== peg$FAILED) {
5260
- s8 = [s8, s9];
5261
- s7 = s8;
5262
- }
5263
- else {
5264
- peg$currPos = s7;
5265
- s7 = peg$FAILED;
5266
- }
4951
+ s6 = peg$parseHighlightTag();
5267
4952
  peg$silentFails--;
5268
- if (s7 === peg$FAILED) {
5269
- s6 = undefined;
4953
+ if (s6 === peg$FAILED) {
4954
+ s5 = undefined;
5270
4955
  }
5271
4956
  else {
5272
- peg$currPos = s6;
5273
- s6 = peg$FAILED;
4957
+ peg$currPos = s5;
4958
+ s5 = peg$FAILED;
5274
4959
  }
5275
- if (s6 !== peg$FAILED) {
4960
+ if (s5 !== peg$FAILED) {
5276
4961
  if (input.length > peg$currPos) {
5277
- s7 = input.charAt(peg$currPos);
4962
+ s6 = input.charAt(peg$currPos);
5278
4963
  peg$currPos++;
5279
4964
  }
5280
4965
  else {
5281
- s7 = peg$FAILED;
4966
+ s6 = peg$FAILED;
5282
4967
  if (peg$silentFails === 0) {
5283
4968
  peg$fail(peg$e0);
5284
4969
  }
5285
4970
  }
5286
- if (s7 !== peg$FAILED) {
5287
- s6 = [s6, s7];
5288
- s5 = s6;
4971
+ if (s6 !== peg$FAILED) {
4972
+ s5 = [s5, s6];
4973
+ s4 = s5;
5289
4974
  }
5290
4975
  else {
5291
- peg$currPos = s5;
5292
- s5 = peg$FAILED;
4976
+ peg$currPos = s4;
4977
+ s4 = peg$FAILED;
5293
4978
  }
5294
4979
  }
5295
4980
  else {
5296
- peg$currPos = s5;
5297
- s5 = peg$FAILED;
4981
+ peg$currPos = s4;
4982
+ s4 = peg$FAILED;
5298
4983
  }
5299
- while (s5 !== peg$FAILED) {
5300
- s4.push(s5);
4984
+ while (s4 !== peg$FAILED) {
4985
+ s3.push(s4);
4986
+ s4 = peg$currPos;
5301
4987
  s5 = peg$currPos;
5302
- s6 = peg$currPos;
5303
4988
  peg$silentFails++;
5304
- s7 = peg$currPos;
5305
- if (input.charCodeAt(peg$currPos) === 32) {
5306
- s8 = peg$c12;
5307
- peg$currPos++;
5308
- }
5309
- else {
5310
- s8 = peg$FAILED;
5311
- if (peg$silentFails === 0) {
5312
- peg$fail(peg$e16);
5313
- }
5314
- }
5315
- if (s8 === peg$FAILED) {
5316
- s8 = null;
5317
- }
5318
- s9 = peg$parseHighlightTag();
5319
- if (s9 !== peg$FAILED) {
5320
- s8 = [s8, s9];
5321
- s7 = s8;
5322
- }
5323
- else {
5324
- peg$currPos = s7;
5325
- s7 = peg$FAILED;
5326
- }
4989
+ s6 = peg$parseHighlightTag();
5327
4990
  peg$silentFails--;
5328
- if (s7 === peg$FAILED) {
5329
- s6 = undefined;
4991
+ if (s6 === peg$FAILED) {
4992
+ s5 = undefined;
5330
4993
  }
5331
4994
  else {
5332
- peg$currPos = s6;
5333
- s6 = peg$FAILED;
4995
+ peg$currPos = s5;
4996
+ s5 = peg$FAILED;
5334
4997
  }
5335
- if (s6 !== peg$FAILED) {
4998
+ if (s5 !== peg$FAILED) {
5336
4999
  if (input.length > peg$currPos) {
5337
- s7 = input.charAt(peg$currPos);
5000
+ s6 = input.charAt(peg$currPos);
5338
5001
  peg$currPos++;
5339
5002
  }
5340
5003
  else {
5341
- s7 = peg$FAILED;
5004
+ s6 = peg$FAILED;
5342
5005
  if (peg$silentFails === 0) {
5343
5006
  peg$fail(peg$e0);
5344
5007
  }
5345
5008
  }
5346
- if (s7 !== peg$FAILED) {
5347
- s6 = [s6, s7];
5348
- s5 = s6;
5009
+ if (s6 !== peg$FAILED) {
5010
+ s5 = [s5, s6];
5011
+ s4 = s5;
5349
5012
  }
5350
5013
  else {
5351
- peg$currPos = s5;
5352
- s5 = peg$FAILED;
5014
+ peg$currPos = s4;
5015
+ s4 = peg$FAILED;
5353
5016
  }
5354
5017
  }
5355
5018
  else {
5356
- peg$currPos = s5;
5357
- s5 = peg$FAILED;
5358
- }
5359
- }
5360
- s3 = input.substring(s3, peg$currPos);
5361
- if (input.charCodeAt(peg$currPos) === 32) {
5362
- s4 = peg$c12;
5363
- peg$currPos++;
5364
- }
5365
- else {
5366
- s4 = peg$FAILED;
5367
- if (peg$silentFails === 0) {
5368
- peg$fail(peg$e16);
5019
+ peg$currPos = s4;
5020
+ s4 = peg$FAILED;
5369
5021
  }
5370
5022
  }
5371
- if (s4 === peg$FAILED) {
5372
- s4 = null;
5373
- }
5374
- s5 = peg$parseHighlightTag();
5375
- if (s5 !== peg$FAILED) {
5023
+ s2 = input.substring(s2, peg$currPos);
5024
+ s3 = peg$parseHighlightTag();
5025
+ if (s3 !== peg$FAILED) {
5376
5026
  peg$savedPos = s0;
5377
- s0 = peg$f62(s3);
5027
+ s0 = peg$f62(s2);
5378
5028
  }
5379
5029
  else {
5380
5030
  peg$currPos = s0;
@@ -8368,7 +8018,7 @@ function peg$parse(input, options) {
8368
8018
  return s0;
8369
8019
  }
8370
8020
  function peg$parseStyledText() {
8371
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
8021
+ var s0, s1, s2, s3, s4, s5, s6;
8372
8022
  s0 = peg$currPos;
8373
8023
  s1 = peg$parseBodyBitOpenTag();
8374
8024
  if (s1 !== peg$FAILED) {
@@ -8432,158 +8082,88 @@ function peg$parse(input, options) {
8432
8082
  s0 = peg$currPos;
8433
8083
  s1 = peg$parseBoldTag();
8434
8084
  if (s1 !== peg$FAILED) {
8435
- if (input.charCodeAt(peg$currPos) === 32) {
8436
- s2 = peg$c12;
8437
- peg$currPos++;
8438
- }
8439
- else {
8440
- s2 = peg$FAILED;
8441
- if (peg$silentFails === 0) {
8442
- peg$fail(peg$e16);
8443
- }
8444
- }
8445
- if (s2 === peg$FAILED) {
8446
- s2 = null;
8447
- }
8448
- s3 = peg$currPos;
8449
- s4 = [];
8085
+ s2 = peg$currPos;
8086
+ s3 = [];
8087
+ s4 = peg$currPos;
8450
8088
  s5 = peg$currPos;
8451
- s6 = peg$currPos;
8452
8089
  peg$silentFails++;
8453
- s7 = peg$currPos;
8454
- if (input.charCodeAt(peg$currPos) === 32) {
8455
- s8 = peg$c12;
8456
- peg$currPos++;
8457
- }
8458
- else {
8459
- s8 = peg$FAILED;
8460
- if (peg$silentFails === 0) {
8461
- peg$fail(peg$e16);
8462
- }
8463
- }
8464
- if (s8 === peg$FAILED) {
8465
- s8 = null;
8466
- }
8467
- s9 = peg$parseBoldTag();
8468
- if (s9 !== peg$FAILED) {
8469
- s8 = [s8, s9];
8470
- s7 = s8;
8471
- }
8472
- else {
8473
- peg$currPos = s7;
8474
- s7 = peg$FAILED;
8475
- }
8090
+ s6 = peg$parseBoldTag();
8476
8091
  peg$silentFails--;
8477
- if (s7 === peg$FAILED) {
8478
- s6 = undefined;
8092
+ if (s6 === peg$FAILED) {
8093
+ s5 = undefined;
8479
8094
  }
8480
8095
  else {
8481
- peg$currPos = s6;
8482
- s6 = peg$FAILED;
8096
+ peg$currPos = s5;
8097
+ s5 = peg$FAILED;
8483
8098
  }
8484
- if (s6 !== peg$FAILED) {
8099
+ if (s5 !== peg$FAILED) {
8485
8100
  if (input.length > peg$currPos) {
8486
- s7 = input.charAt(peg$currPos);
8101
+ s6 = input.charAt(peg$currPos);
8487
8102
  peg$currPos++;
8488
8103
  }
8489
8104
  else {
8490
- s7 = peg$FAILED;
8105
+ s6 = peg$FAILED;
8491
8106
  if (peg$silentFails === 0) {
8492
8107
  peg$fail(peg$e0);
8493
8108
  }
8494
8109
  }
8495
- if (s7 !== peg$FAILED) {
8496
- s6 = [s6, s7];
8497
- s5 = s6;
8110
+ if (s6 !== peg$FAILED) {
8111
+ s5 = [s5, s6];
8112
+ s4 = s5;
8498
8113
  }
8499
8114
  else {
8500
- peg$currPos = s5;
8501
- s5 = peg$FAILED;
8115
+ peg$currPos = s4;
8116
+ s4 = peg$FAILED;
8502
8117
  }
8503
8118
  }
8504
8119
  else {
8505
- peg$currPos = s5;
8506
- s5 = peg$FAILED;
8120
+ peg$currPos = s4;
8121
+ s4 = peg$FAILED;
8507
8122
  }
8508
- while (s5 !== peg$FAILED) {
8509
- s4.push(s5);
8123
+ while (s4 !== peg$FAILED) {
8124
+ s3.push(s4);
8125
+ s4 = peg$currPos;
8510
8126
  s5 = peg$currPos;
8511
- s6 = peg$currPos;
8512
8127
  peg$silentFails++;
8513
- s7 = peg$currPos;
8514
- if (input.charCodeAt(peg$currPos) === 32) {
8515
- s8 = peg$c12;
8516
- peg$currPos++;
8517
- }
8518
- else {
8519
- s8 = peg$FAILED;
8520
- if (peg$silentFails === 0) {
8521
- peg$fail(peg$e16);
8522
- }
8523
- }
8524
- if (s8 === peg$FAILED) {
8525
- s8 = null;
8526
- }
8527
- s9 = peg$parseBoldTag();
8528
- if (s9 !== peg$FAILED) {
8529
- s8 = [s8, s9];
8530
- s7 = s8;
8531
- }
8532
- else {
8533
- peg$currPos = s7;
8534
- s7 = peg$FAILED;
8535
- }
8128
+ s6 = peg$parseBoldTag();
8536
8129
  peg$silentFails--;
8537
- if (s7 === peg$FAILED) {
8538
- s6 = undefined;
8130
+ if (s6 === peg$FAILED) {
8131
+ s5 = undefined;
8539
8132
  }
8540
8133
  else {
8541
- peg$currPos = s6;
8542
- s6 = peg$FAILED;
8134
+ peg$currPos = s5;
8135
+ s5 = peg$FAILED;
8543
8136
  }
8544
- if (s6 !== peg$FAILED) {
8137
+ if (s5 !== peg$FAILED) {
8545
8138
  if (input.length > peg$currPos) {
8546
- s7 = input.charAt(peg$currPos);
8139
+ s6 = input.charAt(peg$currPos);
8547
8140
  peg$currPos++;
8548
8141
  }
8549
8142
  else {
8550
- s7 = peg$FAILED;
8143
+ s6 = peg$FAILED;
8551
8144
  if (peg$silentFails === 0) {
8552
8145
  peg$fail(peg$e0);
8553
8146
  }
8554
8147
  }
8555
- if (s7 !== peg$FAILED) {
8556
- s6 = [s6, s7];
8557
- s5 = s6;
8148
+ if (s6 !== peg$FAILED) {
8149
+ s5 = [s5, s6];
8150
+ s4 = s5;
8558
8151
  }
8559
8152
  else {
8560
- peg$currPos = s5;
8561
- s5 = peg$FAILED;
8153
+ peg$currPos = s4;
8154
+ s4 = peg$FAILED;
8562
8155
  }
8563
8156
  }
8564
8157
  else {
8565
- peg$currPos = s5;
8566
- s5 = peg$FAILED;
8567
- }
8568
- }
8569
- s3 = input.substring(s3, peg$currPos);
8570
- if (input.charCodeAt(peg$currPos) === 32) {
8571
- s4 = peg$c12;
8572
- peg$currPos++;
8573
- }
8574
- else {
8575
- s4 = peg$FAILED;
8576
- if (peg$silentFails === 0) {
8577
- peg$fail(peg$e16);
8158
+ peg$currPos = s4;
8159
+ s4 = peg$FAILED;
8578
8160
  }
8579
8161
  }
8580
- if (s4 === peg$FAILED) {
8581
- s4 = null;
8582
- }
8583
- s5 = peg$parseBoldTag();
8584
- if (s5 !== peg$FAILED) {
8162
+ s2 = input.substring(s2, peg$currPos);
8163
+ s3 = peg$parseBoldTag();
8164
+ if (s3 !== peg$FAILED) {
8585
8165
  peg$savedPos = s0;
8586
- s0 = peg$f92(s3);
8166
+ s0 = peg$f92(s2);
8587
8167
  }
8588
8168
  else {
8589
8169
  peg$currPos = s0;
@@ -8598,158 +8178,88 @@ function peg$parse(input, options) {
8598
8178
  s0 = peg$currPos;
8599
8179
  s1 = peg$parseItalicTag();
8600
8180
  if (s1 !== peg$FAILED) {
8601
- if (input.charCodeAt(peg$currPos) === 32) {
8602
- s2 = peg$c12;
8603
- peg$currPos++;
8604
- }
8605
- else {
8606
- s2 = peg$FAILED;
8607
- if (peg$silentFails === 0) {
8608
- peg$fail(peg$e16);
8609
- }
8610
- }
8611
- if (s2 === peg$FAILED) {
8612
- s2 = null;
8613
- }
8614
- s3 = peg$currPos;
8615
- s4 = [];
8181
+ s2 = peg$currPos;
8182
+ s3 = [];
8183
+ s4 = peg$currPos;
8616
8184
  s5 = peg$currPos;
8617
- s6 = peg$currPos;
8618
8185
  peg$silentFails++;
8619
- s7 = peg$currPos;
8620
- if (input.charCodeAt(peg$currPos) === 32) {
8621
- s8 = peg$c12;
8622
- peg$currPos++;
8623
- }
8624
- else {
8625
- s8 = peg$FAILED;
8626
- if (peg$silentFails === 0) {
8627
- peg$fail(peg$e16);
8628
- }
8629
- }
8630
- if (s8 === peg$FAILED) {
8631
- s8 = null;
8632
- }
8633
- s9 = peg$parseItalicTag();
8634
- if (s9 !== peg$FAILED) {
8635
- s8 = [s8, s9];
8636
- s7 = s8;
8637
- }
8638
- else {
8639
- peg$currPos = s7;
8640
- s7 = peg$FAILED;
8641
- }
8186
+ s6 = peg$parseItalicTag();
8642
8187
  peg$silentFails--;
8643
- if (s7 === peg$FAILED) {
8644
- s6 = undefined;
8188
+ if (s6 === peg$FAILED) {
8189
+ s5 = undefined;
8645
8190
  }
8646
8191
  else {
8647
- peg$currPos = s6;
8648
- s6 = peg$FAILED;
8192
+ peg$currPos = s5;
8193
+ s5 = peg$FAILED;
8649
8194
  }
8650
- if (s6 !== peg$FAILED) {
8195
+ if (s5 !== peg$FAILED) {
8651
8196
  if (input.length > peg$currPos) {
8652
- s7 = input.charAt(peg$currPos);
8197
+ s6 = input.charAt(peg$currPos);
8653
8198
  peg$currPos++;
8654
8199
  }
8655
8200
  else {
8656
- s7 = peg$FAILED;
8201
+ s6 = peg$FAILED;
8657
8202
  if (peg$silentFails === 0) {
8658
8203
  peg$fail(peg$e0);
8659
8204
  }
8660
8205
  }
8661
- if (s7 !== peg$FAILED) {
8662
- s6 = [s6, s7];
8663
- s5 = s6;
8206
+ if (s6 !== peg$FAILED) {
8207
+ s5 = [s5, s6];
8208
+ s4 = s5;
8664
8209
  }
8665
8210
  else {
8666
- peg$currPos = s5;
8667
- s5 = peg$FAILED;
8211
+ peg$currPos = s4;
8212
+ s4 = peg$FAILED;
8668
8213
  }
8669
8214
  }
8670
8215
  else {
8671
- peg$currPos = s5;
8672
- s5 = peg$FAILED;
8216
+ peg$currPos = s4;
8217
+ s4 = peg$FAILED;
8673
8218
  }
8674
- while (s5 !== peg$FAILED) {
8675
- s4.push(s5);
8219
+ while (s4 !== peg$FAILED) {
8220
+ s3.push(s4);
8221
+ s4 = peg$currPos;
8676
8222
  s5 = peg$currPos;
8677
- s6 = peg$currPos;
8678
8223
  peg$silentFails++;
8679
- s7 = peg$currPos;
8680
- if (input.charCodeAt(peg$currPos) === 32) {
8681
- s8 = peg$c12;
8682
- peg$currPos++;
8683
- }
8684
- else {
8685
- s8 = peg$FAILED;
8686
- if (peg$silentFails === 0) {
8687
- peg$fail(peg$e16);
8688
- }
8689
- }
8690
- if (s8 === peg$FAILED) {
8691
- s8 = null;
8692
- }
8693
- s9 = peg$parseItalicTag();
8694
- if (s9 !== peg$FAILED) {
8695
- s8 = [s8, s9];
8696
- s7 = s8;
8697
- }
8698
- else {
8699
- peg$currPos = s7;
8700
- s7 = peg$FAILED;
8701
- }
8224
+ s6 = peg$parseItalicTag();
8702
8225
  peg$silentFails--;
8703
- if (s7 === peg$FAILED) {
8704
- s6 = undefined;
8226
+ if (s6 === peg$FAILED) {
8227
+ s5 = undefined;
8705
8228
  }
8706
8229
  else {
8707
- peg$currPos = s6;
8708
- s6 = peg$FAILED;
8230
+ peg$currPos = s5;
8231
+ s5 = peg$FAILED;
8709
8232
  }
8710
- if (s6 !== peg$FAILED) {
8233
+ if (s5 !== peg$FAILED) {
8711
8234
  if (input.length > peg$currPos) {
8712
- s7 = input.charAt(peg$currPos);
8235
+ s6 = input.charAt(peg$currPos);
8713
8236
  peg$currPos++;
8714
8237
  }
8715
8238
  else {
8716
- s7 = peg$FAILED;
8239
+ s6 = peg$FAILED;
8717
8240
  if (peg$silentFails === 0) {
8718
8241
  peg$fail(peg$e0);
8719
8242
  }
8720
8243
  }
8721
- if (s7 !== peg$FAILED) {
8722
- s6 = [s6, s7];
8723
- s5 = s6;
8244
+ if (s6 !== peg$FAILED) {
8245
+ s5 = [s5, s6];
8246
+ s4 = s5;
8724
8247
  }
8725
8248
  else {
8726
- peg$currPos = s5;
8727
- s5 = peg$FAILED;
8249
+ peg$currPos = s4;
8250
+ s4 = peg$FAILED;
8728
8251
  }
8729
8252
  }
8730
8253
  else {
8731
- peg$currPos = s5;
8732
- s5 = peg$FAILED;
8733
- }
8734
- }
8735
- s3 = input.substring(s3, peg$currPos);
8736
- if (input.charCodeAt(peg$currPos) === 32) {
8737
- s4 = peg$c12;
8738
- peg$currPos++;
8739
- }
8740
- else {
8741
- s4 = peg$FAILED;
8742
- if (peg$silentFails === 0) {
8743
- peg$fail(peg$e16);
8254
+ peg$currPos = s4;
8255
+ s4 = peg$FAILED;
8744
8256
  }
8745
8257
  }
8746
- if (s4 === peg$FAILED) {
8747
- s4 = null;
8748
- }
8749
- s5 = peg$parseItalicTag();
8750
- if (s5 !== peg$FAILED) {
8258
+ s2 = input.substring(s2, peg$currPos);
8259
+ s3 = peg$parseItalicTag();
8260
+ if (s3 !== peg$FAILED) {
8751
8261
  peg$savedPos = s0;
8752
- s0 = peg$f93(s3);
8262
+ s0 = peg$f93(s2);
8753
8263
  }
8754
8264
  else {
8755
8265
  peg$currPos = s0;
@@ -8764,158 +8274,88 @@ function peg$parse(input, options) {
8764
8274
  s0 = peg$currPos;
8765
8275
  s1 = peg$parseLightTag();
8766
8276
  if (s1 !== peg$FAILED) {
8767
- if (input.charCodeAt(peg$currPos) === 32) {
8768
- s2 = peg$c12;
8769
- peg$currPos++;
8770
- }
8771
- else {
8772
- s2 = peg$FAILED;
8773
- if (peg$silentFails === 0) {
8774
- peg$fail(peg$e16);
8775
- }
8776
- }
8777
- if (s2 === peg$FAILED) {
8778
- s2 = null;
8779
- }
8780
- s3 = peg$currPos;
8781
- s4 = [];
8277
+ s2 = peg$currPos;
8278
+ s3 = [];
8279
+ s4 = peg$currPos;
8782
8280
  s5 = peg$currPos;
8783
- s6 = peg$currPos;
8784
8281
  peg$silentFails++;
8785
- s7 = peg$currPos;
8786
- if (input.charCodeAt(peg$currPos) === 32) {
8787
- s8 = peg$c12;
8788
- peg$currPos++;
8789
- }
8790
- else {
8791
- s8 = peg$FAILED;
8792
- if (peg$silentFails === 0) {
8793
- peg$fail(peg$e16);
8794
- }
8795
- }
8796
- if (s8 === peg$FAILED) {
8797
- s8 = null;
8798
- }
8799
- s9 = peg$parseLightTag();
8800
- if (s9 !== peg$FAILED) {
8801
- s8 = [s8, s9];
8802
- s7 = s8;
8803
- }
8804
- else {
8805
- peg$currPos = s7;
8806
- s7 = peg$FAILED;
8807
- }
8282
+ s6 = peg$parseLightTag();
8808
8283
  peg$silentFails--;
8809
- if (s7 === peg$FAILED) {
8810
- s6 = undefined;
8284
+ if (s6 === peg$FAILED) {
8285
+ s5 = undefined;
8811
8286
  }
8812
8287
  else {
8813
- peg$currPos = s6;
8814
- s6 = peg$FAILED;
8288
+ peg$currPos = s5;
8289
+ s5 = peg$FAILED;
8815
8290
  }
8816
- if (s6 !== peg$FAILED) {
8291
+ if (s5 !== peg$FAILED) {
8817
8292
  if (input.length > peg$currPos) {
8818
- s7 = input.charAt(peg$currPos);
8293
+ s6 = input.charAt(peg$currPos);
8819
8294
  peg$currPos++;
8820
8295
  }
8821
8296
  else {
8822
- s7 = peg$FAILED;
8297
+ s6 = peg$FAILED;
8823
8298
  if (peg$silentFails === 0) {
8824
8299
  peg$fail(peg$e0);
8825
8300
  }
8826
8301
  }
8827
- if (s7 !== peg$FAILED) {
8828
- s6 = [s6, s7];
8829
- s5 = s6;
8302
+ if (s6 !== peg$FAILED) {
8303
+ s5 = [s5, s6];
8304
+ s4 = s5;
8830
8305
  }
8831
8306
  else {
8832
- peg$currPos = s5;
8833
- s5 = peg$FAILED;
8307
+ peg$currPos = s4;
8308
+ s4 = peg$FAILED;
8834
8309
  }
8835
8310
  }
8836
8311
  else {
8837
- peg$currPos = s5;
8838
- s5 = peg$FAILED;
8312
+ peg$currPos = s4;
8313
+ s4 = peg$FAILED;
8839
8314
  }
8840
- while (s5 !== peg$FAILED) {
8841
- s4.push(s5);
8315
+ while (s4 !== peg$FAILED) {
8316
+ s3.push(s4);
8317
+ s4 = peg$currPos;
8842
8318
  s5 = peg$currPos;
8843
- s6 = peg$currPos;
8844
8319
  peg$silentFails++;
8845
- s7 = peg$currPos;
8846
- if (input.charCodeAt(peg$currPos) === 32) {
8847
- s8 = peg$c12;
8848
- peg$currPos++;
8849
- }
8850
- else {
8851
- s8 = peg$FAILED;
8852
- if (peg$silentFails === 0) {
8853
- peg$fail(peg$e16);
8854
- }
8855
- }
8856
- if (s8 === peg$FAILED) {
8857
- s8 = null;
8858
- }
8859
- s9 = peg$parseLightTag();
8860
- if (s9 !== peg$FAILED) {
8861
- s8 = [s8, s9];
8862
- s7 = s8;
8863
- }
8864
- else {
8865
- peg$currPos = s7;
8866
- s7 = peg$FAILED;
8867
- }
8320
+ s6 = peg$parseLightTag();
8868
8321
  peg$silentFails--;
8869
- if (s7 === peg$FAILED) {
8870
- s6 = undefined;
8322
+ if (s6 === peg$FAILED) {
8323
+ s5 = undefined;
8871
8324
  }
8872
8325
  else {
8873
- peg$currPos = s6;
8874
- s6 = peg$FAILED;
8326
+ peg$currPos = s5;
8327
+ s5 = peg$FAILED;
8875
8328
  }
8876
- if (s6 !== peg$FAILED) {
8329
+ if (s5 !== peg$FAILED) {
8877
8330
  if (input.length > peg$currPos) {
8878
- s7 = input.charAt(peg$currPos);
8331
+ s6 = input.charAt(peg$currPos);
8879
8332
  peg$currPos++;
8880
8333
  }
8881
8334
  else {
8882
- s7 = peg$FAILED;
8335
+ s6 = peg$FAILED;
8883
8336
  if (peg$silentFails === 0) {
8884
8337
  peg$fail(peg$e0);
8885
8338
  }
8886
8339
  }
8887
- if (s7 !== peg$FAILED) {
8888
- s6 = [s6, s7];
8889
- s5 = s6;
8340
+ if (s6 !== peg$FAILED) {
8341
+ s5 = [s5, s6];
8342
+ s4 = s5;
8890
8343
  }
8891
8344
  else {
8892
- peg$currPos = s5;
8893
- s5 = peg$FAILED;
8345
+ peg$currPos = s4;
8346
+ s4 = peg$FAILED;
8894
8347
  }
8895
8348
  }
8896
8349
  else {
8897
- peg$currPos = s5;
8898
- s5 = peg$FAILED;
8899
- }
8900
- }
8901
- s3 = input.substring(s3, peg$currPos);
8902
- if (input.charCodeAt(peg$currPos) === 32) {
8903
- s4 = peg$c12;
8904
- peg$currPos++;
8905
- }
8906
- else {
8907
- s4 = peg$FAILED;
8908
- if (peg$silentFails === 0) {
8909
- peg$fail(peg$e16);
8350
+ peg$currPos = s4;
8351
+ s4 = peg$FAILED;
8910
8352
  }
8911
8353
  }
8912
- if (s4 === peg$FAILED) {
8913
- s4 = null;
8914
- }
8915
- s5 = peg$parseLightTag();
8916
- if (s5 !== peg$FAILED) {
8354
+ s2 = input.substring(s2, peg$currPos);
8355
+ s3 = peg$parseLightTag();
8356
+ if (s3 !== peg$FAILED) {
8917
8357
  peg$savedPos = s0;
8918
- s0 = peg$f94(s3);
8358
+ s0 = peg$f94(s2);
8919
8359
  }
8920
8360
  else {
8921
8361
  peg$currPos = s0;
@@ -8930,158 +8370,88 @@ function peg$parse(input, options) {
8930
8370
  s0 = peg$currPos;
8931
8371
  s1 = peg$parseHighlightTag();
8932
8372
  if (s1 !== peg$FAILED) {
8933
- if (input.charCodeAt(peg$currPos) === 32) {
8934
- s2 = peg$c12;
8935
- peg$currPos++;
8936
- }
8937
- else {
8938
- s2 = peg$FAILED;
8939
- if (peg$silentFails === 0) {
8940
- peg$fail(peg$e16);
8941
- }
8942
- }
8943
- if (s2 === peg$FAILED) {
8944
- s2 = null;
8945
- }
8946
- s3 = peg$currPos;
8947
- s4 = [];
8373
+ s2 = peg$currPos;
8374
+ s3 = [];
8375
+ s4 = peg$currPos;
8948
8376
  s5 = peg$currPos;
8949
- s6 = peg$currPos;
8950
8377
  peg$silentFails++;
8951
- s7 = peg$currPos;
8952
- if (input.charCodeAt(peg$currPos) === 32) {
8953
- s8 = peg$c12;
8954
- peg$currPos++;
8955
- }
8956
- else {
8957
- s8 = peg$FAILED;
8958
- if (peg$silentFails === 0) {
8959
- peg$fail(peg$e16);
8960
- }
8961
- }
8962
- if (s8 === peg$FAILED) {
8963
- s8 = null;
8964
- }
8965
- s9 = peg$parseHighlightTag();
8966
- if (s9 !== peg$FAILED) {
8967
- s8 = [s8, s9];
8968
- s7 = s8;
8969
- }
8970
- else {
8971
- peg$currPos = s7;
8972
- s7 = peg$FAILED;
8973
- }
8378
+ s6 = peg$parseHighlightTag();
8974
8379
  peg$silentFails--;
8975
- if (s7 === peg$FAILED) {
8976
- s6 = undefined;
8380
+ if (s6 === peg$FAILED) {
8381
+ s5 = undefined;
8977
8382
  }
8978
8383
  else {
8979
- peg$currPos = s6;
8980
- s6 = peg$FAILED;
8384
+ peg$currPos = s5;
8385
+ s5 = peg$FAILED;
8981
8386
  }
8982
- if (s6 !== peg$FAILED) {
8387
+ if (s5 !== peg$FAILED) {
8983
8388
  if (input.length > peg$currPos) {
8984
- s7 = input.charAt(peg$currPos);
8389
+ s6 = input.charAt(peg$currPos);
8985
8390
  peg$currPos++;
8986
8391
  }
8987
8392
  else {
8988
- s7 = peg$FAILED;
8393
+ s6 = peg$FAILED;
8989
8394
  if (peg$silentFails === 0) {
8990
8395
  peg$fail(peg$e0);
8991
8396
  }
8992
8397
  }
8993
- if (s7 !== peg$FAILED) {
8994
- s6 = [s6, s7];
8995
- s5 = s6;
8398
+ if (s6 !== peg$FAILED) {
8399
+ s5 = [s5, s6];
8400
+ s4 = s5;
8996
8401
  }
8997
8402
  else {
8998
- peg$currPos = s5;
8999
- s5 = peg$FAILED;
8403
+ peg$currPos = s4;
8404
+ s4 = peg$FAILED;
9000
8405
  }
9001
8406
  }
9002
8407
  else {
9003
- peg$currPos = s5;
9004
- s5 = peg$FAILED;
8408
+ peg$currPos = s4;
8409
+ s4 = peg$FAILED;
9005
8410
  }
9006
- while (s5 !== peg$FAILED) {
9007
- s4.push(s5);
8411
+ while (s4 !== peg$FAILED) {
8412
+ s3.push(s4);
8413
+ s4 = peg$currPos;
9008
8414
  s5 = peg$currPos;
9009
- s6 = peg$currPos;
9010
8415
  peg$silentFails++;
9011
- s7 = peg$currPos;
9012
- if (input.charCodeAt(peg$currPos) === 32) {
9013
- s8 = peg$c12;
9014
- peg$currPos++;
9015
- }
9016
- else {
9017
- s8 = peg$FAILED;
9018
- if (peg$silentFails === 0) {
9019
- peg$fail(peg$e16);
9020
- }
9021
- }
9022
- if (s8 === peg$FAILED) {
9023
- s8 = null;
9024
- }
9025
- s9 = peg$parseHighlightTag();
9026
- if (s9 !== peg$FAILED) {
9027
- s8 = [s8, s9];
9028
- s7 = s8;
9029
- }
9030
- else {
9031
- peg$currPos = s7;
9032
- s7 = peg$FAILED;
9033
- }
8416
+ s6 = peg$parseHighlightTag();
9034
8417
  peg$silentFails--;
9035
- if (s7 === peg$FAILED) {
9036
- s6 = undefined;
8418
+ if (s6 === peg$FAILED) {
8419
+ s5 = undefined;
9037
8420
  }
9038
8421
  else {
9039
- peg$currPos = s6;
9040
- s6 = peg$FAILED;
8422
+ peg$currPos = s5;
8423
+ s5 = peg$FAILED;
9041
8424
  }
9042
- if (s6 !== peg$FAILED) {
8425
+ if (s5 !== peg$FAILED) {
9043
8426
  if (input.length > peg$currPos) {
9044
- s7 = input.charAt(peg$currPos);
8427
+ s6 = input.charAt(peg$currPos);
9045
8428
  peg$currPos++;
9046
8429
  }
9047
8430
  else {
9048
- s7 = peg$FAILED;
8431
+ s6 = peg$FAILED;
9049
8432
  if (peg$silentFails === 0) {
9050
8433
  peg$fail(peg$e0);
9051
8434
  }
9052
8435
  }
9053
- if (s7 !== peg$FAILED) {
9054
- s6 = [s6, s7];
9055
- s5 = s6;
8436
+ if (s6 !== peg$FAILED) {
8437
+ s5 = [s5, s6];
8438
+ s4 = s5;
9056
8439
  }
9057
8440
  else {
9058
- peg$currPos = s5;
9059
- s5 = peg$FAILED;
8441
+ peg$currPos = s4;
8442
+ s4 = peg$FAILED;
9060
8443
  }
9061
8444
  }
9062
8445
  else {
9063
- peg$currPos = s5;
9064
- s5 = peg$FAILED;
9065
- }
9066
- }
9067
- s3 = input.substring(s3, peg$currPos);
9068
- if (input.charCodeAt(peg$currPos) === 32) {
9069
- s4 = peg$c12;
9070
- peg$currPos++;
9071
- }
9072
- else {
9073
- s4 = peg$FAILED;
9074
- if (peg$silentFails === 0) {
9075
- peg$fail(peg$e16);
8446
+ peg$currPos = s4;
8447
+ s4 = peg$FAILED;
9076
8448
  }
9077
8449
  }
9078
- if (s4 === peg$FAILED) {
9079
- s4 = null;
9080
- }
9081
- s5 = peg$parseHighlightTag();
9082
- if (s5 !== peg$FAILED) {
8450
+ s2 = input.substring(s2, peg$currPos);
8451
+ s3 = peg$parseHighlightTag();
8452
+ if (s3 !== peg$FAILED) {
9083
8453
  peg$savedPos = s0;
9084
- s0 = peg$f95(s3);
8454
+ s0 = peg$f95(s2);
9085
8455
  }
9086
8456
  else {
9087
8457
  peg$currPos = s0;