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