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