@gmb/bitmark-parser-generator 5.30.0 → 5.31.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli/main.js CHANGED
@@ -3201,10 +3201,17 @@ var CARDSETS = {
3201
3201
  ]
3202
3202
  },
3203
3203
  {
3204
+ // matchMatrix cells are NESTED (`cells[$s]`), unlike matchPairs'
3205
+ // flat pair object — so `isCaseSensitive` must be written INTO the
3206
+ // cell, mirroring the sibling `example` rule above (`cells: { $s:
3207
+ // {...} }`). The earlier flat `{ isCaseSensitive: '$' }` (copied
3208
+ // from matchPairs) wrote at bit scope, so an authored cell-side
3209
+ // `[@isCaseSensitive:false]` (e.g. on a `++` value) was dropped
3210
+ // instead of landing on the cell. PLAN-122.
3204
3211
  key: ConfigKey.property_isCaseSensitive,
3205
3212
  exportJsonKey: [
3206
- { "@absent": { isCaseSensitive: "$ancestor" } },
3207
- { isCaseSensitive: "$" }
3213
+ { "@absent": { cells: { $s: { isCaseSensitive: "$ancestor" } } } },
3214
+ { cells: { $s: { isCaseSensitive: "$" } } }
3208
3215
  ],
3209
3216
  description: "Property to indicate if the match is case sensitive.",
3210
3217
  format: TagFormat.boolean
@@ -13861,7 +13868,7 @@ var instance2 = new Config();
13861
13868
  // src/generated/package_info.ts
13862
13869
  var PACKAGE_INFO = {
13863
13870
  "name": "@gmb/bitmark-parser-generator",
13864
- "version": "5.30.0",
13871
+ "version": "5.31.1",
13865
13872
  "license": "ISC"};
13866
13873
  var Environment = {
13867
13874
  unknown: "",
@@ -16828,26 +16835,26 @@ function peg$parse(input, options) {
16828
16835
  bitmarkMinusMinusString: peg$parsebitmarkMinusMinusString
16829
16836
  };
16830
16837
  let peg$startRuleFunction = peg$parseversion;
16831
- const peg$c0 = " ";
16832
- const peg$c1 = "|";
16833
- const peg$c2 = "### ";
16834
- const peg$c3 = "## ";
16835
- const peg$c4 = "# ";
16836
- const peg$c5 = "code";
16837
- const peg$c6 = ":";
16838
- const peg$c7 = "bitmark++";
16839
- const peg$c8 = "bitmark--";
16840
- const peg$c9 = "JavaScript";
16841
- const peg$c10 = "\u2022 ";
16842
- const peg$c11 = "\u2022_ ";
16843
- const peg$c12 = "\u2022";
16844
- const peg$c13 = " ";
16845
- const peg$c14 = "I ";
16846
- const peg$c15 = "i ";
16847
- const peg$c16 = "\u2022A ";
16848
- const peg$c17 = "\u2022a ";
16849
- const peg$c18 = "\u2022+ ";
16850
- const peg$c19 = "\u2022- ";
16838
+ const peg$c0 = "|";
16839
+ const peg$c1 = "### ";
16840
+ const peg$c2 = "## ";
16841
+ const peg$c3 = "# ";
16842
+ const peg$c4 = "code";
16843
+ const peg$c5 = ":";
16844
+ const peg$c6 = "bitmark++";
16845
+ const peg$c7 = "bitmark--";
16846
+ const peg$c8 = "JavaScript";
16847
+ const peg$c9 = "\u2022 ";
16848
+ const peg$c10 = "\u2022_ ";
16849
+ const peg$c11 = "\u2022";
16850
+ const peg$c12 = " ";
16851
+ const peg$c13 = "I ";
16852
+ const peg$c14 = "i ";
16853
+ const peg$c15 = "\u2022A ";
16854
+ const peg$c16 = "\u2022a ";
16855
+ const peg$c17 = "\u2022+ ";
16856
+ const peg$c18 = "\u2022- ";
16857
+ const peg$c19 = " ";
16851
16858
  const peg$c20 = "image";
16852
16859
  const peg$c21 = "#";
16853
16860
  const peg$c22 = "@";
@@ -16979,28 +16986,28 @@ function peg$parse(input, options) {
16979
16986
  const peg$r4 = /^[!#-;=?-[\]-_a-{}-~]/;
16980
16987
  const peg$e0 = peg$anyExpectation();
16981
16988
  const peg$e1 = peg$otherExpectation("StyledText");
16982
- const peg$e2 = peg$literalExpectation(" ", false);
16983
- const peg$e3 = peg$literalExpectation("|", false);
16984
- const peg$e4 = peg$literalExpectation("### ", false);
16985
- const peg$e5 = peg$literalExpectation("## ", false);
16986
- const peg$e6 = peg$literalExpectation("# ", false);
16987
- const peg$e7 = peg$literalExpectation("code", false);
16988
- const peg$e8 = peg$classExpectation([" ", " "], false, false, false);
16989
- const peg$e9 = peg$literalExpectation(":", false);
16990
- const peg$e10 = peg$literalExpectation("bitmark++", false);
16991
- const peg$e11 = peg$literalExpectation("bitmark--", false);
16992
- const peg$e12 = peg$literalExpectation("JavaScript", false);
16993
- const peg$e13 = peg$literalExpectation("\u2022 ", false);
16994
- const peg$e14 = peg$literalExpectation("\u2022_ ", false);
16995
- const peg$e15 = peg$literalExpectation("\u2022", false);
16996
- const peg$e16 = peg$classExpectation([["0", "9"]], false, false, false);
16997
- const peg$e17 = peg$literalExpectation(" ", false);
16998
- const peg$e18 = peg$literalExpectation("I ", false);
16999
- const peg$e19 = peg$literalExpectation("i ", false);
17000
- const peg$e20 = peg$literalExpectation("\u2022A ", false);
17001
- const peg$e21 = peg$literalExpectation("\u2022a ", false);
17002
- const peg$e22 = peg$literalExpectation("\u2022+ ", false);
17003
- const peg$e23 = peg$literalExpectation("\u2022- ", false);
16989
+ const peg$e2 = peg$literalExpectation("|", false);
16990
+ const peg$e3 = peg$literalExpectation("### ", false);
16991
+ const peg$e4 = peg$literalExpectation("## ", false);
16992
+ const peg$e5 = peg$literalExpectation("# ", false);
16993
+ const peg$e6 = peg$literalExpectation("code", false);
16994
+ const peg$e7 = peg$classExpectation([" ", " "], false, false, false);
16995
+ const peg$e8 = peg$literalExpectation(":", false);
16996
+ const peg$e9 = peg$literalExpectation("bitmark++", false);
16997
+ const peg$e10 = peg$literalExpectation("bitmark--", false);
16998
+ const peg$e11 = peg$literalExpectation("JavaScript", false);
16999
+ const peg$e12 = peg$literalExpectation("\u2022 ", false);
17000
+ const peg$e13 = peg$literalExpectation("\u2022_ ", false);
17001
+ const peg$e14 = peg$literalExpectation("\u2022", false);
17002
+ const peg$e15 = peg$classExpectation([["0", "9"]], false, false, false);
17003
+ const peg$e16 = peg$literalExpectation(" ", false);
17004
+ const peg$e17 = peg$literalExpectation("I ", false);
17005
+ const peg$e18 = peg$literalExpectation("i ", false);
17006
+ const peg$e19 = peg$literalExpectation("\u2022A ", false);
17007
+ const peg$e20 = peg$literalExpectation("\u2022a ", false);
17008
+ const peg$e21 = peg$literalExpectation("\u2022+ ", false);
17009
+ const peg$e22 = peg$literalExpectation("\u2022- ", false);
17010
+ const peg$e23 = peg$literalExpectation(" ", false);
17004
17011
  const peg$e24 = peg$literalExpectation("image", false);
17005
17012
  const peg$e25 = peg$literalExpectation("#", false);
17006
17013
  const peg$e26 = peg$literalExpectation("@", false);
@@ -17176,14 +17183,15 @@ function peg$parse(input, options) {
17176
17183
  function peg$f13(t) {
17177
17184
  return t;
17178
17185
  }
17179
- function peg$f14(b) {
17180
- return b;
17186
+ function peg$f14(c, bl) {
17187
+ return { ...c, content: bl, attrs: {} };
17181
17188
  }
17182
17189
  function peg$f15(c, bl) {
17183
17190
  return { ...c, content: bl, attrs: {} };
17184
17191
  }
17185
17192
  function peg$f16(c, bl) {
17186
- return { ...c, content: bl, attrs: {} };
17193
+ let start = bl[0]._tempListStart;
17194
+ return { ...c, attrs: { start }, content: bl };
17187
17195
  }
17188
17196
  function peg$f17(c, bl) {
17189
17197
  let start = bl[0]._tempListStart;
@@ -17194,8 +17202,7 @@ function peg$parse(input, options) {
17194
17202
  return { ...c, attrs: { start }, content: bl };
17195
17203
  }
17196
17204
  function peg$f19(c, bl) {
17197
- let start = bl[0]._tempListStart;
17198
- return { ...c, attrs: { start }, content: bl };
17205
+ return { ...c, content: bl, attrs: {} };
17199
17206
  }
17200
17207
  function peg$f20(c, bl) {
17201
17208
  return { ...c, content: bl, attrs: {} };
@@ -17203,41 +17210,34 @@ function peg$parse(input, options) {
17203
17210
  function peg$f21(c, bl) {
17204
17211
  return { ...c, content: bl, attrs: {} };
17205
17212
  }
17206
- function peg$f22(c, bl) {
17207
- return { ...c, content: bl, attrs: {} };
17208
- }
17209
- function peg$f23(i) {
17210
- indentStack = [];
17211
- indent = i.join("");
17212
- }
17213
- function peg$f24() {
17213
+ function peg$f22() {
17214
17214
  return { type: "bulletList" };
17215
17215
  }
17216
- function peg$f25() {
17216
+ function peg$f23() {
17217
17217
  return { type: "noBulletList" };
17218
17218
  }
17219
- function peg$f26() {
17219
+ function peg$f24() {
17220
17220
  return { type: "orderedList" };
17221
17221
  }
17222
- function peg$f27() {
17222
+ function peg$f25() {
17223
17223
  return { type: "orderedListRoman" };
17224
17224
  }
17225
- function peg$f28() {
17225
+ function peg$f26() {
17226
17226
  return { type: "orderedListRomanLower" };
17227
17227
  }
17228
- function peg$f29() {
17228
+ function peg$f27() {
17229
17229
  return { type: "letteredList" };
17230
17230
  }
17231
- function peg$f30() {
17231
+ function peg$f28() {
17232
17232
  return { type: "letteredListLower" };
17233
17233
  }
17234
- function peg$f31() {
17234
+ function peg$f29() {
17235
17235
  return { type: "taskList" };
17236
17236
  }
17237
- function peg$f32(lt, listItem, lines, c) {
17237
+ function peg$f30(lt, listItem, lines, c) {
17238
17238
  return c;
17239
17239
  }
17240
- function peg$f33(lt, listItem, lines, children) {
17240
+ function peg$f31(lt, listItem, lines, children) {
17241
17241
  let _tempParsingParent = "bulletList";
17242
17242
  const matchOrdered = lt.match(/•([0-9]+)([Ii]?) /);
17243
17243
  let start = 1;
@@ -17306,36 +17306,36 @@ function peg$parse(input, options) {
17306
17306
  return { type: t, content, _tempParsingParent, _tempListStart };
17307
17307
  }
17308
17308
  }
17309
- function peg$f34(ll) {
17309
+ function peg$f32(ll) {
17310
17310
  return ll;
17311
17311
  }
17312
- function peg$f35(i) {
17312
+ function peg$f33(i) {
17313
17313
  return i.join("") === indent;
17314
17314
  }
17315
- function peg$f36(i) {
17315
+ function peg$f34(i) {
17316
17316
  return i.length > indent.length;
17317
17317
  }
17318
- function peg$f37(i) {
17318
+ function peg$f35(i) {
17319
17319
  indentStack.push(indent);
17320
17320
  indent = i.join("");
17321
17321
  }
17322
- function peg$f38() {
17322
+ function peg$f36() {
17323
17323
  indent = indentStack.pop();
17324
17324
  return true;
17325
17325
  }
17326
- function peg$f39(body) {
17326
+ function peg$f37(body) {
17327
17327
  return { type: "paragraph", content: bitmarkPlusString(body.trim()), attrs: {} };
17328
17328
  }
17329
- function peg$f40(body) {
17329
+ function peg$f38(body) {
17330
17330
  return { type: "paragraph", content: bitmarkPlusString(body.trim()), attrs: {} };
17331
17331
  }
17332
- function peg$f41(body) {
17332
+ function peg$f39(body) {
17333
17333
  return { type: "paragraph", content: bitmarkPlusString(body.trim()), attrs: {} };
17334
17334
  }
17335
- function peg$f42(t) {
17335
+ function peg$f40(t) {
17336
17336
  return t;
17337
17337
  }
17338
- function peg$f43(t, u, ch) {
17338
+ function peg$f41(t, u, ch) {
17339
17339
  const chain = Object.assign({}, ...ch);
17340
17340
  let imageAlignment_ = chain.alignment || "center";
17341
17341
  delete chain.alignment;
@@ -17364,185 +17364,185 @@ function peg$parse(input, options) {
17364
17364
  };
17365
17365
  return image;
17366
17366
  }
17367
- function peg$f44(ch) {
17367
+ function peg$f42(ch) {
17368
17368
  return ch;
17369
17369
  }
17370
- function peg$f45(str) {
17370
+ function peg$f43(str) {
17371
17371
  return { comment: str.trim() };
17372
17372
  }
17373
- function peg$f46(p, v) {
17373
+ function peg$f44(p, v) {
17374
17374
  return { [p]: parseInt(v) };
17375
17375
  }
17376
- function peg$f47(p, v) {
17376
+ function peg$f45(p, v) {
17377
17377
  return { [p]: v.trim() };
17378
17378
  }
17379
- function peg$f48(p, v) {
17379
+ function peg$f46(p, v) {
17380
17380
  return { [p]: v };
17381
17381
  }
17382
- function peg$f49(p, v) {
17382
+ function peg$f47(p, v) {
17383
17383
  return { [p]: v };
17384
17384
  }
17385
- function peg$f50(p) {
17385
+ function peg$f48(p) {
17386
17386
  return { [p]: true };
17387
17387
  }
17388
- function peg$f51() {
17388
+ function peg$f49() {
17389
17389
  return;
17390
17390
  }
17391
- function peg$f52(p) {
17391
+ function peg$f50(p) {
17392
17392
  return { error: "Found unknown property or invalid value: " + p };
17393
17393
  }
17394
- function peg$f53(bs) {
17394
+ function peg$f51(bs) {
17395
17395
  return [{ type: "paragraph", content: bs, attrs: {} }];
17396
17396
  }
17397
- function peg$f54(first, more) {
17397
+ function peg$f52(first, more) {
17398
17398
  const cleaned_ = cleanEmptyTextNodes(first ? [first, ...more.flat()] : more.flat());
17399
17399
  return cleaned_;
17400
17400
  }
17401
- function peg$f55() {
17401
+ function peg$f53() {
17402
17402
  return { "type": "hardBreak" };
17403
17403
  }
17404
- function peg$f56(t) {
17404
+ function peg$f54(t) {
17405
17405
  return { text: unbreakscape(t), type: "text" };
17406
17406
  }
17407
- function peg$f57(t) {
17407
+ function peg$f55(t) {
17408
17408
  return { index: +t, type: "bit" };
17409
17409
  }
17410
- function peg$f58(t) {
17410
+ function peg$f56(t) {
17411
17411
  return { attrs: { formula: unbreakscape(t) }, type: "latex" };
17412
17412
  }
17413
- function peg$f59(alt, u, ch) {
17413
+ function peg$f57(alt, u, ch) {
17414
17414
  return { attrs: { alt, src: (u.pr + u.t).trim(), ...Object.assign({}, ...ch), zoomDisabled: true }, type: "imageInline" };
17415
17415
  }
17416
- function peg$f60(t, marks) {
17416
+ function peg$f58(t, marks) {
17417
17417
  if (!marks) marks = [];
17418
17418
  return { marks, text: unbreakscape(t), type: "text" };
17419
17419
  }
17420
- function peg$f61(t) {
17420
+ function peg$f59(t) {
17421
17421
  return { marks: [{ type: "bold" }], text: unbreakscape(t), type: "text" };
17422
17422
  }
17423
- function peg$f62(t) {
17423
+ function peg$f60(t) {
17424
17424
  return { marks: [{ type: "italic" }], text: unbreakscape(t), type: "text" };
17425
17425
  }
17426
- function peg$f63(t) {
17426
+ function peg$f61(t) {
17427
17427
  return { marks: [{ type: "light" }], text: unbreakscape(t), type: "text" };
17428
17428
  }
17429
- function peg$f64(t) {
17429
+ function peg$f62(t) {
17430
17430
  return { marks: [{ type: "highlight" }], text: unbreakscape(t), type: "text" };
17431
17431
  }
17432
- function peg$f65(u) {
17432
+ function peg$f63(u) {
17433
17433
  return { marks: [{ type: "link", attrs: { href: (u.pr + u.t).trim(), target: "_blank" } }], text: u.t, type: "text" };
17434
17434
  }
17435
- function peg$f66(ch) {
17435
+ function peg$f64(ch) {
17436
17436
  return ch;
17437
17437
  }
17438
- function peg$f67(ch) {
17438
+ function peg$f65(ch) {
17439
17439
  return ch;
17440
17440
  }
17441
- function peg$f68(str) {
17441
+ function peg$f66(str) {
17442
17442
  return { comment: str };
17443
17443
  }
17444
- function peg$f69(p, v) {
17444
+ function peg$f67(p, v) {
17445
17445
  return { [p]: v };
17446
17446
  }
17447
- function peg$f70(p, v) {
17447
+ function peg$f68(p, v) {
17448
17448
  return { [p]: parseInt(v) };
17449
17449
  }
17450
- function peg$f71(p, v) {
17450
+ function peg$f69(p, v) {
17451
17451
  return { type: "error", msg: p + " must be a positive integer.", found: v };
17452
17452
  }
17453
- function peg$f72(p, v) {
17453
+ function peg$f70(p, v) {
17454
17454
  return { [p]: v };
17455
17455
  }
17456
- function peg$f73(p, v) {
17456
+ function peg$f71(p, v) {
17457
17457
  return { [p]: v };
17458
17458
  }
17459
- function peg$f74(str) {
17459
+ function peg$f72(str) {
17460
17460
  return { type: "link", attrs: { href: str.trim(), target: "_blank" } };
17461
17461
  }
17462
- function peg$f75(str, rc, p) {
17462
+ function peg$f73(str, rc, p) {
17463
17463
  return { type: "extref", attrs: { extref: str.trim(), references: rc, provider: p.trim() } };
17464
17464
  }
17465
- function peg$f76(str, str2) {
17465
+ function peg$f74(str, str2) {
17466
17466
  return { type: "xref", attrs: { xref: str.trim(), reference: str2.trim() } };
17467
17467
  }
17468
- function peg$f77(str) {
17468
+ function peg$f75(str) {
17469
17469
  return { type: "xref", attrs: { xref: str.trim(), reference: "" } };
17470
17470
  }
17471
- function peg$f78(str) {
17471
+ function peg$f76(str) {
17472
17472
  return { type: "ref", attrs: { reference: str.trim() } };
17473
17473
  }
17474
- function peg$f79(str, ch) {
17474
+ function peg$f77(str, ch) {
17475
17475
  const chain = Object.assign({}, ...ch);
17476
17476
  return { type: "symbol", attrs: { src: str.trim(), ...chain } };
17477
17477
  }
17478
- function peg$f80(str) {
17478
+ function peg$f78(str) {
17479
17479
  return { type: "footnote", attrs: { content: bitmarkPlusString(str.trim()) } };
17480
17480
  }
17481
- function peg$f81(str) {
17481
+ function peg$f79(str) {
17482
17482
  return { type: "footnote*", attrs: { content: bitmarkPlusString(str.trim()) } };
17483
17483
  }
17484
- function peg$f82(str) {
17484
+ function peg$f80(str) {
17485
17485
  return { type: "var", attrs: { name: str.trim() } };
17486
17486
  }
17487
- function peg$f83() {
17487
+ function peg$f81() {
17488
17488
  return { type: "code", attrs: { language: "plain text" } };
17489
17489
  }
17490
- function peg$f84(lang) {
17490
+ function peg$f82(lang) {
17491
17491
  return { type: "code", attrs: { language: lang.trim().toLowerCase() } };
17492
17492
  }
17493
- function peg$f85() {
17493
+ function peg$f83() {
17494
17494
  return { type: "timer", attrs: { name: "" } };
17495
17495
  }
17496
- function peg$f86(str) {
17496
+ function peg$f84(str) {
17497
17497
  return { type: "timer", attrs: { name: str.trim() } };
17498
17498
  }
17499
- function peg$f87(str) {
17499
+ function peg$f85(str) {
17500
17500
  return { type: "duration", attrs: { duration: str } };
17501
17501
  }
17502
- function peg$f88(color) {
17502
+ function peg$f86(color) {
17503
17503
  return { type: "color", attrs: { color } };
17504
17504
  }
17505
- function peg$f89(str) {
17505
+ function peg$f87(str) {
17506
17506
  return { type: "colorPicker", attrs: { propertyRef: str.trim() } };
17507
17507
  }
17508
- function peg$f90(style) {
17508
+ function peg$f88(style) {
17509
17509
  return { type: style };
17510
17510
  }
17511
- function peg$f91(str) {
17511
+ function peg$f89(str) {
17512
17512
  return { type: "comment", comment: str };
17513
17513
  }
17514
- function peg$f92(r) {
17514
+ function peg$f90(r) {
17515
17515
  return r.trim();
17516
17516
  }
17517
- function peg$f93(bs) {
17517
+ function peg$f91(bs) {
17518
17518
  return [{ type: "paragraph", content: bs, attrs: {} }];
17519
17519
  }
17520
- function peg$f94(first, more) {
17520
+ function peg$f92(first, more) {
17521
17521
  const cleaned_ = cleanEmptyTextNodes(first ? [first, ...more.flat()] : more.flat());
17522
17522
  return cleaned_;
17523
17523
  }
17524
- function peg$f95() {
17524
+ function peg$f93() {
17525
17525
  return { "type": "hardBreak" };
17526
17526
  }
17527
- function peg$f96(t) {
17527
+ function peg$f94(t) {
17528
17528
  return { text: unbreakscape(t), type: "text" };
17529
17529
  }
17530
- function peg$f97(t) {
17530
+ function peg$f95(t) {
17531
17531
  return { index: +t, type: "bit" };
17532
17532
  }
17533
- function peg$f98(t) {
17533
+ function peg$f96(t) {
17534
17534
  return { marks: [{ type: "bold" }], text: unbreakscape(t), type: "text" };
17535
17535
  }
17536
- function peg$f99(t) {
17536
+ function peg$f97(t) {
17537
17537
  return { marks: [{ type: "italic" }], text: unbreakscape(t), type: "text" };
17538
17538
  }
17539
- function peg$f100(t) {
17539
+ function peg$f98(t) {
17540
17540
  return { marks: [{ type: "light" }], text: unbreakscape(t), type: "text" };
17541
17541
  }
17542
- function peg$f101(t) {
17542
+ function peg$f99(t) {
17543
17543
  return { marks: [{ type: "highlight" }], text: unbreakscape(t), type: "text" };
17544
17544
  }
17545
- function peg$f102(pr, t) {
17545
+ function peg$f100(pr, t) {
17546
17546
  return { pr, t };
17547
17547
  }
17548
17548
  let peg$currPos = options.peg$currPos | 0;
@@ -17743,40 +17743,10 @@ function peg$parse(input, options) {
17743
17743
  return s0;
17744
17744
  }
17745
17745
  function peg$parseBlockStart() {
17746
- let s0, s1, s2;
17746
+ let s0;
17747
17747
  s0 = peg$parseTitleTags();
17748
17748
  if (s0 === peg$FAILED) {
17749
- s0 = peg$currPos;
17750
- s1 = [];
17751
- if (input.charCodeAt(peg$currPos) === 9) {
17752
- s2 = peg$c0;
17753
- peg$currPos++;
17754
- } else {
17755
- s2 = peg$FAILED;
17756
- if (peg$silentFails === 0) {
17757
- peg$fail(peg$e2);
17758
- }
17759
- }
17760
- while (s2 !== peg$FAILED) {
17761
- s1.push(s2);
17762
- if (input.charCodeAt(peg$currPos) === 9) {
17763
- s2 = peg$c0;
17764
- peg$currPos++;
17765
- } else {
17766
- s2 = peg$FAILED;
17767
- if (peg$silentFails === 0) {
17768
- peg$fail(peg$e2);
17769
- }
17770
- }
17771
- }
17772
- s2 = peg$parseListTags();
17773
- if (s2 !== peg$FAILED) {
17774
- s1 = [s1, s2];
17775
- s0 = s1;
17776
- } else {
17777
- peg$currPos = s0;
17778
- s0 = peg$FAILED;
17779
- }
17749
+ s0 = peg$parseListTags();
17780
17750
  if (s0 === peg$FAILED) {
17781
17751
  s0 = peg$parseImageBlock();
17782
17752
  if (s0 === peg$FAILED) {
@@ -17792,12 +17762,12 @@ function peg$parse(input, options) {
17792
17762
  function peg$parseBlockTag() {
17793
17763
  let s0;
17794
17764
  if (input.charCodeAt(peg$currPos) === 124) {
17795
- s0 = peg$c1;
17765
+ s0 = peg$c0;
17796
17766
  peg$currPos++;
17797
17767
  } else {
17798
17768
  s0 = peg$FAILED;
17799
17769
  if (peg$silentFails === 0) {
17800
- peg$fail(peg$e3);
17770
+ peg$fail(peg$e2);
17801
17771
  }
17802
17772
  }
17803
17773
  return s0;
@@ -17812,33 +17782,33 @@ function peg$parse(input, options) {
17812
17782
  }
17813
17783
  function peg$parseTitleTags() {
17814
17784
  let s0;
17815
- if (input.substr(peg$currPos, 4) === peg$c2) {
17816
- s0 = peg$c2;
17785
+ if (input.substr(peg$currPos, 4) === peg$c1) {
17786
+ s0 = peg$c1;
17817
17787
  peg$currPos += 4;
17818
17788
  } else {
17819
17789
  s0 = peg$FAILED;
17820
17790
  if (peg$silentFails === 0) {
17821
- peg$fail(peg$e4);
17791
+ peg$fail(peg$e3);
17822
17792
  }
17823
17793
  }
17824
17794
  if (s0 === peg$FAILED) {
17825
- if (input.substr(peg$currPos, 3) === peg$c3) {
17826
- s0 = peg$c3;
17795
+ if (input.substr(peg$currPos, 3) === peg$c2) {
17796
+ s0 = peg$c2;
17827
17797
  peg$currPos += 3;
17828
17798
  } else {
17829
17799
  s0 = peg$FAILED;
17830
17800
  if (peg$silentFails === 0) {
17831
- peg$fail(peg$e5);
17801
+ peg$fail(peg$e4);
17832
17802
  }
17833
17803
  }
17834
17804
  if (s0 === peg$FAILED) {
17835
- if (input.substr(peg$currPos, 2) === peg$c4) {
17836
- s0 = peg$c4;
17805
+ if (input.substr(peg$currPos, 2) === peg$c3) {
17806
+ s0 = peg$c3;
17837
17807
  peg$currPos += 2;
17838
17808
  } else {
17839
17809
  s0 = peg$FAILED;
17840
17810
  if (peg$silentFails === 0) {
17841
- peg$fail(peg$e6);
17811
+ peg$fail(peg$e5);
17842
17812
  }
17843
17813
  }
17844
17814
  }
@@ -17877,13 +17847,13 @@ function peg$parse(input, options) {
17877
17847
  }
17878
17848
  function peg$parseCodeType() {
17879
17849
  let s0;
17880
- if (input.substr(peg$currPos, 4) === peg$c5) {
17881
- s0 = peg$c5;
17850
+ if (input.substr(peg$currPos, 4) === peg$c4) {
17851
+ s0 = peg$c4;
17882
17852
  peg$currPos += 4;
17883
17853
  } else {
17884
17854
  s0 = peg$FAILED;
17885
17855
  if (peg$silentFails === 0) {
17886
- peg$fail(peg$e7);
17856
+ peg$fail(peg$e6);
17887
17857
  }
17888
17858
  }
17889
17859
  return s0;
@@ -17933,7 +17903,7 @@ function peg$parse(input, options) {
17933
17903
  } else {
17934
17904
  s5 = peg$FAILED;
17935
17905
  if (peg$silentFails === 0) {
17936
- peg$fail(peg$e8);
17906
+ peg$fail(peg$e7);
17937
17907
  }
17938
17908
  }
17939
17909
  while (s5 !== peg$FAILED) {
@@ -17944,7 +17914,7 @@ function peg$parse(input, options) {
17944
17914
  } else {
17945
17915
  s5 = peg$FAILED;
17946
17916
  if (peg$silentFails === 0) {
17947
- peg$fail(peg$e8);
17917
+ peg$fail(peg$e7);
17948
17918
  }
17949
17919
  }
17950
17920
  }
@@ -17976,12 +17946,12 @@ function peg$parse(input, options) {
17976
17946
  s1 = peg$parseCodeTag();
17977
17947
  if (s1 !== peg$FAILED) {
17978
17948
  if (input.charCodeAt(peg$currPos) === 58) {
17979
- s2 = peg$c6;
17949
+ s2 = peg$c5;
17980
17950
  peg$currPos++;
17981
17951
  } else {
17982
17952
  s2 = peg$FAILED;
17983
17953
  if (peg$silentFails === 0) {
17984
- peg$fail(peg$e9);
17954
+ peg$fail(peg$e8);
17985
17955
  }
17986
17956
  }
17987
17957
  if (s2 !== peg$FAILED) {
@@ -17996,7 +17966,7 @@ function peg$parse(input, options) {
17996
17966
  } else {
17997
17967
  s7 = peg$FAILED;
17998
17968
  if (peg$silentFails === 0) {
17999
- peg$fail(peg$e8);
17969
+ peg$fail(peg$e7);
18000
17970
  }
18001
17971
  }
18002
17972
  while (s7 !== peg$FAILED) {
@@ -18007,7 +17977,7 @@ function peg$parse(input, options) {
18007
17977
  } else {
18008
17978
  s7 = peg$FAILED;
18009
17979
  if (peg$silentFails === 0) {
18010
- peg$fail(peg$e8);
17980
+ peg$fail(peg$e7);
18011
17981
  }
18012
17982
  }
18013
17983
  }
@@ -18047,33 +18017,33 @@ function peg$parse(input, options) {
18047
18017
  }
18048
18018
  function peg$parseCodeLanguage() {
18049
18019
  let s0, s1, s2;
18050
- if (input.substr(peg$currPos, 9) === peg$c7) {
18051
- s0 = peg$c7;
18020
+ if (input.substr(peg$currPos, 9) === peg$c6) {
18021
+ s0 = peg$c6;
18052
18022
  peg$currPos += 9;
18053
18023
  } else {
18054
18024
  s0 = peg$FAILED;
18055
18025
  if (peg$silentFails === 0) {
18056
- peg$fail(peg$e10);
18026
+ peg$fail(peg$e9);
18057
18027
  }
18058
18028
  }
18059
18029
  if (s0 === peg$FAILED) {
18060
- if (input.substr(peg$currPos, 9) === peg$c8) {
18061
- s0 = peg$c8;
18030
+ if (input.substr(peg$currPos, 9) === peg$c7) {
18031
+ s0 = peg$c7;
18062
18032
  peg$currPos += 9;
18063
18033
  } else {
18064
18034
  s0 = peg$FAILED;
18065
18035
  if (peg$silentFails === 0) {
18066
- peg$fail(peg$e11);
18036
+ peg$fail(peg$e10);
18067
18037
  }
18068
18038
  }
18069
18039
  if (s0 === peg$FAILED) {
18070
- if (input.substr(peg$currPos, 10) === peg$c9) {
18071
- s0 = peg$c9;
18040
+ if (input.substr(peg$currPos, 10) === peg$c8) {
18041
+ s0 = peg$c8;
18072
18042
  peg$currPos += 10;
18073
18043
  } else {
18074
18044
  s0 = peg$FAILED;
18075
18045
  if (peg$silentFails === 0) {
18076
- peg$fail(peg$e12);
18046
+ peg$fail(peg$e11);
18077
18047
  }
18078
18048
  }
18079
18049
  if (s0 === peg$FAILED) {
@@ -18177,26 +18147,26 @@ function peg$parse(input, options) {
18177
18147
  }
18178
18148
  function peg$parseBulletListTag() {
18179
18149
  let s0;
18180
- if (input.substr(peg$currPos, 2) === peg$c10) {
18181
- s0 = peg$c10;
18150
+ if (input.substr(peg$currPos, 2) === peg$c9) {
18151
+ s0 = peg$c9;
18182
18152
  peg$currPos += 2;
18183
18153
  } else {
18184
18154
  s0 = peg$FAILED;
18185
18155
  if (peg$silentFails === 0) {
18186
- peg$fail(peg$e13);
18156
+ peg$fail(peg$e12);
18187
18157
  }
18188
18158
  }
18189
18159
  return s0;
18190
18160
  }
18191
18161
  function peg$parseNoBulletListTag() {
18192
18162
  let s0;
18193
- if (input.substr(peg$currPos, 3) === peg$c11) {
18194
- s0 = peg$c11;
18163
+ if (input.substr(peg$currPos, 3) === peg$c10) {
18164
+ s0 = peg$c10;
18195
18165
  peg$currPos += 3;
18196
18166
  } else {
18197
18167
  s0 = peg$FAILED;
18198
18168
  if (peg$silentFails === 0) {
18199
- peg$fail(peg$e14);
18169
+ peg$fail(peg$e13);
18200
18170
  }
18201
18171
  }
18202
18172
  return s0;
@@ -18206,12 +18176,12 @@ function peg$parse(input, options) {
18206
18176
  s0 = peg$currPos;
18207
18177
  s1 = peg$currPos;
18208
18178
  if (input.charCodeAt(peg$currPos) === 8226) {
18209
- s2 = peg$c12;
18179
+ s2 = peg$c11;
18210
18180
  peg$currPos++;
18211
18181
  } else {
18212
18182
  s2 = peg$FAILED;
18213
18183
  if (peg$silentFails === 0) {
18214
- peg$fail(peg$e15);
18184
+ peg$fail(peg$e14);
18215
18185
  }
18216
18186
  }
18217
18187
  if (s2 !== peg$FAILED) {
@@ -18222,7 +18192,7 @@ function peg$parse(input, options) {
18222
18192
  } else {
18223
18193
  s4 = peg$FAILED;
18224
18194
  if (peg$silentFails === 0) {
18225
- peg$fail(peg$e16);
18195
+ peg$fail(peg$e15);
18226
18196
  }
18227
18197
  }
18228
18198
  if (s4 !== peg$FAILED) {
@@ -18234,7 +18204,7 @@ function peg$parse(input, options) {
18234
18204
  } else {
18235
18205
  s4 = peg$FAILED;
18236
18206
  if (peg$silentFails === 0) {
18237
- peg$fail(peg$e16);
18207
+ peg$fail(peg$e15);
18238
18208
  }
18239
18209
  }
18240
18210
  }
@@ -18243,12 +18213,12 @@ function peg$parse(input, options) {
18243
18213
  }
18244
18214
  if (s3 !== peg$FAILED) {
18245
18215
  if (input.charCodeAt(peg$currPos) === 32) {
18246
- s4 = peg$c13;
18216
+ s4 = peg$c12;
18247
18217
  peg$currPos++;
18248
18218
  } else {
18249
18219
  s4 = peg$FAILED;
18250
18220
  if (peg$silentFails === 0) {
18251
- peg$fail(peg$e17);
18221
+ peg$fail(peg$e16);
18252
18222
  }
18253
18223
  }
18254
18224
  if (s4 !== peg$FAILED) {
@@ -18278,12 +18248,12 @@ function peg$parse(input, options) {
18278
18248
  s0 = peg$currPos;
18279
18249
  s1 = peg$currPos;
18280
18250
  if (input.charCodeAt(peg$currPos) === 8226) {
18281
- s2 = peg$c12;
18251
+ s2 = peg$c11;
18282
18252
  peg$currPos++;
18283
18253
  } else {
18284
18254
  s2 = peg$FAILED;
18285
18255
  if (peg$silentFails === 0) {
18286
- peg$fail(peg$e15);
18256
+ peg$fail(peg$e14);
18287
18257
  }
18288
18258
  }
18289
18259
  if (s2 !== peg$FAILED) {
@@ -18294,7 +18264,7 @@ function peg$parse(input, options) {
18294
18264
  } else {
18295
18265
  s4 = peg$FAILED;
18296
18266
  if (peg$silentFails === 0) {
18297
- peg$fail(peg$e16);
18267
+ peg$fail(peg$e15);
18298
18268
  }
18299
18269
  }
18300
18270
  if (s4 !== peg$FAILED) {
@@ -18306,7 +18276,7 @@ function peg$parse(input, options) {
18306
18276
  } else {
18307
18277
  s4 = peg$FAILED;
18308
18278
  if (peg$silentFails === 0) {
18309
- peg$fail(peg$e16);
18279
+ peg$fail(peg$e15);
18310
18280
  }
18311
18281
  }
18312
18282
  }
@@ -18314,13 +18284,13 @@ function peg$parse(input, options) {
18314
18284
  s3 = peg$FAILED;
18315
18285
  }
18316
18286
  if (s3 !== peg$FAILED) {
18317
- if (input.substr(peg$currPos, 2) === peg$c14) {
18318
- s4 = peg$c14;
18287
+ if (input.substr(peg$currPos, 2) === peg$c13) {
18288
+ s4 = peg$c13;
18319
18289
  peg$currPos += 2;
18320
18290
  } else {
18321
18291
  s4 = peg$FAILED;
18322
18292
  if (peg$silentFails === 0) {
18323
- peg$fail(peg$e18);
18293
+ peg$fail(peg$e17);
18324
18294
  }
18325
18295
  }
18326
18296
  if (s4 !== peg$FAILED) {
@@ -18350,12 +18320,12 @@ function peg$parse(input, options) {
18350
18320
  s0 = peg$currPos;
18351
18321
  s1 = peg$currPos;
18352
18322
  if (input.charCodeAt(peg$currPos) === 8226) {
18353
- s2 = peg$c12;
18323
+ s2 = peg$c11;
18354
18324
  peg$currPos++;
18355
18325
  } else {
18356
18326
  s2 = peg$FAILED;
18357
18327
  if (peg$silentFails === 0) {
18358
- peg$fail(peg$e15);
18328
+ peg$fail(peg$e14);
18359
18329
  }
18360
18330
  }
18361
18331
  if (s2 !== peg$FAILED) {
@@ -18366,7 +18336,7 @@ function peg$parse(input, options) {
18366
18336
  } else {
18367
18337
  s4 = peg$FAILED;
18368
18338
  if (peg$silentFails === 0) {
18369
- peg$fail(peg$e16);
18339
+ peg$fail(peg$e15);
18370
18340
  }
18371
18341
  }
18372
18342
  if (s4 !== peg$FAILED) {
@@ -18378,7 +18348,7 @@ function peg$parse(input, options) {
18378
18348
  } else {
18379
18349
  s4 = peg$FAILED;
18380
18350
  if (peg$silentFails === 0) {
18381
- peg$fail(peg$e16);
18351
+ peg$fail(peg$e15);
18382
18352
  }
18383
18353
  }
18384
18354
  }
@@ -18386,13 +18356,13 @@ function peg$parse(input, options) {
18386
18356
  s3 = peg$FAILED;
18387
18357
  }
18388
18358
  if (s3 !== peg$FAILED) {
18389
- if (input.substr(peg$currPos, 2) === peg$c15) {
18390
- s4 = peg$c15;
18359
+ if (input.substr(peg$currPos, 2) === peg$c14) {
18360
+ s4 = peg$c14;
18391
18361
  peg$currPos += 2;
18392
18362
  } else {
18393
18363
  s4 = peg$FAILED;
18394
18364
  if (peg$silentFails === 0) {
18395
- peg$fail(peg$e19);
18365
+ peg$fail(peg$e18);
18396
18366
  }
18397
18367
  }
18398
18368
  if (s4 !== peg$FAILED) {
@@ -18419,49 +18389,49 @@ function peg$parse(input, options) {
18419
18389
  }
18420
18390
  function peg$parseLetteredListTag() {
18421
18391
  let s0;
18422
- if (input.substr(peg$currPos, 3) === peg$c16) {
18423
- s0 = peg$c16;
18392
+ if (input.substr(peg$currPos, 3) === peg$c15) {
18393
+ s0 = peg$c15;
18424
18394
  peg$currPos += 3;
18425
18395
  } else {
18426
18396
  s0 = peg$FAILED;
18427
18397
  if (peg$silentFails === 0) {
18428
- peg$fail(peg$e20);
18398
+ peg$fail(peg$e19);
18429
18399
  }
18430
18400
  }
18431
18401
  return s0;
18432
18402
  }
18433
18403
  function peg$parseLetteredListLowerTag() {
18434
18404
  let s0;
18435
- if (input.substr(peg$currPos, 3) === peg$c17) {
18436
- s0 = peg$c17;
18405
+ if (input.substr(peg$currPos, 3) === peg$c16) {
18406
+ s0 = peg$c16;
18437
18407
  peg$currPos += 3;
18438
18408
  } else {
18439
18409
  s0 = peg$FAILED;
18440
18410
  if (peg$silentFails === 0) {
18441
- peg$fail(peg$e21);
18411
+ peg$fail(peg$e20);
18442
18412
  }
18443
18413
  }
18444
18414
  return s0;
18445
18415
  }
18446
18416
  function peg$parseTaskListTag() {
18447
18417
  let s0;
18448
- if (input.substr(peg$currPos, 3) === peg$c18) {
18449
- s0 = peg$c18;
18418
+ if (input.substr(peg$currPos, 3) === peg$c17) {
18419
+ s0 = peg$c17;
18450
18420
  peg$currPos += 3;
18451
18421
  } else {
18452
18422
  s0 = peg$FAILED;
18453
18423
  if (peg$silentFails === 0) {
18454
- peg$fail(peg$e22);
18424
+ peg$fail(peg$e21);
18455
18425
  }
18456
18426
  }
18457
18427
  if (s0 === peg$FAILED) {
18458
- if (input.substr(peg$currPos, 3) === peg$c19) {
18459
- s0 = peg$c19;
18428
+ if (input.substr(peg$currPos, 3) === peg$c18) {
18429
+ s0 = peg$c18;
18460
18430
  peg$currPos += 3;
18461
18431
  } else {
18462
18432
  s0 = peg$FAILED;
18463
18433
  if (peg$silentFails === 0) {
18464
- peg$fail(peg$e23);
18434
+ peg$fail(peg$e22);
18465
18435
  }
18466
18436
  }
18467
18437
  }
@@ -18494,24 +18464,6 @@ function peg$parse(input, options) {
18494
18464
  return s0;
18495
18465
  }
18496
18466
  function peg$parseListBlock() {
18497
- let s0, s1, s2;
18498
- s0 = peg$currPos;
18499
- s1 = peg$parseListBaseIndent();
18500
- if (s1 !== peg$FAILED) {
18501
- s2 = peg$parseListBlockInner();
18502
- if (s2 !== peg$FAILED) {
18503
- s0 = peg$f14(s2);
18504
- } else {
18505
- peg$currPos = s0;
18506
- s0 = peg$FAILED;
18507
- }
18508
- } else {
18509
- peg$currPos = s0;
18510
- s0 = peg$FAILED;
18511
- }
18512
- return s0;
18513
- }
18514
- function peg$parseListBlockInner() {
18515
18467
  let s0, s1, s2, s3;
18516
18468
  s0 = peg$currPos;
18517
18469
  s1 = peg$parseBulletListContainer();
@@ -18531,7 +18483,7 @@ function peg$parse(input, options) {
18531
18483
  if (s3 === peg$FAILED) {
18532
18484
  s3 = null;
18533
18485
  }
18534
- s0 = peg$f15(s1, s2);
18486
+ s0 = peg$f14(s1, s2);
18535
18487
  } else {
18536
18488
  peg$currPos = s0;
18537
18489
  s0 = peg$FAILED;
@@ -18559,7 +18511,7 @@ function peg$parse(input, options) {
18559
18511
  if (s3 === peg$FAILED) {
18560
18512
  s3 = null;
18561
18513
  }
18562
- s0 = peg$f16(s1, s2);
18514
+ s0 = peg$f15(s1, s2);
18563
18515
  } else {
18564
18516
  peg$currPos = s0;
18565
18517
  s0 = peg$FAILED;
@@ -18587,7 +18539,7 @@ function peg$parse(input, options) {
18587
18539
  if (s3 === peg$FAILED) {
18588
18540
  s3 = null;
18589
18541
  }
18590
- s0 = peg$f17(s1, s2);
18542
+ s0 = peg$f16(s1, s2);
18591
18543
  } else {
18592
18544
  peg$currPos = s0;
18593
18545
  s0 = peg$FAILED;
@@ -18615,7 +18567,7 @@ function peg$parse(input, options) {
18615
18567
  if (s3 === peg$FAILED) {
18616
18568
  s3 = null;
18617
18569
  }
18618
- s0 = peg$f18(s1, s2);
18570
+ s0 = peg$f17(s1, s2);
18619
18571
  } else {
18620
18572
  peg$currPos = s0;
18621
18573
  s0 = peg$FAILED;
@@ -18643,7 +18595,7 @@ function peg$parse(input, options) {
18643
18595
  if (s3 === peg$FAILED) {
18644
18596
  s3 = null;
18645
18597
  }
18646
- s0 = peg$f19(s1, s2);
18598
+ s0 = peg$f18(s1, s2);
18647
18599
  } else {
18648
18600
  peg$currPos = s0;
18649
18601
  s0 = peg$FAILED;
@@ -18671,7 +18623,7 @@ function peg$parse(input, options) {
18671
18623
  if (s3 === peg$FAILED) {
18672
18624
  s3 = null;
18673
18625
  }
18674
- s0 = peg$f20(s1, s2);
18626
+ s0 = peg$f19(s1, s2);
18675
18627
  } else {
18676
18628
  peg$currPos = s0;
18677
18629
  s0 = peg$FAILED;
@@ -18699,7 +18651,7 @@ function peg$parse(input, options) {
18699
18651
  if (s3 === peg$FAILED) {
18700
18652
  s3 = null;
18701
18653
  }
18702
- s0 = peg$f21(s1, s2);
18654
+ s0 = peg$f20(s1, s2);
18703
18655
  } else {
18704
18656
  peg$currPos = s0;
18705
18657
  s0 = peg$FAILED;
@@ -18727,7 +18679,7 @@ function peg$parse(input, options) {
18727
18679
  if (s3 === peg$FAILED) {
18728
18680
  s3 = null;
18729
18681
  }
18730
- s0 = peg$f22(s1, s2);
18682
+ s0 = peg$f21(s1, s2);
18731
18683
  } else {
18732
18684
  peg$currPos = s0;
18733
18685
  s0 = peg$FAILED;
@@ -18745,69 +18697,12 @@ function peg$parse(input, options) {
18745
18697
  }
18746
18698
  return s0;
18747
18699
  }
18748
- function peg$parseListBaseIndent() {
18749
- let s0, s1, s2, s3;
18750
- s0 = peg$currPos;
18751
- peg$silentFails++;
18752
- s1 = peg$currPos;
18753
- s2 = [];
18754
- if (input.charCodeAt(peg$currPos) === 9) {
18755
- s3 = peg$c0;
18756
- peg$currPos++;
18757
- } else {
18758
- s3 = peg$FAILED;
18759
- if (peg$silentFails === 0) {
18760
- peg$fail(peg$e2);
18761
- }
18762
- }
18763
- while (s3 !== peg$FAILED) {
18764
- s2.push(s3);
18765
- if (input.charCodeAt(peg$currPos) === 9) {
18766
- s3 = peg$c0;
18767
- peg$currPos++;
18768
- } else {
18769
- s3 = peg$FAILED;
18770
- if (peg$silentFails === 0) {
18771
- peg$fail(peg$e2);
18772
- }
18773
- }
18774
- }
18775
- s3 = peg$parseListTags();
18776
- if (s3 !== peg$FAILED) {
18777
- s1 = peg$f23(s2);
18778
- } else {
18779
- peg$currPos = s1;
18780
- s1 = peg$FAILED;
18781
- }
18782
- peg$silentFails--;
18783
- if (s1 !== peg$FAILED) {
18784
- peg$currPos = s0;
18785
- s0 = void 0;
18786
- } else {
18787
- s0 = peg$FAILED;
18788
- }
18789
- return s0;
18790
- }
18791
18700
  function peg$parseBulletListContainer() {
18792
- let s0, s1, s2, s3, s4;
18701
+ let s0, s1, s2;
18793
18702
  s0 = peg$currPos;
18794
18703
  s1 = peg$currPos;
18795
18704
  peg$silentFails++;
18796
- s2 = peg$currPos;
18797
- s3 = peg$parseSAMEDENT();
18798
- if (s3 !== peg$FAILED) {
18799
- s4 = peg$parseBulletListTag();
18800
- if (s4 !== peg$FAILED) {
18801
- s3 = [s3, s4];
18802
- s2 = s3;
18803
- } else {
18804
- peg$currPos = s2;
18805
- s2 = peg$FAILED;
18806
- }
18807
- } else {
18808
- peg$currPos = s2;
18809
- s2 = peg$FAILED;
18810
- }
18705
+ s2 = peg$parseBulletListTag();
18811
18706
  peg$silentFails--;
18812
18707
  if (s2 !== peg$FAILED) {
18813
18708
  peg$currPos = s1;
@@ -18816,31 +18711,17 @@ function peg$parse(input, options) {
18816
18711
  s1 = peg$FAILED;
18817
18712
  }
18818
18713
  if (s1 !== peg$FAILED) {
18819
- s1 = peg$f24();
18714
+ s1 = peg$f22();
18820
18715
  }
18821
18716
  s0 = s1;
18822
18717
  return s0;
18823
18718
  }
18824
18719
  function peg$parseNoBulletListContainer() {
18825
- let s0, s1, s2, s3, s4;
18720
+ let s0, s1, s2;
18826
18721
  s0 = peg$currPos;
18827
18722
  s1 = peg$currPos;
18828
18723
  peg$silentFails++;
18829
- s2 = peg$currPos;
18830
- s3 = peg$parseSAMEDENT();
18831
- if (s3 !== peg$FAILED) {
18832
- s4 = peg$parseNoBulletListTag();
18833
- if (s4 !== peg$FAILED) {
18834
- s3 = [s3, s4];
18835
- s2 = s3;
18836
- } else {
18837
- peg$currPos = s2;
18838
- s2 = peg$FAILED;
18839
- }
18840
- } else {
18841
- peg$currPos = s2;
18842
- s2 = peg$FAILED;
18843
- }
18724
+ s2 = peg$parseNoBulletListTag();
18844
18725
  peg$silentFails--;
18845
18726
  if (s2 !== peg$FAILED) {
18846
18727
  peg$currPos = s1;
@@ -18849,31 +18730,17 @@ function peg$parse(input, options) {
18849
18730
  s1 = peg$FAILED;
18850
18731
  }
18851
18732
  if (s1 !== peg$FAILED) {
18852
- s1 = peg$f25();
18733
+ s1 = peg$f23();
18853
18734
  }
18854
18735
  s0 = s1;
18855
18736
  return s0;
18856
18737
  }
18857
18738
  function peg$parseOrderedListContainer() {
18858
- let s0, s1, s2, s3, s4;
18739
+ let s0, s1, s2;
18859
18740
  s0 = peg$currPos;
18860
18741
  s1 = peg$currPos;
18861
18742
  peg$silentFails++;
18862
- s2 = peg$currPos;
18863
- s3 = peg$parseSAMEDENT();
18864
- if (s3 !== peg$FAILED) {
18865
- s4 = peg$parseOrderedListTag();
18866
- if (s4 !== peg$FAILED) {
18867
- s3 = [s3, s4];
18868
- s2 = s3;
18869
- } else {
18870
- peg$currPos = s2;
18871
- s2 = peg$FAILED;
18872
- }
18873
- } else {
18874
- peg$currPos = s2;
18875
- s2 = peg$FAILED;
18876
- }
18743
+ s2 = peg$parseOrderedListTag();
18877
18744
  peg$silentFails--;
18878
18745
  if (s2 !== peg$FAILED) {
18879
18746
  peg$currPos = s1;
@@ -18882,31 +18749,17 @@ function peg$parse(input, options) {
18882
18749
  s1 = peg$FAILED;
18883
18750
  }
18884
18751
  if (s1 !== peg$FAILED) {
18885
- s1 = peg$f26();
18752
+ s1 = peg$f24();
18886
18753
  }
18887
18754
  s0 = s1;
18888
18755
  return s0;
18889
18756
  }
18890
18757
  function peg$parseOrderedListRomanContainer() {
18891
- let s0, s1, s2, s3, s4;
18758
+ let s0, s1, s2;
18892
18759
  s0 = peg$currPos;
18893
18760
  s1 = peg$currPos;
18894
18761
  peg$silentFails++;
18895
- s2 = peg$currPos;
18896
- s3 = peg$parseSAMEDENT();
18897
- if (s3 !== peg$FAILED) {
18898
- s4 = peg$parseOrderedListRomanTag();
18899
- if (s4 !== peg$FAILED) {
18900
- s3 = [s3, s4];
18901
- s2 = s3;
18902
- } else {
18903
- peg$currPos = s2;
18904
- s2 = peg$FAILED;
18905
- }
18906
- } else {
18907
- peg$currPos = s2;
18908
- s2 = peg$FAILED;
18909
- }
18762
+ s2 = peg$parseOrderedListRomanTag();
18910
18763
  peg$silentFails--;
18911
18764
  if (s2 !== peg$FAILED) {
18912
18765
  peg$currPos = s1;
@@ -18915,31 +18768,17 @@ function peg$parse(input, options) {
18915
18768
  s1 = peg$FAILED;
18916
18769
  }
18917
18770
  if (s1 !== peg$FAILED) {
18918
- s1 = peg$f27();
18771
+ s1 = peg$f25();
18919
18772
  }
18920
18773
  s0 = s1;
18921
18774
  return s0;
18922
18775
  }
18923
18776
  function peg$parseOrderedListRomanLowerContainer() {
18924
- let s0, s1, s2, s3, s4;
18777
+ let s0, s1, s2;
18925
18778
  s0 = peg$currPos;
18926
18779
  s1 = peg$currPos;
18927
18780
  peg$silentFails++;
18928
- s2 = peg$currPos;
18929
- s3 = peg$parseSAMEDENT();
18930
- if (s3 !== peg$FAILED) {
18931
- s4 = peg$parseOrderedListRomanLowerTag();
18932
- if (s4 !== peg$FAILED) {
18933
- s3 = [s3, s4];
18934
- s2 = s3;
18935
- } else {
18936
- peg$currPos = s2;
18937
- s2 = peg$FAILED;
18938
- }
18939
- } else {
18940
- peg$currPos = s2;
18941
- s2 = peg$FAILED;
18942
- }
18781
+ s2 = peg$parseOrderedListRomanLowerTag();
18943
18782
  peg$silentFails--;
18944
18783
  if (s2 !== peg$FAILED) {
18945
18784
  peg$currPos = s1;
@@ -18948,31 +18787,17 @@ function peg$parse(input, options) {
18948
18787
  s1 = peg$FAILED;
18949
18788
  }
18950
18789
  if (s1 !== peg$FAILED) {
18951
- s1 = peg$f28();
18790
+ s1 = peg$f26();
18952
18791
  }
18953
18792
  s0 = s1;
18954
18793
  return s0;
18955
18794
  }
18956
18795
  function peg$parseLetteredListContainer() {
18957
- let s0, s1, s2, s3, s4;
18796
+ let s0, s1, s2;
18958
18797
  s0 = peg$currPos;
18959
18798
  s1 = peg$currPos;
18960
18799
  peg$silentFails++;
18961
- s2 = peg$currPos;
18962
- s3 = peg$parseSAMEDENT();
18963
- if (s3 !== peg$FAILED) {
18964
- s4 = peg$parseLetteredListTag();
18965
- if (s4 !== peg$FAILED) {
18966
- s3 = [s3, s4];
18967
- s2 = s3;
18968
- } else {
18969
- peg$currPos = s2;
18970
- s2 = peg$FAILED;
18971
- }
18972
- } else {
18973
- peg$currPos = s2;
18974
- s2 = peg$FAILED;
18975
- }
18800
+ s2 = peg$parseLetteredListTag();
18976
18801
  peg$silentFails--;
18977
18802
  if (s2 !== peg$FAILED) {
18978
18803
  peg$currPos = s1;
@@ -18981,31 +18806,17 @@ function peg$parse(input, options) {
18981
18806
  s1 = peg$FAILED;
18982
18807
  }
18983
18808
  if (s1 !== peg$FAILED) {
18984
- s1 = peg$f29();
18809
+ s1 = peg$f27();
18985
18810
  }
18986
18811
  s0 = s1;
18987
18812
  return s0;
18988
18813
  }
18989
18814
  function peg$parseLetteredListLowerContainer() {
18990
- let s0, s1, s2, s3, s4;
18815
+ let s0, s1, s2;
18991
18816
  s0 = peg$currPos;
18992
18817
  s1 = peg$currPos;
18993
18818
  peg$silentFails++;
18994
- s2 = peg$currPos;
18995
- s3 = peg$parseSAMEDENT();
18996
- if (s3 !== peg$FAILED) {
18997
- s4 = peg$parseLetteredListLowerTag();
18998
- if (s4 !== peg$FAILED) {
18999
- s3 = [s3, s4];
19000
- s2 = s3;
19001
- } else {
19002
- peg$currPos = s2;
19003
- s2 = peg$FAILED;
19004
- }
19005
- } else {
19006
- peg$currPos = s2;
19007
- s2 = peg$FAILED;
19008
- }
18819
+ s2 = peg$parseLetteredListLowerTag();
19009
18820
  peg$silentFails--;
19010
18821
  if (s2 !== peg$FAILED) {
19011
18822
  peg$currPos = s1;
@@ -19014,31 +18825,17 @@ function peg$parse(input, options) {
19014
18825
  s1 = peg$FAILED;
19015
18826
  }
19016
18827
  if (s1 !== peg$FAILED) {
19017
- s1 = peg$f30();
18828
+ s1 = peg$f28();
19018
18829
  }
19019
18830
  s0 = s1;
19020
18831
  return s0;
19021
18832
  }
19022
18833
  function peg$parseTaskListContainer() {
19023
- let s0, s1, s2, s3, s4;
18834
+ let s0, s1, s2;
19024
18835
  s0 = peg$currPos;
19025
18836
  s1 = peg$currPos;
19026
18837
  peg$silentFails++;
19027
- s2 = peg$currPos;
19028
- s3 = peg$parseSAMEDENT();
19029
- if (s3 !== peg$FAILED) {
19030
- s4 = peg$parseTaskListTag();
19031
- if (s4 !== peg$FAILED) {
19032
- s3 = [s3, s4];
19033
- s2 = s3;
19034
- } else {
19035
- peg$currPos = s2;
19036
- s2 = peg$FAILED;
19037
- }
19038
- } else {
19039
- peg$currPos = s2;
19040
- s2 = peg$FAILED;
19041
- }
18838
+ s2 = peg$parseTaskListTag();
19042
18839
  peg$silentFails--;
19043
18840
  if (s2 !== peg$FAILED) {
19044
18841
  peg$currPos = s1;
@@ -19047,7 +18844,7 @@ function peg$parse(input, options) {
19047
18844
  s1 = peg$FAILED;
19048
18845
  }
19049
18846
  if (s1 !== peg$FAILED) {
19050
- s1 = peg$f31();
18847
+ s1 = peg$f29();
19051
18848
  }
19052
18849
  s0 = s1;
19053
18850
  return s0;
@@ -19153,7 +18950,7 @@ function peg$parse(input, options) {
19153
18950
  }
19154
18951
  s8 = peg$parseDEDENT();
19155
18952
  if (s8 !== peg$FAILED) {
19156
- s5 = peg$f32(s2, s3, s4, s7);
18953
+ s5 = peg$f30(s2, s3, s4, s7);
19157
18954
  } else {
19158
18955
  peg$currPos = s5;
19159
18956
  s5 = peg$FAILED;
@@ -19165,7 +18962,7 @@ function peg$parse(input, options) {
19165
18962
  if (s5 === peg$FAILED) {
19166
18963
  s5 = null;
19167
18964
  }
19168
- s0 = peg$f33(s2, s3, s4, s5);
18965
+ s0 = peg$f31(s2, s3, s4, s5);
19169
18966
  } else {
19170
18967
  peg$currPos = s0;
19171
18968
  s0 = peg$FAILED;
@@ -19296,7 +19093,7 @@ function peg$parse(input, options) {
19296
19093
  s4 = s5;
19297
19094
  }
19298
19095
  if (s4 !== peg$FAILED) {
19299
- s0 = peg$f34(s4);
19096
+ s0 = peg$f32(s4);
19300
19097
  } else {
19301
19098
  peg$currPos = s0;
19302
19099
  s0 = peg$FAILED;
@@ -19325,7 +19122,7 @@ function peg$parse(input, options) {
19325
19122
  } else {
19326
19123
  s2 = peg$FAILED;
19327
19124
  if (peg$silentFails === 0) {
19328
- peg$fail(peg$e8);
19125
+ peg$fail(peg$e7);
19329
19126
  }
19330
19127
  }
19331
19128
  while (s2 !== peg$FAILED) {
@@ -19336,7 +19133,7 @@ function peg$parse(input, options) {
19336
19133
  } else {
19337
19134
  s2 = peg$FAILED;
19338
19135
  if (peg$silentFails === 0) {
19339
- peg$fail(peg$e8);
19136
+ peg$fail(peg$e7);
19340
19137
  }
19341
19138
  }
19342
19139
  }
@@ -19355,27 +19152,27 @@ function peg$parse(input, options) {
19355
19152
  s0 = peg$currPos;
19356
19153
  s1 = [];
19357
19154
  if (input.charCodeAt(peg$currPos) === 9) {
19358
- s2 = peg$c0;
19155
+ s2 = peg$c19;
19359
19156
  peg$currPos++;
19360
19157
  } else {
19361
19158
  s2 = peg$FAILED;
19362
19159
  if (peg$silentFails === 0) {
19363
- peg$fail(peg$e2);
19160
+ peg$fail(peg$e23);
19364
19161
  }
19365
19162
  }
19366
19163
  while (s2 !== peg$FAILED) {
19367
19164
  s1.push(s2);
19368
19165
  if (input.charCodeAt(peg$currPos) === 9) {
19369
- s2 = peg$c0;
19166
+ s2 = peg$c19;
19370
19167
  peg$currPos++;
19371
19168
  } else {
19372
19169
  s2 = peg$FAILED;
19373
19170
  if (peg$silentFails === 0) {
19374
- peg$fail(peg$e2);
19171
+ peg$fail(peg$e23);
19375
19172
  }
19376
19173
  }
19377
19174
  }
19378
- s2 = peg$f35(s1);
19175
+ s2 = peg$f33(s1);
19379
19176
  if (s2) {
19380
19177
  s2 = void 0;
19381
19178
  } else {
@@ -19397,24 +19194,24 @@ function peg$parse(input, options) {
19397
19194
  s1 = peg$currPos;
19398
19195
  s2 = [];
19399
19196
  if (input.charCodeAt(peg$currPos) === 9) {
19400
- s3 = peg$c0;
19197
+ s3 = peg$c19;
19401
19198
  peg$currPos++;
19402
19199
  } else {
19403
19200
  s3 = peg$FAILED;
19404
19201
  if (peg$silentFails === 0) {
19405
- peg$fail(peg$e2);
19202
+ peg$fail(peg$e23);
19406
19203
  }
19407
19204
  }
19408
19205
  if (s3 !== peg$FAILED) {
19409
19206
  while (s3 !== peg$FAILED) {
19410
19207
  s2.push(s3);
19411
19208
  if (input.charCodeAt(peg$currPos) === 9) {
19412
- s3 = peg$c0;
19209
+ s3 = peg$c19;
19413
19210
  peg$currPos++;
19414
19211
  } else {
19415
19212
  s3 = peg$FAILED;
19416
19213
  if (peg$silentFails === 0) {
19417
- peg$fail(peg$e2);
19214
+ peg$fail(peg$e23);
19418
19215
  }
19419
19216
  }
19420
19217
  }
@@ -19422,14 +19219,14 @@ function peg$parse(input, options) {
19422
19219
  s2 = peg$FAILED;
19423
19220
  }
19424
19221
  if (s2 !== peg$FAILED) {
19425
- s3 = peg$f36(s2);
19222
+ s3 = peg$f34(s2);
19426
19223
  if (s3) {
19427
19224
  s3 = void 0;
19428
19225
  } else {
19429
19226
  s3 = peg$FAILED;
19430
19227
  }
19431
19228
  if (s3 !== peg$FAILED) {
19432
- s1 = peg$f37(s2);
19229
+ s1 = peg$f35(s2);
19433
19230
  } else {
19434
19231
  peg$currPos = s1;
19435
19232
  s1 = peg$FAILED;
@@ -19449,7 +19246,7 @@ function peg$parse(input, options) {
19449
19246
  }
19450
19247
  function peg$parseDEDENT() {
19451
19248
  let s0;
19452
- s0 = peg$f38();
19249
+ s0 = peg$f36();
19453
19250
  if (s0) {
19454
19251
  s0 = void 0;
19455
19252
  } else {
@@ -19473,7 +19270,7 @@ function peg$parse(input, options) {
19473
19270
  if (s1 !== peg$FAILED) {
19474
19271
  s2 = peg$parseParagraphBody();
19475
19272
  if (s2 !== peg$FAILED) {
19476
- s0 = peg$f39(s2);
19273
+ s0 = peg$f37(s2);
19477
19274
  } else {
19478
19275
  peg$currPos = s0;
19479
19276
  s0 = peg$FAILED;
@@ -19488,7 +19285,7 @@ function peg$parse(input, options) {
19488
19285
  if (s1 !== peg$FAILED) {
19489
19286
  s2 = peg$parseParagraphBody();
19490
19287
  if (s2 !== peg$FAILED) {
19491
- s0 = peg$f40(s2);
19288
+ s0 = peg$f38(s2);
19492
19289
  } else {
19493
19290
  peg$currPos = s0;
19494
19291
  s0 = peg$FAILED;
@@ -19502,7 +19299,7 @@ function peg$parse(input, options) {
19502
19299
  s1 = peg$parseExplicitParagraphHeader();
19503
19300
  if (s1 !== peg$FAILED) {
19504
19301
  s2 = "";
19505
- s0 = peg$f41(s2);
19302
+ s0 = peg$f39(s2);
19506
19303
  } else {
19507
19304
  peg$currPos = s0;
19508
19305
  s0 = peg$FAILED;
@@ -19605,7 +19402,7 @@ function peg$parse(input, options) {
19605
19402
  } else {
19606
19403
  s5 = peg$FAILED;
19607
19404
  if (peg$silentFails === 0) {
19608
- peg$fail(peg$e8);
19405
+ peg$fail(peg$e7);
19609
19406
  }
19610
19407
  }
19611
19408
  while (s5 !== peg$FAILED) {
@@ -19616,7 +19413,7 @@ function peg$parse(input, options) {
19616
19413
  } else {
19617
19414
  s5 = peg$FAILED;
19618
19415
  if (peg$silentFails === 0) {
19619
- peg$fail(peg$e8);
19416
+ peg$fail(peg$e7);
19620
19417
  }
19621
19418
  }
19622
19419
  }
@@ -19670,7 +19467,7 @@ function peg$parse(input, options) {
19670
19467
  if (s1 !== peg$FAILED) {
19671
19468
  s2 = peg$parseImageType();
19672
19469
  if (s2 !== peg$FAILED) {
19673
- s0 = peg$f42(s2);
19470
+ s0 = peg$f40(s2);
19674
19471
  } else {
19675
19472
  peg$currPos = s0;
19676
19473
  s0 = peg$FAILED;
@@ -19687,12 +19484,12 @@ function peg$parse(input, options) {
19687
19484
  s1 = peg$parseImageTag();
19688
19485
  if (s1 !== peg$FAILED) {
19689
19486
  if (input.charCodeAt(peg$currPos) === 58) {
19690
- s2 = peg$c6;
19487
+ s2 = peg$c5;
19691
19488
  peg$currPos++;
19692
19489
  } else {
19693
19490
  s2 = peg$FAILED;
19694
19491
  if (peg$silentFails === 0) {
19695
- peg$fail(peg$e9);
19492
+ peg$fail(peg$e8);
19696
19493
  }
19697
19494
  }
19698
19495
  if (s2 !== peg$FAILED) {
@@ -19700,30 +19497,30 @@ function peg$parse(input, options) {
19700
19497
  peg$currPos++;
19701
19498
  } else {
19702
19499
  if (peg$silentFails === 0) {
19703
- peg$fail(peg$e17);
19500
+ peg$fail(peg$e16);
19704
19501
  }
19705
19502
  }
19706
19503
  s4 = peg$parseUrlHttp();
19707
19504
  if (s4 !== peg$FAILED) {
19708
19505
  s5 = [];
19709
19506
  if (input.charCodeAt(peg$currPos) === 32) {
19710
- s6 = peg$c13;
19507
+ s6 = peg$c12;
19711
19508
  peg$currPos++;
19712
19509
  } else {
19713
19510
  s6 = peg$FAILED;
19714
19511
  if (peg$silentFails === 0) {
19715
- peg$fail(peg$e17);
19512
+ peg$fail(peg$e16);
19716
19513
  }
19717
19514
  }
19718
19515
  while (s6 !== peg$FAILED) {
19719
19516
  s5.push(s6);
19720
19517
  if (input.charCodeAt(peg$currPos) === 32) {
19721
- s6 = peg$c13;
19518
+ s6 = peg$c12;
19722
19519
  peg$currPos++;
19723
19520
  } else {
19724
19521
  s6 = peg$FAILED;
19725
19522
  if (peg$silentFails === 0) {
19726
- peg$fail(peg$e17);
19523
+ peg$fail(peg$e16);
19727
19524
  }
19728
19525
  }
19729
19526
  }
@@ -19739,7 +19536,7 @@ function peg$parse(input, options) {
19739
19536
  } else {
19740
19537
  s11 = peg$FAILED;
19741
19538
  if (peg$silentFails === 0) {
19742
- peg$fail(peg$e8);
19539
+ peg$fail(peg$e7);
19743
19540
  }
19744
19541
  }
19745
19542
  while (s11 !== peg$FAILED) {
@@ -19750,7 +19547,7 @@ function peg$parse(input, options) {
19750
19547
  } else {
19751
19548
  s11 = peg$FAILED;
19752
19549
  if (peg$silentFails === 0) {
19753
- peg$fail(peg$e8);
19550
+ peg$fail(peg$e7);
19754
19551
  }
19755
19552
  }
19756
19553
  }
@@ -19772,7 +19569,7 @@ function peg$parse(input, options) {
19772
19569
  if (s9 === peg$FAILED) {
19773
19570
  s9 = null;
19774
19571
  }
19775
- s0 = peg$f43(s1, s4, s7);
19572
+ s0 = peg$f41(s1, s4, s7);
19776
19573
  } else {
19777
19574
  peg$currPos = s0;
19778
19575
  s0 = peg$FAILED;
@@ -19804,7 +19601,7 @@ function peg$parse(input, options) {
19804
19601
  s1.push(s2);
19805
19602
  s2 = peg$parseMediaChainItem();
19806
19603
  }
19807
- s1 = peg$f44(s1);
19604
+ s1 = peg$f42(s1);
19808
19605
  s0 = s1;
19809
19606
  return s0;
19810
19607
  }
@@ -19877,7 +19674,7 @@ function peg$parse(input, options) {
19877
19674
  s2 = input.substring(s2, peg$currPos);
19878
19675
  s3 = peg$parseBlockTag();
19879
19676
  if (s3 !== peg$FAILED) {
19880
- s0 = peg$f45(s2);
19677
+ s0 = peg$f43(s2);
19881
19678
  } else {
19882
19679
  peg$currPos = s0;
19883
19680
  s0 = peg$FAILED;
@@ -19903,34 +19700,34 @@ function peg$parse(input, options) {
19903
19700
  s2 = peg$parseMediaSizeTags();
19904
19701
  if (s2 !== peg$FAILED) {
19905
19702
  if (input.charCodeAt(peg$currPos) === 58) {
19906
- s3 = peg$c6;
19703
+ s3 = peg$c5;
19907
19704
  peg$currPos++;
19908
19705
  } else {
19909
19706
  s3 = peg$FAILED;
19910
19707
  if (peg$silentFails === 0) {
19911
- peg$fail(peg$e9);
19708
+ peg$fail(peg$e8);
19912
19709
  }
19913
19710
  }
19914
19711
  if (s3 !== peg$FAILED) {
19915
19712
  s4 = [];
19916
19713
  if (input.charCodeAt(peg$currPos) === 32) {
19917
- s5 = peg$c13;
19714
+ s5 = peg$c12;
19918
19715
  peg$currPos++;
19919
19716
  } else {
19920
19717
  s5 = peg$FAILED;
19921
19718
  if (peg$silentFails === 0) {
19922
- peg$fail(peg$e17);
19719
+ peg$fail(peg$e16);
19923
19720
  }
19924
19721
  }
19925
19722
  while (s5 !== peg$FAILED) {
19926
19723
  s4.push(s5);
19927
19724
  if (input.charCodeAt(peg$currPos) === 32) {
19928
- s5 = peg$c13;
19725
+ s5 = peg$c12;
19929
19726
  peg$currPos++;
19930
19727
  } else {
19931
19728
  s5 = peg$FAILED;
19932
19729
  if (peg$silentFails === 0) {
19933
- peg$fail(peg$e17);
19730
+ peg$fail(peg$e16);
19934
19731
  }
19935
19732
  }
19936
19733
  }
@@ -19954,7 +19751,7 @@ function peg$parse(input, options) {
19954
19751
  } else {
19955
19752
  s9 = peg$FAILED;
19956
19753
  if (peg$silentFails === 0) {
19957
- peg$fail(peg$e16);
19754
+ peg$fail(peg$e15);
19958
19755
  }
19959
19756
  }
19960
19757
  if (s9 !== peg$FAILED) {
@@ -19989,7 +19786,7 @@ function peg$parse(input, options) {
19989
19786
  } else {
19990
19787
  s9 = peg$FAILED;
19991
19788
  if (peg$silentFails === 0) {
19992
- peg$fail(peg$e16);
19789
+ peg$fail(peg$e15);
19993
19790
  }
19994
19791
  }
19995
19792
  if (s9 !== peg$FAILED) {
@@ -20015,29 +19812,29 @@ function peg$parse(input, options) {
20015
19812
  if (s5 !== peg$FAILED) {
20016
19813
  s6 = [];
20017
19814
  if (input.charCodeAt(peg$currPos) === 32) {
20018
- s7 = peg$c13;
19815
+ s7 = peg$c12;
20019
19816
  peg$currPos++;
20020
19817
  } else {
20021
19818
  s7 = peg$FAILED;
20022
19819
  if (peg$silentFails === 0) {
20023
- peg$fail(peg$e17);
19820
+ peg$fail(peg$e16);
20024
19821
  }
20025
19822
  }
20026
19823
  while (s7 !== peg$FAILED) {
20027
19824
  s6.push(s7);
20028
19825
  if (input.charCodeAt(peg$currPos) === 32) {
20029
- s7 = peg$c13;
19826
+ s7 = peg$c12;
20030
19827
  peg$currPos++;
20031
19828
  } else {
20032
19829
  s7 = peg$FAILED;
20033
19830
  if (peg$silentFails === 0) {
20034
- peg$fail(peg$e17);
19831
+ peg$fail(peg$e16);
20035
19832
  }
20036
19833
  }
20037
19834
  }
20038
19835
  s7 = peg$parseBlockTag();
20039
19836
  if (s7 !== peg$FAILED) {
20040
- s0 = peg$f46(s2, s5);
19837
+ s0 = peg$f44(s2, s5);
20041
19838
  } else {
20042
19839
  peg$currPos = s0;
20043
19840
  s0 = peg$FAILED;
@@ -20071,34 +19868,34 @@ function peg$parse(input, options) {
20071
19868
  s2 = peg$parseMediaTextTags();
20072
19869
  if (s2 !== peg$FAILED) {
20073
19870
  if (input.charCodeAt(peg$currPos) === 58) {
20074
- s3 = peg$c6;
19871
+ s3 = peg$c5;
20075
19872
  peg$currPos++;
20076
19873
  } else {
20077
19874
  s3 = peg$FAILED;
20078
19875
  if (peg$silentFails === 0) {
20079
- peg$fail(peg$e9);
19876
+ peg$fail(peg$e8);
20080
19877
  }
20081
19878
  }
20082
19879
  if (s3 !== peg$FAILED) {
20083
19880
  s4 = [];
20084
19881
  if (input.charCodeAt(peg$currPos) === 32) {
20085
- s5 = peg$c13;
19882
+ s5 = peg$c12;
20086
19883
  peg$currPos++;
20087
19884
  } else {
20088
19885
  s5 = peg$FAILED;
20089
19886
  if (peg$silentFails === 0) {
20090
- peg$fail(peg$e17);
19887
+ peg$fail(peg$e16);
20091
19888
  }
20092
19889
  }
20093
19890
  while (s5 !== peg$FAILED) {
20094
19891
  s4.push(s5);
20095
19892
  if (input.charCodeAt(peg$currPos) === 32) {
20096
- s5 = peg$c13;
19893
+ s5 = peg$c12;
20097
19894
  peg$currPos++;
20098
19895
  } else {
20099
19896
  s5 = peg$FAILED;
20100
19897
  if (peg$silentFails === 0) {
20101
- peg$fail(peg$e17);
19898
+ peg$fail(peg$e16);
20102
19899
  }
20103
19900
  }
20104
19901
  }
@@ -20158,7 +19955,7 @@ function peg$parse(input, options) {
20158
19955
  s5 = input.substring(s5, peg$currPos);
20159
19956
  s6 = peg$parseBlockTag();
20160
19957
  if (s6 !== peg$FAILED) {
20161
- s0 = peg$f47(s2, s5);
19958
+ s0 = peg$f45(s2, s5);
20162
19959
  } else {
20163
19960
  peg$currPos = s0;
20164
19961
  s0 = peg$FAILED;
@@ -20188,34 +19985,34 @@ function peg$parse(input, options) {
20188
19985
  s2 = peg$parseMediaAlignmentTags();
20189
19986
  if (s2 !== peg$FAILED) {
20190
19987
  if (input.charCodeAt(peg$currPos) === 58) {
20191
- s3 = peg$c6;
19988
+ s3 = peg$c5;
20192
19989
  peg$currPos++;
20193
19990
  } else {
20194
19991
  s3 = peg$FAILED;
20195
19992
  if (peg$silentFails === 0) {
20196
- peg$fail(peg$e9);
19993
+ peg$fail(peg$e8);
20197
19994
  }
20198
19995
  }
20199
19996
  if (s3 !== peg$FAILED) {
20200
19997
  s4 = [];
20201
19998
  if (input.charCodeAt(peg$currPos) === 32) {
20202
- s5 = peg$c13;
19999
+ s5 = peg$c12;
20203
20000
  peg$currPos++;
20204
20001
  } else {
20205
20002
  s5 = peg$FAILED;
20206
20003
  if (peg$silentFails === 0) {
20207
- peg$fail(peg$e17);
20004
+ peg$fail(peg$e16);
20208
20005
  }
20209
20006
  }
20210
20007
  while (s5 !== peg$FAILED) {
20211
20008
  s4.push(s5);
20212
20009
  if (input.charCodeAt(peg$currPos) === 32) {
20213
- s5 = peg$c13;
20010
+ s5 = peg$c12;
20214
20011
  peg$currPos++;
20215
20012
  } else {
20216
20013
  s5 = peg$FAILED;
20217
20014
  if (peg$silentFails === 0) {
20218
- peg$fail(peg$e17);
20015
+ peg$fail(peg$e16);
20219
20016
  }
20220
20017
  }
20221
20018
  }
@@ -20223,29 +20020,29 @@ function peg$parse(input, options) {
20223
20020
  if (s5 !== peg$FAILED) {
20224
20021
  s6 = [];
20225
20022
  if (input.charCodeAt(peg$currPos) === 32) {
20226
- s7 = peg$c13;
20023
+ s7 = peg$c12;
20227
20024
  peg$currPos++;
20228
20025
  } else {
20229
20026
  s7 = peg$FAILED;
20230
20027
  if (peg$silentFails === 0) {
20231
- peg$fail(peg$e17);
20028
+ peg$fail(peg$e16);
20232
20029
  }
20233
20030
  }
20234
20031
  while (s7 !== peg$FAILED) {
20235
20032
  s6.push(s7);
20236
20033
  if (input.charCodeAt(peg$currPos) === 32) {
20237
- s7 = peg$c13;
20034
+ s7 = peg$c12;
20238
20035
  peg$currPos++;
20239
20036
  } else {
20240
20037
  s7 = peg$FAILED;
20241
20038
  if (peg$silentFails === 0) {
20242
- peg$fail(peg$e17);
20039
+ peg$fail(peg$e16);
20243
20040
  }
20244
20041
  }
20245
20042
  }
20246
20043
  s7 = peg$parseBlockTag();
20247
20044
  if (s7 !== peg$FAILED) {
20248
- s0 = peg$f48(s2, s5);
20045
+ s0 = peg$f46(s2, s5);
20249
20046
  } else {
20250
20047
  peg$currPos = s0;
20251
20048
  s0 = peg$FAILED;
@@ -20279,34 +20076,34 @@ function peg$parse(input, options) {
20279
20076
  s2 = peg$parseMediaBooleanTags();
20280
20077
  if (s2 !== peg$FAILED) {
20281
20078
  if (input.charCodeAt(peg$currPos) === 58) {
20282
- s3 = peg$c6;
20079
+ s3 = peg$c5;
20283
20080
  peg$currPos++;
20284
20081
  } else {
20285
20082
  s3 = peg$FAILED;
20286
20083
  if (peg$silentFails === 0) {
20287
- peg$fail(peg$e9);
20084
+ peg$fail(peg$e8);
20288
20085
  }
20289
20086
  }
20290
20087
  if (s3 !== peg$FAILED) {
20291
20088
  s4 = [];
20292
20089
  if (input.charCodeAt(peg$currPos) === 32) {
20293
- s5 = peg$c13;
20090
+ s5 = peg$c12;
20294
20091
  peg$currPos++;
20295
20092
  } else {
20296
20093
  s5 = peg$FAILED;
20297
20094
  if (peg$silentFails === 0) {
20298
- peg$fail(peg$e17);
20095
+ peg$fail(peg$e16);
20299
20096
  }
20300
20097
  }
20301
20098
  while (s5 !== peg$FAILED) {
20302
20099
  s4.push(s5);
20303
20100
  if (input.charCodeAt(peg$currPos) === 32) {
20304
- s5 = peg$c13;
20101
+ s5 = peg$c12;
20305
20102
  peg$currPos++;
20306
20103
  } else {
20307
20104
  s5 = peg$FAILED;
20308
20105
  if (peg$silentFails === 0) {
20309
- peg$fail(peg$e17);
20106
+ peg$fail(peg$e16);
20310
20107
  }
20311
20108
  }
20312
20109
  }
@@ -20314,29 +20111,29 @@ function peg$parse(input, options) {
20314
20111
  if (s5 !== peg$FAILED) {
20315
20112
  s6 = [];
20316
20113
  if (input.charCodeAt(peg$currPos) === 32) {
20317
- s7 = peg$c13;
20114
+ s7 = peg$c12;
20318
20115
  peg$currPos++;
20319
20116
  } else {
20320
20117
  s7 = peg$FAILED;
20321
20118
  if (peg$silentFails === 0) {
20322
- peg$fail(peg$e17);
20119
+ peg$fail(peg$e16);
20323
20120
  }
20324
20121
  }
20325
20122
  while (s7 !== peg$FAILED) {
20326
20123
  s6.push(s7);
20327
20124
  if (input.charCodeAt(peg$currPos) === 32) {
20328
- s7 = peg$c13;
20125
+ s7 = peg$c12;
20329
20126
  peg$currPos++;
20330
20127
  } else {
20331
20128
  s7 = peg$FAILED;
20332
20129
  if (peg$silentFails === 0) {
20333
- peg$fail(peg$e17);
20130
+ peg$fail(peg$e16);
20334
20131
  }
20335
20132
  }
20336
20133
  }
20337
20134
  s7 = peg$parseBlockTag();
20338
20135
  if (s7 !== peg$FAILED) {
20339
- s0 = peg$f49(s2, s5);
20136
+ s0 = peg$f47(s2, s5);
20340
20137
  } else {
20341
20138
  peg$currPos = s0;
20342
20139
  s0 = peg$FAILED;
@@ -20371,29 +20168,29 @@ function peg$parse(input, options) {
20371
20168
  if (s2 !== peg$FAILED) {
20372
20169
  s3 = [];
20373
20170
  if (input.charCodeAt(peg$currPos) === 32) {
20374
- s4 = peg$c13;
20171
+ s4 = peg$c12;
20375
20172
  peg$currPos++;
20376
20173
  } else {
20377
20174
  s4 = peg$FAILED;
20378
20175
  if (peg$silentFails === 0) {
20379
- peg$fail(peg$e17);
20176
+ peg$fail(peg$e16);
20380
20177
  }
20381
20178
  }
20382
20179
  while (s4 !== peg$FAILED) {
20383
20180
  s3.push(s4);
20384
20181
  if (input.charCodeAt(peg$currPos) === 32) {
20385
- s4 = peg$c13;
20182
+ s4 = peg$c12;
20386
20183
  peg$currPos++;
20387
20184
  } else {
20388
20185
  s4 = peg$FAILED;
20389
20186
  if (peg$silentFails === 0) {
20390
- peg$fail(peg$e17);
20187
+ peg$fail(peg$e16);
20391
20188
  }
20392
20189
  }
20393
20190
  }
20394
20191
  s4 = peg$parseBlockTag();
20395
20192
  if (s4 !== peg$FAILED) {
20396
- s0 = peg$f50(s2);
20193
+ s0 = peg$f48(s2);
20397
20194
  } else {
20398
20195
  peg$currPos = s0;
20399
20196
  s0 = peg$FAILED;
@@ -20418,7 +20215,7 @@ function peg$parse(input, options) {
20418
20215
  }
20419
20216
  s2 = peg$parseBlockTag();
20420
20217
  if (s2 !== peg$FAILED) {
20421
- s0 = peg$f51();
20218
+ s0 = peg$f49();
20422
20219
  } else {
20423
20220
  peg$currPos = s0;
20424
20221
  s0 = peg$FAILED;
@@ -20493,7 +20290,7 @@ function peg$parse(input, options) {
20493
20290
  s2 = input.substring(s2, peg$currPos);
20494
20291
  s3 = peg$parseBlockTag();
20495
20292
  if (s3 !== peg$FAILED) {
20496
- s0 = peg$f52(s2);
20293
+ s0 = peg$f50(s2);
20497
20294
  } else {
20498
20295
  peg$currPos = s0;
20499
20296
  s0 = peg$FAILED;
@@ -20656,7 +20453,7 @@ function peg$parse(input, options) {
20656
20453
  peg$silentFails++;
20657
20454
  s0 = peg$currPos;
20658
20455
  s1 = peg$parseInlineTags();
20659
- s1 = peg$f53(s1);
20456
+ s1 = peg$f51(s1);
20660
20457
  s0 = s1;
20661
20458
  peg$silentFails--;
20662
20459
  return s0;
@@ -20687,7 +20484,7 @@ function peg$parse(input, options) {
20687
20484
  s3 = peg$parseInlinePlainText();
20688
20485
  }
20689
20486
  }
20690
- s0 = peg$f54(s1, s2);
20487
+ s0 = peg$f52(s1, s2);
20691
20488
  return s0;
20692
20489
  }
20693
20490
  function peg$parseInlinePlainText() {
@@ -20695,7 +20492,7 @@ function peg$parse(input, options) {
20695
20492
  s0 = peg$currPos;
20696
20493
  s1 = peg$parseNL();
20697
20494
  if (s1 !== peg$FAILED) {
20698
- s1 = peg$f55();
20495
+ s1 = peg$f53();
20699
20496
  }
20700
20497
  s0 = s1;
20701
20498
  if (s0 === peg$FAILED) {
@@ -20823,7 +20620,7 @@ function peg$parse(input, options) {
20823
20620
  s1 = s2;
20824
20621
  }
20825
20622
  if (s1 !== peg$FAILED) {
20826
- s1 = peg$f56(s1);
20623
+ s1 = peg$f54(s1);
20827
20624
  }
20828
20625
  s0 = s1;
20829
20626
  }
@@ -20874,7 +20671,7 @@ function peg$parse(input, options) {
20874
20671
  } else {
20875
20672
  s4 = peg$FAILED;
20876
20673
  if (peg$silentFails === 0) {
20877
- peg$fail(peg$e16);
20674
+ peg$fail(peg$e15);
20878
20675
  }
20879
20676
  }
20880
20677
  if (s4 !== peg$FAILED) {
@@ -20886,7 +20683,7 @@ function peg$parse(input, options) {
20886
20683
  } else {
20887
20684
  s4 = peg$FAILED;
20888
20685
  if (peg$silentFails === 0) {
20889
- peg$fail(peg$e16);
20686
+ peg$fail(peg$e15);
20890
20687
  }
20891
20688
  }
20892
20689
  }
@@ -20901,7 +20698,7 @@ function peg$parse(input, options) {
20901
20698
  if (s2 !== peg$FAILED) {
20902
20699
  s3 = peg$parseBodyBitCloseTag();
20903
20700
  if (s3 !== peg$FAILED) {
20904
- s0 = peg$f57(s2);
20701
+ s0 = peg$f55(s2);
20905
20702
  } else {
20906
20703
  peg$currPos = s0;
20907
20704
  s0 = peg$FAILED;
@@ -21000,7 +20797,7 @@ function peg$parse(input, options) {
21000
20797
  }
21001
20798
  }
21002
20799
  if (s4 !== peg$FAILED) {
21003
- s0 = peg$f58(s2);
20800
+ s0 = peg$f56(s2);
21004
20801
  } else {
21005
20802
  peg$currPos = s0;
21006
20803
  s0 = peg$FAILED;
@@ -21102,17 +20899,17 @@ function peg$parse(input, options) {
21102
20899
  s5 = peg$parseUrl();
21103
20900
  if (s5 !== peg$FAILED) {
21104
20901
  if (input.charCodeAt(peg$currPos) === 124) {
21105
- s6 = peg$c1;
20902
+ s6 = peg$c0;
21106
20903
  peg$currPos++;
21107
20904
  } else {
21108
20905
  s6 = peg$FAILED;
21109
20906
  if (peg$silentFails === 0) {
21110
- peg$fail(peg$e3);
20907
+ peg$fail(peg$e2);
21111
20908
  }
21112
20909
  }
21113
20910
  if (s6 !== peg$FAILED) {
21114
20911
  s7 = peg$parseInlineMediaChain();
21115
- s0 = peg$f59(s2, s5, s7);
20912
+ s0 = peg$f57(s2, s5, s7);
21116
20913
  } else {
21117
20914
  peg$currPos = s0;
21118
20915
  s0 = peg$FAILED;
@@ -21211,7 +21008,7 @@ function peg$parse(input, options) {
21211
21008
  if (s3 !== peg$FAILED) {
21212
21009
  s4 = peg$parseAttrChain();
21213
21010
  if (s4 !== peg$FAILED) {
21214
- s0 = peg$f60(s2, s4);
21011
+ s0 = peg$f58(s2, s4);
21215
21012
  } else {
21216
21013
  peg$currPos = s0;
21217
21014
  s0 = peg$FAILED;
@@ -21300,7 +21097,7 @@ function peg$parse(input, options) {
21300
21097
  s2 = input.substring(s2, peg$currPos);
21301
21098
  s3 = peg$parseBoldTag();
21302
21099
  if (s3 !== peg$FAILED) {
21303
- s0 = peg$f61(s2);
21100
+ s0 = peg$f59(s2);
21304
21101
  } else {
21305
21102
  peg$currPos = s0;
21306
21103
  s0 = peg$FAILED;
@@ -21385,7 +21182,7 @@ function peg$parse(input, options) {
21385
21182
  s2 = input.substring(s2, peg$currPos);
21386
21183
  s3 = peg$parseItalicTag();
21387
21184
  if (s3 !== peg$FAILED) {
21388
- s0 = peg$f62(s2);
21185
+ s0 = peg$f60(s2);
21389
21186
  } else {
21390
21187
  peg$currPos = s0;
21391
21188
  s0 = peg$FAILED;
@@ -21470,7 +21267,7 @@ function peg$parse(input, options) {
21470
21267
  s2 = input.substring(s2, peg$currPos);
21471
21268
  s3 = peg$parseLightTag();
21472
21269
  if (s3 !== peg$FAILED) {
21473
- s0 = peg$f63(s2);
21270
+ s0 = peg$f61(s2);
21474
21271
  } else {
21475
21272
  peg$currPos = s0;
21476
21273
  s0 = peg$FAILED;
@@ -21555,7 +21352,7 @@ function peg$parse(input, options) {
21555
21352
  s2 = input.substring(s2, peg$currPos);
21556
21353
  s3 = peg$parseHighlightTag();
21557
21354
  if (s3 !== peg$FAILED) {
21558
- s0 = peg$f64(s2);
21355
+ s0 = peg$f62(s2);
21559
21356
  } else {
21560
21357
  peg$currPos = s0;
21561
21358
  s0 = peg$FAILED;
@@ -21568,7 +21365,7 @@ function peg$parse(input, options) {
21568
21365
  s0 = peg$currPos;
21569
21366
  s1 = peg$parseUrl();
21570
21367
  if (s1 !== peg$FAILED) {
21571
- s1 = peg$f65(s1);
21368
+ s1 = peg$f63(s1);
21572
21369
  }
21573
21370
  s0 = s1;
21574
21371
  }
@@ -21683,12 +21480,12 @@ function peg$parse(input, options) {
21683
21480
  let s0, s1, s2, s3;
21684
21481
  s0 = peg$currPos;
21685
21482
  if (input.charCodeAt(peg$currPos) === 124) {
21686
- s1 = peg$c1;
21483
+ s1 = peg$c0;
21687
21484
  peg$currPos++;
21688
21485
  } else {
21689
21486
  s1 = peg$FAILED;
21690
21487
  if (peg$silentFails === 0) {
21691
- peg$fail(peg$e3);
21488
+ peg$fail(peg$e2);
21692
21489
  }
21693
21490
  }
21694
21491
  if (s1 !== peg$FAILED) {
@@ -21703,7 +21500,7 @@ function peg$parse(input, options) {
21703
21500
  s2 = peg$FAILED;
21704
21501
  }
21705
21502
  if (s2 !== peg$FAILED) {
21706
- s0 = peg$f66(s2);
21503
+ s0 = peg$f64(s2);
21707
21504
  } else {
21708
21505
  peg$currPos = s0;
21709
21506
  s0 = peg$FAILED;
@@ -21723,7 +21520,7 @@ function peg$parse(input, options) {
21723
21520
  s1.push(s2);
21724
21521
  s2 = peg$parseInlineMediaChainItem();
21725
21522
  }
21726
- s1 = peg$f67(s1);
21523
+ s1 = peg$f65(s1);
21727
21524
  s0 = s1;
21728
21525
  return s0;
21729
21526
  }
@@ -21796,7 +21593,7 @@ function peg$parse(input, options) {
21796
21593
  s2 = input.substring(s2, peg$currPos);
21797
21594
  s3 = peg$parseBlockTag();
21798
21595
  if (s3 !== peg$FAILED) {
21799
- s0 = peg$f68(s2);
21596
+ s0 = peg$f66(s2);
21800
21597
  } else {
21801
21598
  peg$currPos = s0;
21802
21599
  s0 = peg$FAILED;
@@ -21830,34 +21627,34 @@ function peg$parse(input, options) {
21830
21627
  }
21831
21628
  if (s2 !== peg$FAILED) {
21832
21629
  if (input.charCodeAt(peg$currPos) === 58) {
21833
- s3 = peg$c6;
21630
+ s3 = peg$c5;
21834
21631
  peg$currPos++;
21835
21632
  } else {
21836
21633
  s3 = peg$FAILED;
21837
21634
  if (peg$silentFails === 0) {
21838
- peg$fail(peg$e9);
21635
+ peg$fail(peg$e8);
21839
21636
  }
21840
21637
  }
21841
21638
  if (s3 !== peg$FAILED) {
21842
21639
  s4 = [];
21843
21640
  if (input.charCodeAt(peg$currPos) === 32) {
21844
- s5 = peg$c13;
21641
+ s5 = peg$c12;
21845
21642
  peg$currPos++;
21846
21643
  } else {
21847
21644
  s5 = peg$FAILED;
21848
21645
  if (peg$silentFails === 0) {
21849
- peg$fail(peg$e17);
21646
+ peg$fail(peg$e16);
21850
21647
  }
21851
21648
  }
21852
21649
  while (s5 !== peg$FAILED) {
21853
21650
  s4.push(s5);
21854
21651
  if (input.charCodeAt(peg$currPos) === 32) {
21855
- s5 = peg$c13;
21652
+ s5 = peg$c12;
21856
21653
  peg$currPos++;
21857
21654
  } else {
21858
21655
  s5 = peg$FAILED;
21859
21656
  if (peg$silentFails === 0) {
21860
- peg$fail(peg$e17);
21657
+ peg$fail(peg$e16);
21861
21658
  }
21862
21659
  }
21863
21660
  }
@@ -21917,7 +21714,7 @@ function peg$parse(input, options) {
21917
21714
  s5 = input.substring(s5, peg$currPos);
21918
21715
  s6 = peg$parseBlockTag();
21919
21716
  if (s6 !== peg$FAILED) {
21920
- s0 = peg$f69(s2, s5);
21717
+ s0 = peg$f67(s2, s5);
21921
21718
  } else {
21922
21719
  peg$currPos = s0;
21923
21720
  s0 = peg$FAILED;
@@ -21947,34 +21744,34 @@ function peg$parse(input, options) {
21947
21744
  s2 = peg$parseMediaSizeTags();
21948
21745
  if (s2 !== peg$FAILED) {
21949
21746
  if (input.charCodeAt(peg$currPos) === 58) {
21950
- s3 = peg$c6;
21747
+ s3 = peg$c5;
21951
21748
  peg$currPos++;
21952
21749
  } else {
21953
21750
  s3 = peg$FAILED;
21954
21751
  if (peg$silentFails === 0) {
21955
- peg$fail(peg$e9);
21752
+ peg$fail(peg$e8);
21956
21753
  }
21957
21754
  }
21958
21755
  if (s3 !== peg$FAILED) {
21959
21756
  s4 = [];
21960
21757
  if (input.charCodeAt(peg$currPos) === 32) {
21961
- s5 = peg$c13;
21758
+ s5 = peg$c12;
21962
21759
  peg$currPos++;
21963
21760
  } else {
21964
21761
  s5 = peg$FAILED;
21965
21762
  if (peg$silentFails === 0) {
21966
- peg$fail(peg$e17);
21763
+ peg$fail(peg$e16);
21967
21764
  }
21968
21765
  }
21969
21766
  while (s5 !== peg$FAILED) {
21970
21767
  s4.push(s5);
21971
21768
  if (input.charCodeAt(peg$currPos) === 32) {
21972
- s5 = peg$c13;
21769
+ s5 = peg$c12;
21973
21770
  peg$currPos++;
21974
21771
  } else {
21975
21772
  s5 = peg$FAILED;
21976
21773
  if (peg$silentFails === 0) {
21977
- peg$fail(peg$e17);
21774
+ peg$fail(peg$e16);
21978
21775
  }
21979
21776
  }
21980
21777
  }
@@ -21998,7 +21795,7 @@ function peg$parse(input, options) {
21998
21795
  } else {
21999
21796
  s9 = peg$FAILED;
22000
21797
  if (peg$silentFails === 0) {
22001
- peg$fail(peg$e16);
21798
+ peg$fail(peg$e15);
22002
21799
  }
22003
21800
  }
22004
21801
  if (s9 !== peg$FAILED) {
@@ -22033,7 +21830,7 @@ function peg$parse(input, options) {
22033
21830
  } else {
22034
21831
  s9 = peg$FAILED;
22035
21832
  if (peg$silentFails === 0) {
22036
- peg$fail(peg$e16);
21833
+ peg$fail(peg$e15);
22037
21834
  }
22038
21835
  }
22039
21836
  if (s9 !== peg$FAILED) {
@@ -22059,7 +21856,7 @@ function peg$parse(input, options) {
22059
21856
  if (s5 !== peg$FAILED) {
22060
21857
  s6 = peg$parseBlockTag();
22061
21858
  if (s6 !== peg$FAILED) {
22062
- s0 = peg$f70(s2, s5);
21859
+ s0 = peg$f68(s2, s5);
22063
21860
  } else {
22064
21861
  peg$currPos = s0;
22065
21862
  s0 = peg$FAILED;
@@ -22093,34 +21890,34 @@ function peg$parse(input, options) {
22093
21890
  s2 = peg$parseMediaSizeTags();
22094
21891
  if (s2 !== peg$FAILED) {
22095
21892
  if (input.charCodeAt(peg$currPos) === 58) {
22096
- s3 = peg$c6;
21893
+ s3 = peg$c5;
22097
21894
  peg$currPos++;
22098
21895
  } else {
22099
21896
  s3 = peg$FAILED;
22100
21897
  if (peg$silentFails === 0) {
22101
- peg$fail(peg$e9);
21898
+ peg$fail(peg$e8);
22102
21899
  }
22103
21900
  }
22104
21901
  if (s3 !== peg$FAILED) {
22105
21902
  s4 = [];
22106
21903
  if (input.charCodeAt(peg$currPos) === 32) {
22107
- s5 = peg$c13;
21904
+ s5 = peg$c12;
22108
21905
  peg$currPos++;
22109
21906
  } else {
22110
21907
  s5 = peg$FAILED;
22111
21908
  if (peg$silentFails === 0) {
22112
- peg$fail(peg$e17);
21909
+ peg$fail(peg$e16);
22113
21910
  }
22114
21911
  }
22115
21912
  while (s5 !== peg$FAILED) {
22116
21913
  s4.push(s5);
22117
21914
  if (input.charCodeAt(peg$currPos) === 32) {
22118
- s5 = peg$c13;
21915
+ s5 = peg$c12;
22119
21916
  peg$currPos++;
22120
21917
  } else {
22121
21918
  s5 = peg$FAILED;
22122
21919
  if (peg$silentFails === 0) {
22123
- peg$fail(peg$e17);
21920
+ peg$fail(peg$e16);
22124
21921
  }
22125
21922
  }
22126
21923
  }
@@ -22180,7 +21977,7 @@ function peg$parse(input, options) {
22180
21977
  s5 = input.substring(s5, peg$currPos);
22181
21978
  s6 = peg$parseBlockTag();
22182
21979
  if (s6 !== peg$FAILED) {
22183
- s0 = peg$f71(s2, s5);
21980
+ s0 = peg$f69(s2, s5);
22184
21981
  } else {
22185
21982
  peg$currPos = s0;
22186
21983
  s0 = peg$FAILED;
@@ -22218,34 +22015,34 @@ function peg$parse(input, options) {
22218
22015
  }
22219
22016
  if (s2 !== peg$FAILED) {
22220
22017
  if (input.charCodeAt(peg$currPos) === 58) {
22221
- s3 = peg$c6;
22018
+ s3 = peg$c5;
22222
22019
  peg$currPos++;
22223
22020
  } else {
22224
22021
  s3 = peg$FAILED;
22225
22022
  if (peg$silentFails === 0) {
22226
- peg$fail(peg$e9);
22023
+ peg$fail(peg$e8);
22227
22024
  }
22228
22025
  }
22229
22026
  if (s3 !== peg$FAILED) {
22230
22027
  s4 = [];
22231
22028
  if (input.charCodeAt(peg$currPos) === 32) {
22232
- s5 = peg$c13;
22029
+ s5 = peg$c12;
22233
22030
  peg$currPos++;
22234
22031
  } else {
22235
22032
  s5 = peg$FAILED;
22236
22033
  if (peg$silentFails === 0) {
22237
- peg$fail(peg$e17);
22034
+ peg$fail(peg$e16);
22238
22035
  }
22239
22036
  }
22240
22037
  while (s5 !== peg$FAILED) {
22241
22038
  s4.push(s5);
22242
22039
  if (input.charCodeAt(peg$currPos) === 32) {
22243
- s5 = peg$c13;
22040
+ s5 = peg$c12;
22244
22041
  peg$currPos++;
22245
22042
  } else {
22246
22043
  s5 = peg$FAILED;
22247
22044
  if (peg$silentFails === 0) {
22248
- peg$fail(peg$e17);
22045
+ peg$fail(peg$e16);
22249
22046
  }
22250
22047
  }
22251
22048
  }
@@ -22253,7 +22050,7 @@ function peg$parse(input, options) {
22253
22050
  if (s5 !== peg$FAILED) {
22254
22051
  s6 = peg$parseBlockTag();
22255
22052
  if (s6 !== peg$FAILED) {
22256
- s0 = peg$f72(s2, s5);
22053
+ s0 = peg$f70(s2, s5);
22257
22054
  } else {
22258
22055
  peg$currPos = s0;
22259
22056
  s0 = peg$FAILED;
@@ -22295,34 +22092,34 @@ function peg$parse(input, options) {
22295
22092
  }
22296
22093
  if (s2 !== peg$FAILED) {
22297
22094
  if (input.charCodeAt(peg$currPos) === 58) {
22298
- s3 = peg$c6;
22095
+ s3 = peg$c5;
22299
22096
  peg$currPos++;
22300
22097
  } else {
22301
22098
  s3 = peg$FAILED;
22302
22099
  if (peg$silentFails === 0) {
22303
- peg$fail(peg$e9);
22100
+ peg$fail(peg$e8);
22304
22101
  }
22305
22102
  }
22306
22103
  if (s3 !== peg$FAILED) {
22307
22104
  s4 = [];
22308
22105
  if (input.charCodeAt(peg$currPos) === 32) {
22309
- s5 = peg$c13;
22106
+ s5 = peg$c12;
22310
22107
  peg$currPos++;
22311
22108
  } else {
22312
22109
  s5 = peg$FAILED;
22313
22110
  if (peg$silentFails === 0) {
22314
- peg$fail(peg$e17);
22111
+ peg$fail(peg$e16);
22315
22112
  }
22316
22113
  }
22317
22114
  while (s5 !== peg$FAILED) {
22318
22115
  s4.push(s5);
22319
22116
  if (input.charCodeAt(peg$currPos) === 32) {
22320
- s5 = peg$c13;
22117
+ s5 = peg$c12;
22321
22118
  peg$currPos++;
22322
22119
  } else {
22323
22120
  s5 = peg$FAILED;
22324
22121
  if (peg$silentFails === 0) {
22325
- peg$fail(peg$e17);
22122
+ peg$fail(peg$e16);
22326
22123
  }
22327
22124
  }
22328
22125
  }
@@ -22330,7 +22127,7 @@ function peg$parse(input, options) {
22330
22127
  if (s5 !== peg$FAILED) {
22331
22128
  s6 = peg$parseBlockTag();
22332
22129
  if (s6 !== peg$FAILED) {
22333
- s0 = peg$f73(s2, s5);
22130
+ s0 = peg$f71(s2, s5);
22334
22131
  } else {
22335
22132
  peg$currPos = s0;
22336
22133
  s0 = peg$FAILED;
@@ -22570,7 +22367,7 @@ function peg$parse(input, options) {
22570
22367
  s2 = input.substring(s2, peg$currPos);
22571
22368
  s3 = peg$parseBlockTag();
22572
22369
  if (s3 !== peg$FAILED) {
22573
- s0 = peg$f74(s2);
22370
+ s0 = peg$f72(s2);
22574
22371
  } else {
22575
22372
  peg$currPos = s0;
22576
22373
  s0 = peg$FAILED;
@@ -22714,7 +22511,7 @@ function peg$parse(input, options) {
22714
22511
  s6 = input.substring(s6, peg$currPos);
22715
22512
  s7 = peg$parseBlockTag();
22716
22513
  if (s7 !== peg$FAILED) {
22717
- s0 = peg$f75(s2, s3, s6);
22514
+ s0 = peg$f73(s2, s3, s6);
22718
22515
  } else {
22719
22516
  peg$currPos = s0;
22720
22517
  s0 = peg$FAILED;
@@ -22865,7 +22662,7 @@ function peg$parse(input, options) {
22865
22662
  s5 = input.substring(s5, peg$currPos);
22866
22663
  s6 = peg$parseBlockTag();
22867
22664
  if (s6 !== peg$FAILED) {
22868
- s0 = peg$f76(s2, s5);
22665
+ s0 = peg$f74(s2, s5);
22869
22666
  } else {
22870
22667
  peg$currPos = s0;
22871
22668
  s0 = peg$FAILED;
@@ -22950,7 +22747,7 @@ function peg$parse(input, options) {
22950
22747
  s2 = input.substring(s2, peg$currPos);
22951
22748
  s3 = peg$parseBlockTag();
22952
22749
  if (s3 !== peg$FAILED) {
22953
- s0 = peg$f77(s2);
22750
+ s0 = peg$f75(s2);
22954
22751
  } else {
22955
22752
  peg$currPos = s0;
22956
22753
  s0 = peg$FAILED;
@@ -23027,7 +22824,7 @@ function peg$parse(input, options) {
23027
22824
  s2 = input.substring(s2, peg$currPos);
23028
22825
  s3 = peg$parseBlockTag();
23029
22826
  if (s3 !== peg$FAILED) {
23030
- s0 = peg$f78(s2);
22827
+ s0 = peg$f76(s2);
23031
22828
  } else {
23032
22829
  peg$currPos = s0;
23033
22830
  s0 = peg$FAILED;
@@ -23105,7 +22902,7 @@ function peg$parse(input, options) {
23105
22902
  s3 = peg$parseBlockTag();
23106
22903
  if (s3 !== peg$FAILED) {
23107
22904
  s4 = peg$parseMediaChain();
23108
- s0 = peg$f79(s2, s4);
22905
+ s0 = peg$f77(s2, s4);
23109
22906
  } else {
23110
22907
  peg$currPos = s0;
23111
22908
  s0 = peg$FAILED;
@@ -23182,7 +22979,7 @@ function peg$parse(input, options) {
23182
22979
  s2 = input.substring(s2, peg$currPos);
23183
22980
  s3 = peg$parseBlockTag();
23184
22981
  if (s3 !== peg$FAILED) {
23185
- s0 = peg$f80(s2);
22982
+ s0 = peg$f78(s2);
23186
22983
  } else {
23187
22984
  peg$currPos = s0;
23188
22985
  s0 = peg$FAILED;
@@ -23259,7 +23056,7 @@ function peg$parse(input, options) {
23259
23056
  s2 = input.substring(s2, peg$currPos);
23260
23057
  s3 = peg$parseBlockTag();
23261
23058
  if (s3 !== peg$FAILED) {
23262
- s0 = peg$f81(s2);
23059
+ s0 = peg$f79(s2);
23263
23060
  } else {
23264
23061
  peg$currPos = s0;
23265
23062
  s0 = peg$FAILED;
@@ -23336,7 +23133,7 @@ function peg$parse(input, options) {
23336
23133
  s2 = input.substring(s2, peg$currPos);
23337
23134
  s3 = peg$parseBlockTag();
23338
23135
  if (s3 !== peg$FAILED) {
23339
- s0 = peg$f82(s2);
23136
+ s0 = peg$f80(s2);
23340
23137
  } else {
23341
23138
  peg$currPos = s0;
23342
23139
  s0 = peg$FAILED;
@@ -23347,19 +23144,19 @@ function peg$parse(input, options) {
23347
23144
  }
23348
23145
  if (s0 === peg$FAILED) {
23349
23146
  s0 = peg$currPos;
23350
- if (input.substr(peg$currPos, 4) === peg$c5) {
23351
- s1 = peg$c5;
23147
+ if (input.substr(peg$currPos, 4) === peg$c4) {
23148
+ s1 = peg$c4;
23352
23149
  peg$currPos += 4;
23353
23150
  } else {
23354
23151
  s1 = peg$FAILED;
23355
23152
  if (peg$silentFails === 0) {
23356
- peg$fail(peg$e7);
23153
+ peg$fail(peg$e6);
23357
23154
  }
23358
23155
  }
23359
23156
  if (s1 !== peg$FAILED) {
23360
23157
  s2 = peg$parseBlockTag();
23361
23158
  if (s2 !== peg$FAILED) {
23362
- s0 = peg$f83();
23159
+ s0 = peg$f81();
23363
23160
  } else {
23364
23161
  peg$currPos = s0;
23365
23162
  s0 = peg$FAILED;
@@ -23436,7 +23233,7 @@ function peg$parse(input, options) {
23436
23233
  s2 = input.substring(s2, peg$currPos);
23437
23234
  s3 = peg$parseBlockTag();
23438
23235
  if (s3 !== peg$FAILED) {
23439
- s0 = peg$f84(s2);
23236
+ s0 = peg$f82(s2);
23440
23237
  } else {
23441
23238
  peg$currPos = s0;
23442
23239
  s0 = peg$FAILED;
@@ -23459,7 +23256,7 @@ function peg$parse(input, options) {
23459
23256
  if (s1 !== peg$FAILED) {
23460
23257
  s2 = peg$parseBlockTag();
23461
23258
  if (s2 !== peg$FAILED) {
23462
- s0 = peg$f85();
23259
+ s0 = peg$f83();
23463
23260
  } else {
23464
23261
  peg$currPos = s0;
23465
23262
  s0 = peg$FAILED;
@@ -23536,7 +23333,7 @@ function peg$parse(input, options) {
23536
23333
  s2 = input.substring(s2, peg$currPos);
23537
23334
  s3 = peg$parseBlockTag();
23538
23335
  if (s3 !== peg$FAILED) {
23539
- s0 = peg$f86(s2);
23336
+ s0 = peg$f84(s2);
23540
23337
  } else {
23541
23338
  peg$currPos = s0;
23542
23339
  s0 = peg$FAILED;
@@ -23637,7 +23434,7 @@ function peg$parse(input, options) {
23637
23434
  if (s2 !== peg$FAILED) {
23638
23435
  s3 = peg$parseBlockTag();
23639
23436
  if (s3 !== peg$FAILED) {
23640
- s0 = peg$f87(s2);
23437
+ s0 = peg$f85(s2);
23641
23438
  } else {
23642
23439
  peg$currPos = s0;
23643
23440
  s0 = peg$FAILED;
@@ -23666,7 +23463,7 @@ function peg$parse(input, options) {
23666
23463
  if (s2 !== peg$FAILED) {
23667
23464
  s3 = peg$parseBlockTag();
23668
23465
  if (s3 !== peg$FAILED) {
23669
- s0 = peg$f88(s2);
23466
+ s0 = peg$f86(s2);
23670
23467
  } else {
23671
23468
  peg$currPos = s0;
23672
23469
  s0 = peg$FAILED;
@@ -23747,7 +23544,7 @@ function peg$parse(input, options) {
23747
23544
  s2 = input.substring(s2, peg$currPos);
23748
23545
  s3 = peg$parseBlockTag();
23749
23546
  if (s3 !== peg$FAILED) {
23750
- s0 = peg$f89(s2);
23547
+ s0 = peg$f87(s2);
23751
23548
  } else {
23752
23549
  peg$currPos = s0;
23753
23550
  s0 = peg$FAILED;
@@ -23762,7 +23559,7 @@ function peg$parse(input, options) {
23762
23559
  if (s1 !== peg$FAILED) {
23763
23560
  s2 = peg$parseBlockTag();
23764
23561
  if (s2 !== peg$FAILED) {
23765
- s0 = peg$f90(s1);
23562
+ s0 = peg$f88(s1);
23766
23563
  } else {
23767
23564
  peg$currPos = s0;
23768
23565
  s0 = peg$FAILED;
@@ -23839,7 +23636,7 @@ function peg$parse(input, options) {
23839
23636
  s2 = input.substring(s2, peg$currPos);
23840
23637
  s3 = peg$parseBlockTag();
23841
23638
  if (s3 !== peg$FAILED) {
23842
- s0 = peg$f91(s2);
23639
+ s0 = peg$f89(s2);
23843
23640
  } else {
23844
23641
  peg$currPos = s0;
23845
23642
  s0 = peg$FAILED;
@@ -23944,7 +23741,7 @@ function peg$parse(input, options) {
23944
23741
  }
23945
23742
  }
23946
23743
  s2 = input.substring(s2, peg$currPos);
23947
- s0 = peg$f92(s2);
23744
+ s0 = peg$f90(s2);
23948
23745
  } else {
23949
23746
  peg$currPos = s0;
23950
23747
  s0 = peg$FAILED;
@@ -24653,7 +24450,7 @@ function peg$parse(input, options) {
24653
24450
  peg$silentFails++;
24654
24451
  s0 = peg$currPos;
24655
24452
  s1 = peg$parsebitmarkMinusMinusString();
24656
- s1 = peg$f93(s1);
24453
+ s1 = peg$f91(s1);
24657
24454
  s0 = s1;
24658
24455
  peg$silentFails--;
24659
24456
  return s0;
@@ -24678,7 +24475,7 @@ function peg$parse(input, options) {
24678
24475
  s3 = peg$parsePlainText();
24679
24476
  }
24680
24477
  }
24681
- s0 = peg$f94(s1, s2);
24478
+ s0 = peg$f92(s1, s2);
24682
24479
  peg$silentFails--;
24683
24480
  return s0;
24684
24481
  }
@@ -24687,7 +24484,7 @@ function peg$parse(input, options) {
24687
24484
  s0 = peg$currPos;
24688
24485
  s1 = peg$parseNL();
24689
24486
  if (s1 !== peg$FAILED) {
24690
- s1 = peg$f95();
24487
+ s1 = peg$f93();
24691
24488
  }
24692
24489
  s0 = s1;
24693
24490
  if (s0 === peg$FAILED) {
@@ -24815,7 +24612,7 @@ function peg$parse(input, options) {
24815
24612
  s1 = s2;
24816
24613
  }
24817
24614
  if (s1 !== peg$FAILED) {
24818
- s1 = peg$f96(s1);
24615
+ s1 = peg$f94(s1);
24819
24616
  }
24820
24617
  s0 = s1;
24821
24618
  }
@@ -24988,7 +24785,7 @@ function peg$parse(input, options) {
24988
24785
  } else {
24989
24786
  s4 = peg$FAILED;
24990
24787
  if (peg$silentFails === 0) {
24991
- peg$fail(peg$e16);
24788
+ peg$fail(peg$e15);
24992
24789
  }
24993
24790
  }
24994
24791
  if (s4 !== peg$FAILED) {
@@ -25000,7 +24797,7 @@ function peg$parse(input, options) {
25000
24797
  } else {
25001
24798
  s4 = peg$FAILED;
25002
24799
  if (peg$silentFails === 0) {
25003
- peg$fail(peg$e16);
24800
+ peg$fail(peg$e15);
25004
24801
  }
25005
24802
  }
25006
24803
  }
@@ -25015,7 +24812,7 @@ function peg$parse(input, options) {
25015
24812
  if (s2 !== peg$FAILED) {
25016
24813
  s3 = peg$parseBodyBitCloseTag();
25017
24814
  if (s3 !== peg$FAILED) {
25018
- s0 = peg$f97(s2);
24815
+ s0 = peg$f95(s2);
25019
24816
  } else {
25020
24817
  peg$currPos = s0;
25021
24818
  s0 = peg$FAILED;
@@ -25104,7 +24901,7 @@ function peg$parse(input, options) {
25104
24901
  s2 = input.substring(s2, peg$currPos);
25105
24902
  s3 = peg$parseBoldTag();
25106
24903
  if (s3 !== peg$FAILED) {
25107
- s0 = peg$f98(s2);
24904
+ s0 = peg$f96(s2);
25108
24905
  } else {
25109
24906
  peg$currPos = s0;
25110
24907
  s0 = peg$FAILED;
@@ -25189,7 +24986,7 @@ function peg$parse(input, options) {
25189
24986
  s2 = input.substring(s2, peg$currPos);
25190
24987
  s3 = peg$parseItalicTag();
25191
24988
  if (s3 !== peg$FAILED) {
25192
- s0 = peg$f99(s2);
24989
+ s0 = peg$f97(s2);
25193
24990
  } else {
25194
24991
  peg$currPos = s0;
25195
24992
  s0 = peg$FAILED;
@@ -25274,7 +25071,7 @@ function peg$parse(input, options) {
25274
25071
  s2 = input.substring(s2, peg$currPos);
25275
25072
  s3 = peg$parseLightTag();
25276
25073
  if (s3 !== peg$FAILED) {
25277
- s0 = peg$f100(s2);
25074
+ s0 = peg$f98(s2);
25278
25075
  } else {
25279
25076
  peg$currPos = s0;
25280
25077
  s0 = peg$FAILED;
@@ -25359,7 +25156,7 @@ function peg$parse(input, options) {
25359
25156
  s2 = input.substring(s2, peg$currPos);
25360
25157
  s3 = peg$parseHighlightTag();
25361
25158
  if (s3 !== peg$FAILED) {
25362
- s0 = peg$f101(s2);
25159
+ s0 = peg$f99(s2);
25363
25160
  } else {
25364
25161
  peg$currPos = s0;
25365
25162
  s0 = peg$FAILED;
@@ -25743,7 +25540,7 @@ function peg$parse(input, options) {
25743
25540
  }
25744
25541
  }
25745
25542
  s2 = input.substring(s2, peg$currPos);
25746
- s0 = peg$f102(s1, s2);
25543
+ s0 = peg$f100(s1, s2);
25747
25544
  } else {
25748
25545
  peg$currPos = s0;
25749
25546
  s0 = peg$FAILED;
@@ -25765,16 +25562,7 @@ function peg$parse(input, options) {
25765
25562
  }
25766
25563
  var indentStack = [], indent = "";
25767
25564
  input = input.replace(/\s+$/, "");
25768
- var _firstNonWs = input.search(/\S/);
25769
- if (_firstNonWs < 0) {
25770
- input = "";
25771
- } else {
25772
- var _lineStart = input.lastIndexOf("\n", _firstNonWs) + 1;
25773
- var _lead = input.slice(_lineStart, _firstNonWs);
25774
- var _rest = input.slice(_firstNonWs);
25775
- var _isIndentedListItem = /^\t+$/.test(_lead) && /^•([0-9]+[Ii]?|_|[Aa]|\+|-)? /.test(_rest);
25776
- input = _isIndentedListItem ? _lead + _rest : _rest;
25777
- }
25565
+ input = input.trimStart();
25778
25566
  peg$result = peg$startRuleFunction();
25779
25567
  const peg$success = peg$result !== peg$FAILED && peg$currPos === input.length;
25780
25568
  function peg$throw() {
@@ -25868,13 +25656,14 @@ var TextParser = class {
25868
25656
  */
25869
25657
  toAst(text, options) {
25870
25658
  if (Array.isArray(text)) return text;
25871
- const str = text ?? "";
25659
+ let str = text ?? "";
25872
25660
  if (!str) return [];
25873
25661
  const opts = Object.assign({}, options);
25874
25662
  let startRule = "bitmarkPlusPlus";
25875
25663
  if (opts.location === TextLocation.tag) {
25876
25664
  startRule = "bitmarkPlus";
25877
25665
  }
25666
+ str = str.trim();
25878
25667
  return parse(str, {
25879
25668
  startRule
25880
25669
  });