@podlite/schema 0.0.69 → 0.0.71
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/CHANGELOG.podlite +96 -0
- package/esm/ast-helpers.d.ts +11 -0
- package/esm/ast-helpers.js +279 -27
- package/esm/ast-helpers.js.map +1 -1
- package/esm/ast-inerator.js +1 -1
- package/esm/block-names.d.ts +2 -2
- package/esm/block-names.js +7 -0
- package/esm/block-names.js.map +1 -1
- package/esm/blocks-helpers.d.ts +1 -1
- package/esm/blocks-helpers.js +3 -1
- package/esm/blocks-helpers.js.map +1 -1
- package/esm/exportAny.js +5 -5
- package/esm/exportHtml.js +95 -38
- package/esm/exportHtml.js.map +1 -1
- package/esm/exportMarkdown.js +120 -35
- package/esm/exportMarkdown.js.map +1 -1
- package/esm/grammar.js +588 -454
- package/esm/grammar.js.map +1 -1
- package/esm/guard.js +12 -2
- package/esm/guard.js.map +1 -1
- package/esm/helpers/blockName.d.ts +8 -0
- package/esm/helpers/blockName.js +60 -0
- package/esm/helpers/blockName.js.map +1 -0
- package/esm/helpers/configPropagation.d.ts +12 -2
- package/esm/helpers/configPropagation.js +51 -13
- package/esm/helpers/configPropagation.js.map +1 -1
- package/esm/helpers/corePlugins.d.ts +1 -1
- package/esm/helpers/corePlugins.js +7 -5
- package/esm/helpers/corePlugins.js.map +1 -1
- package/esm/helpers/handlers.js +3 -3
- package/esm/helpers/ids.js +1 -1
- package/esm/helpers/makeInterator.js +3 -2
- package/esm/helpers/makeInterator.js.map +1 -1
- package/esm/helpers/makeTransformer.js +1 -1
- package/esm/helpers/parseAttributes.js +1 -1
- package/esm/index.d.ts +13 -3
- package/esm/index.js +59 -47
- package/esm/index.js.map +1 -1
- package/esm/pluggableParser.d.ts +6 -2
- package/esm/pluggableParser.js +15 -15
- package/esm/pluggableParser.js.map +1 -1
- package/esm/plugin-clean-location.js +1 -1
- package/esm/plugin-data-table.js +7 -8
- package/esm/plugin-data-table.js.map +1 -1
- package/esm/plugin-defn-fill-term.js +1 -1
- package/esm/plugin-formatting-codes.js +70 -29
- package/esm/plugin-formatting-codes.js.map +1 -1
- package/esm/plugin-group-items.js +1 -1
- package/esm/plugin-set.js +15 -18
- package/esm/plugin-set.js.map +1 -1
- package/esm/plugin-tables.js +8 -3
- package/esm/plugin-tables.js.map +1 -1
- package/esm/query-helpers.js +1 -1
- package/esm/selectors.d.ts +25 -8
- package/esm/selectors.js +399 -142
- package/esm/selectors.js.map +1 -1
- package/esm/set-assign.d.ts +17 -0
- package/esm/set-assign.js +143 -0
- package/esm/set-assign.js.map +1 -0
- package/esm/test-display.d.ts +3 -0
- package/esm/test-display.js +58 -0
- package/esm/test-display.js.map +1 -0
- package/esm/toc-caption.d.ts +7 -0
- package/esm/toc-caption.js +23 -0
- package/esm/toc-caption.js.map +1 -0
- package/esm/types.d.ts +16 -1
- package/esm/version.d.ts +1 -1
- package/esm/version.js +1 -1
- package/esm/writerHtml.js +1 -1
- package/esm/writerMarkdown.js +1 -1
- package/lib/ast-helpers.d.ts +11 -0
- package/lib/ast-helpers.js +279 -26
- package/lib/block-names.d.ts +2 -2
- package/lib/block-names.js +7 -0
- package/lib/blocks-helpers.d.ts +1 -1
- package/lib/blocks-helpers.js +3 -1
- package/lib/exportHtml.js +84 -27
- package/lib/exportMarkdown.js +111 -26
- package/lib/grammar.js +588 -454
- package/lib/guard.js +11 -1
- package/lib/helpers/blockName.d.ts +8 -0
- package/lib/helpers/blockName.js +66 -0
- package/lib/helpers/configPropagation.d.ts +12 -2
- package/lib/helpers/configPropagation.js +54 -14
- package/lib/helpers/corePlugins.d.ts +1 -1
- package/lib/helpers/corePlugins.js +4 -2
- package/lib/helpers/makeInterator.js +3 -2
- package/lib/index.d.ts +13 -3
- package/lib/index.js +33 -6
- package/lib/pluggableParser.d.ts +6 -2
- package/lib/pluggableParser.js +5 -5
- package/lib/plugin-data-table.js +4 -5
- package/lib/plugin-formatting-codes.js +65 -24
- package/lib/plugin-set.js +15 -18
- package/lib/plugin-tables.js +6 -1
- package/lib/selectors.d.ts +25 -8
- package/lib/selectors.js +401 -141
- package/lib/set-assign.d.ts +17 -0
- package/lib/set-assign.js +150 -0
- package/lib/test-display.d.ts +3 -0
- package/lib/test-display.js +67 -0
- package/lib/toc-caption.d.ts +7 -0
- package/lib/toc-caption.js +27 -0
- package/lib/types.d.ts +16 -1
- package/lib/version.d.ts +1 -1
- package/lib/version.js +1 -1
- package/package.json +3 -3
- package/schema/AstTree.json +160 -0
- package/schema/PodliteDocument.json +160 -0
- package/esm/helpers/makeQuery.test.d.ts +0 -1
- package/esm/helpers/makeQuery.test.js +0 -51
- package/esm/helpers/makeQuery.test.js.map +0 -1
- package/lib/helpers/makeQuery.test.d.ts +0 -1
- package/lib/helpers/makeQuery.test.js +0 -51
package/esm/grammar.js
CHANGED
|
@@ -113,47 +113,49 @@ function peg$parse(input, options) {
|
|
|
113
113
|
type: 'ambient',
|
|
114
114
|
location: location()
|
|
115
115
|
};
|
|
116
|
-
}, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () {
|
|
116
|
+
}, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () {
|
|
117
|
+
noteUnknownDirective(options, text(), location());
|
|
118
|
+
return text();
|
|
119
|
+
}, peg$c36 = function () { return text(); }, peg$c37 = function () {
|
|
117
120
|
addDiagnostic(options, "Line looks like a directive but could not be read; it stays as text", location(), 'directive-unreadable');
|
|
121
|
+
noteRecognition(options, { kind: 'unreadable-directive', location: location() });
|
|
118
122
|
return { type: "para", value: text(), error: true, location: location() };
|
|
119
|
-
}, peg$
|
|
123
|
+
}, peg$c38 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c39 = function (code) { return [code]; }, peg$c40 = /^[ \t]/, peg$c41 = peg$classExpectation([" ", "\t"], false, false), peg$c42 = ",", peg$c43 = peg$literalExpectation(",", false), peg$c44 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c45 = /^[a-zA-Z0-9]/, peg$c46 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c47 = /^[a-zA-Z0-9_\-]/, peg$c48 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c49 = function (attr) { return !attr.dropped; }, peg$c50 = function (attr) { return { [attr.name]: attr.value }; }, peg$c51 = "=>", peg$c52 = peg$literalExpectation("=>", false), peg$c53 = function (name, value) { return { [name]: value }; }, peg$c54 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c55 = function (code) { return code; }, peg$c56 = ":", peg$c57 = peg$literalExpectation(":", false), peg$c58 = /^[!]/, peg$c59 = peg$classExpectation(["!"], false, false), peg$c60 = "allow", peg$c61 = peg$literalExpectation("allow", false), peg$c62 = "<", peg$c63 = peg$literalExpectation("<", false), peg$c64 = ">", peg$c65 = peg$literalExpectation(">", false), peg$c66 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c67 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c68 = function (isFalse, key, value) { return { name: 'allow', ...value, ...(isFalse ? { isFalse: true } : {}) }; }, peg$c69 = /^[^ \t\r\n,<>[\]{}()'"]/, peg$c70 = peg$classExpectation([" ", "\t", "\r", "\n", ",", "<", ">", "[", "]", "{", "}", "(", ")", "'", "\""], true, false), peg$c71 = function (first, i) { return i; }, peg$c72 = function (first, rest) { return flattenDeep([first, ...rest]); }, peg$c73 = function (i) { return i; }, peg$c74 = function (all) { return all; }, peg$c75 = function (res) { return [res]; }, peg$c76 = function () { return []; }, peg$c77 = "{", peg$c78 = peg$literalExpectation("{", false), peg$c79 = "}", peg$c80 = peg$literalExpectation("}", false), peg$c81 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c82 = function (isFalse, key) { return { value: {}, type: "map" }; }, peg$c83 = function (isFalse, key) { return { unreadable: true, location: location() }; }, peg$c84 = "[", peg$c85 = peg$literalExpectation("[", false), peg$c86 = "]", peg$c87 = peg$literalExpectation("]", false), peg$c88 = function (isFalse, key) {
|
|
120
124
|
return {
|
|
121
125
|
unreadable: true,
|
|
122
126
|
location: location(),
|
|
123
127
|
message: "Square brackets are not an attribute value form; write a list with angle brackets or parentheses"
|
|
124
128
|
};
|
|
125
|
-
}, peg$
|
|
129
|
+
}, peg$c89 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c90 = /^[']/, peg$c91 = peg$classExpectation(["'"], false, false), peg$c92 = /^[^'\n\r]/, peg$c93 = peg$classExpectation(["'", "\n", "\r"], true, false), peg$c94 = function (isFalse, key, text) { return { value: text, type: "string" }; }, peg$c95 = /^["]/, peg$c96 = peg$classExpectation(["\""], false, false), peg$c97 = /^[^"\n\r]/, peg$c98 = peg$classExpectation(["\"", "\n", "\r"], true, false), peg$c99 = function (isFalse, key, text) { return { value: text.trim(), type: "string" }; }, peg$c100 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c101 = "(", peg$c102 = peg$literalExpectation("(", false), peg$c103 = function (isFalse, key, array) {
|
|
126
130
|
return (array.length > 1)
|
|
127
131
|
? { type: 'array', value: array }
|
|
128
132
|
: { type: valueKind(array[0]), value: array[0] };
|
|
129
|
-
}, peg$
|
|
133
|
+
}, peg$c104 = ")", peg$c105 = peg$literalExpectation(")", false), peg$c106 = function (isFalse, key, res) { return res; }, peg$c107 = function (isFalse, key) {
|
|
130
134
|
return {
|
|
131
135
|
unreadable: true,
|
|
132
136
|
location: location(),
|
|
133
137
|
message: "Bare text in parentheses; quote it or use a number"
|
|
134
138
|
};
|
|
135
|
-
}, peg$
|
|
139
|
+
}, peg$c108 = "\uFF62", peg$c109 = peg$literalExpectation("\uFF62", false), peg$c110 = /^[^\uFF63\n\r]/, peg$c111 = peg$classExpectation(["\uFF63", "\n", "\r"], true, false), peg$c112 = "\uFF63", peg$c113 = peg$literalExpectation("\uFF63", false), peg$c114 = function (isFalse, key) {
|
|
136
140
|
return {
|
|
137
141
|
unreadable: true,
|
|
138
142
|
location: location(),
|
|
139
143
|
message: "Value is not closed; only a bracketed value may continue on the next configuration line"
|
|
140
144
|
};
|
|
141
|
-
}, peg$
|
|
145
|
+
}, peg$c115 = function (isFalse, key) {
|
|
142
146
|
return {
|
|
143
147
|
value: !isFalse,
|
|
144
148
|
type: "boolean"
|
|
145
149
|
};
|
|
146
|
-
}, peg$
|
|
150
|
+
}, peg$c116 = function (isFalse, key, value) {
|
|
147
151
|
if (value.unreadable) {
|
|
148
152
|
addDiagnostic(options, value.message || `cannot read the value of :${key}`, value.location);
|
|
149
153
|
return { name: key, dropped: true };
|
|
150
154
|
}
|
|
151
155
|
return { name: key, ...value, ...(isFalse && value.type !== 'boolean' ? { isFalse: true } : {}) };
|
|
152
|
-
}, peg$
|
|
153
|
-
return (
|
|
154
|
-
|
|
155
|
-
isNamedBlock(name));
|
|
156
|
-
}, peg$c139 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c140 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c141 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c142 = function (vmargin, name, config, content, vmargin2, ename) {
|
|
156
|
+
}, peg$c117 = function (first, rest) { return rest; }, peg$c118 = function (first, cont, unread) { return keepReadable(flattenDeep([...first, ...cont])); }, peg$c119 = function () { addDiagnostic(options, "Configuration continuation line could not be read", location()); }, peg$c120 = /^[^'"]/, peg$c121 = peg$classExpectation(["'", "\""], true, false), peg$c122 = function (text) { return text; }, peg$c123 = /^[0-9]/, peg$c124 = peg$classExpectation([["0", "9"]], false, false), peg$c125 = /^[\-+]/, peg$c126 = peg$classExpectation(["-", "+"], false, false), peg$c127 = "True", peg$c128 = peg$literalExpectation("True", false), peg$c129 = function () { return true; }, peg$c130 = "False", peg$c131 = peg$literalExpectation("False", false), peg$c132 = function () { return false; }, peg$c133 = ".", peg$c134 = peg$literalExpectation(".", false), peg$c135 = /^[eE]/, peg$c136 = peg$classExpectation(["e", "E"], false, false), peg$c137 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c138 = function (number) { return parseInt(number, 10); }, peg$c139 = function (vmargin, name, config) {
|
|
157
|
+
return isRawBlock(name);
|
|
158
|
+
}, peg$c140 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c141 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c142 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c143 = function (vmargin, name, config, content, vmargin2, ename) {
|
|
157
159
|
const type = 'block';
|
|
158
160
|
return {
|
|
159
161
|
type: type,
|
|
@@ -161,29 +163,29 @@ function peg$parse(input, options) {
|
|
|
161
163
|
name,
|
|
162
164
|
margin: vmargin
|
|
163
165
|
};
|
|
164
|
-
}, peg$
|
|
166
|
+
}, peg$c144 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c145 = function (vmargin, name, config, content, vmargin2, res) {
|
|
165
167
|
return {
|
|
166
168
|
...res,
|
|
167
169
|
text: text(),
|
|
168
170
|
config,
|
|
169
171
|
location: location()
|
|
170
172
|
};
|
|
171
|
-
}, peg$
|
|
173
|
+
}, peg$c146 = /^[\-+=_|]/, peg$c147 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c148 = function () { return { type: 'separator', text: text() }; }, peg$c149 = function () { return options.isDelimited; }, peg$c150 = function () {
|
|
172
174
|
return {
|
|
173
175
|
type: 'separator',
|
|
174
176
|
text: text()
|
|
175
177
|
};
|
|
176
|
-
}, peg$
|
|
178
|
+
}, peg$c151 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c152 = function () {
|
|
177
179
|
// reset separator count and its accum
|
|
178
180
|
options.separators = [];
|
|
179
181
|
return true;
|
|
180
|
-
}, peg$
|
|
182
|
+
}, peg$c153 = function (head, t) {
|
|
181
183
|
options.separators.push(t.text);
|
|
182
184
|
return t;
|
|
183
|
-
}, peg$
|
|
185
|
+
}, peg$c154 = function (head, separator, rowtext, t) {
|
|
184
186
|
options.separators.push(t.text);
|
|
185
187
|
return t;
|
|
186
|
-
}, peg$
|
|
188
|
+
}, peg$c155 = function (head, separator, rowtext, bseparator) {
|
|
187
189
|
return [
|
|
188
190
|
{
|
|
189
191
|
name: 'row',
|
|
@@ -192,14 +194,14 @@ function peg$parse(input, options) {
|
|
|
192
194
|
},
|
|
193
195
|
bseparator
|
|
194
196
|
];
|
|
195
|
-
}, peg$
|
|
197
|
+
}, peg$c156 = function (head, separator, singleRow) { return [singleRow]; }, peg$c157 = function (head, separator, rest) {
|
|
196
198
|
// if more then 1 separator and it equal - table doesn't have header
|
|
197
199
|
if (options.separators.length > 1) {
|
|
198
200
|
// check if separators equal (for table without header)
|
|
199
201
|
return !options.separators.every(val => val === options.separators[0]);
|
|
200
202
|
}
|
|
201
203
|
return true;
|
|
202
|
-
}, peg$
|
|
204
|
+
}, peg$c158 = function (head, separator, rest) {
|
|
203
205
|
return [
|
|
204
206
|
{
|
|
205
207
|
name: 'head',
|
|
@@ -209,7 +211,7 @@ function peg$parse(input, options) {
|
|
|
209
211
|
separator,
|
|
210
212
|
...flattenDeep(rest)
|
|
211
213
|
];
|
|
212
|
-
}, peg$
|
|
214
|
+
}, peg$c159 = function (rowtest, bseparator) {
|
|
213
215
|
return [
|
|
214
216
|
{
|
|
215
217
|
name: 'row',
|
|
@@ -218,37 +220,37 @@ function peg$parse(input, options) {
|
|
|
218
220
|
},
|
|
219
221
|
bseparator
|
|
220
222
|
];
|
|
221
|
-
}, peg$
|
|
223
|
+
}, peg$c160 = function (rest) {
|
|
222
224
|
return [...flattenDeep(rest)];
|
|
223
|
-
}, peg$
|
|
225
|
+
}, peg$c161 = function (vmargin, name, config) { return name === 'table'; }, peg$c162 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c163 = function (vmargin, name, config, nodes) { return nodes; }, peg$c164 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c165 = function (vmargin, name, config, content, vmargin2, ename) {
|
|
224
226
|
return {
|
|
225
227
|
type: 'block',
|
|
226
228
|
content,
|
|
227
229
|
name,
|
|
228
230
|
margin: vmargin
|
|
229
231
|
};
|
|
230
|
-
}, peg$
|
|
232
|
+
}, peg$c166 = function (vmargin, name, config, content, vmargin2, res) {
|
|
231
233
|
return {
|
|
232
234
|
...res,
|
|
233
235
|
text: text(),
|
|
234
236
|
config,
|
|
235
237
|
location: location()
|
|
236
238
|
};
|
|
237
|
-
}, peg$
|
|
239
|
+
}, peg$c167 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c168 = function (vmargin, name, config, t) { return t; }, peg$c169 = function (vmargin, name, config, content, vmargin2, ename) {
|
|
238
240
|
return {
|
|
239
241
|
type: 'block',
|
|
240
242
|
content: content,
|
|
241
243
|
name,
|
|
242
244
|
margin: vmargin
|
|
243
245
|
};
|
|
244
|
-
}, peg$
|
|
246
|
+
}, peg$c170 = function (vmargin, name, config, content, vmargin2, res) {
|
|
245
247
|
return {
|
|
246
248
|
...res,
|
|
247
249
|
text: text(),
|
|
248
250
|
config,
|
|
249
251
|
location: location()
|
|
250
252
|
};
|
|
251
|
-
}, peg$
|
|
253
|
+
}, peg$c171 = function (vmargin, name, config, nodes) { return nodes; }, peg$c172 = function (vmargin, name, config, tvmargin, text) {
|
|
252
254
|
const type = name.match(/pod|nested|item|code|defn/)
|
|
253
255
|
&&
|
|
254
256
|
(tvmargin.length - vmargin.length) > 0 ? 'code' : 'para';
|
|
@@ -264,20 +266,20 @@ function peg$parse(input, options) {
|
|
|
264
266
|
],
|
|
265
267
|
location: location(),
|
|
266
268
|
};
|
|
267
|
-
}, peg$
|
|
269
|
+
}, peg$c173 = function (vmargin, name, config, content, vmargin2, ename) {
|
|
268
270
|
return {
|
|
269
271
|
type: 'block',
|
|
270
272
|
content,
|
|
271
273
|
name,
|
|
272
274
|
margin: vmargin,
|
|
273
275
|
};
|
|
274
|
-
}, peg$
|
|
276
|
+
}, peg$c174 = function (vmargin, name, config, content, vmargin2, res) {
|
|
275
277
|
return {
|
|
276
278
|
...res,
|
|
277
279
|
config,
|
|
278
280
|
location: location(),
|
|
279
281
|
};
|
|
280
|
-
}, peg$
|
|
282
|
+
}, peg$c175 = function () {
|
|
281
283
|
return {
|
|
282
284
|
text: text(),
|
|
283
285
|
type: 'para',
|
|
@@ -290,11 +292,9 @@ function peg$parse(input, options) {
|
|
|
290
292
|
],
|
|
291
293
|
location: location(),
|
|
292
294
|
};
|
|
293
|
-
}, peg$
|
|
294
|
-
return (
|
|
295
|
-
|
|
296
|
-
isNamedBlock(name));
|
|
297
|
-
}, peg$c180 = function (vmargin, name, content) {
|
|
295
|
+
}, peg$c176 = function () { return { empty: 1 }; }, peg$c177 = /^[s]/, peg$c178 = peg$classExpectation(["s"], false, false), peg$c179 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c180 = function (vmargin, name) {
|
|
296
|
+
return isRawBlock(name);
|
|
297
|
+
}, peg$c181 = function (vmargin, name, content) {
|
|
298
298
|
return {
|
|
299
299
|
margin: vmargin,
|
|
300
300
|
type: 'block',
|
|
@@ -303,7 +303,7 @@ function peg$parse(input, options) {
|
|
|
303
303
|
config: [],
|
|
304
304
|
location: location()
|
|
305
305
|
};
|
|
306
|
-
}, peg$
|
|
306
|
+
}, peg$c182 = function (vmargin, name) { return name === 'table'; }, peg$c183 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c184 = function (vmargin, name, content) {
|
|
307
307
|
return {
|
|
308
308
|
margin: vmargin,
|
|
309
309
|
type: 'block',
|
|
@@ -313,7 +313,7 @@ function peg$parse(input, options) {
|
|
|
313
313
|
config: [],
|
|
314
314
|
location: location()
|
|
315
315
|
};
|
|
316
|
-
}, peg$
|
|
316
|
+
}, peg$c185 = function (vmargin, name, first_line, content_rest) {
|
|
317
317
|
const content = (first_line === "\n" ? "" : first_line) + content_rest;
|
|
318
318
|
return {
|
|
319
319
|
margin: vmargin,
|
|
@@ -336,7 +336,7 @@ function peg$parse(input, options) {
|
|
|
336
336
|
name,
|
|
337
337
|
location: location()
|
|
338
338
|
};
|
|
339
|
-
}, peg$
|
|
339
|
+
}, peg$c186 = "= ", peg$c187 = peg$literalExpectation("= ", false), peg$c188 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c189 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c190 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c191 = function (v) { return { kind: 'value', value: v }; }, peg$c192 = function (seg) { return seg; }, peg$c193 = "=set", peg$c194 = peg$literalExpectation("=set", false), peg$c195 = function (vmargin, first, cont) {
|
|
340
340
|
const items = [];
|
|
341
341
|
let pending = null;
|
|
342
342
|
const flush = () => {
|
|
@@ -366,21 +366,21 @@ function peg$parse(input, options) {
|
|
|
366
366
|
margin: vmargin,
|
|
367
367
|
location: location()
|
|
368
368
|
};
|
|
369
|
-
}, peg$
|
|
369
|
+
}, peg$c196 = function (vmargin, marker, name, replacement) {
|
|
370
370
|
return {
|
|
371
371
|
name,
|
|
372
372
|
type: 'alias',
|
|
373
373
|
replacement,
|
|
374
374
|
margin: vmargin
|
|
375
375
|
};
|
|
376
|
-
}, peg$
|
|
376
|
+
}, peg$c197 = /^[A-Z]/, peg$c198 = peg$classExpectation([["A", "Z"]], false, false), peg$c199 = "<>", peg$c200 = peg$literalExpectation("<>", false), peg$c201 = function (vmargin, marker, name, config) {
|
|
377
377
|
return {
|
|
378
378
|
name,
|
|
379
379
|
type: 'config',
|
|
380
380
|
config,
|
|
381
381
|
margin: vmargin
|
|
382
382
|
};
|
|
383
|
-
}, peg$
|
|
383
|
+
}, peg$c202 = "=boundary", peg$c203 = peg$literalExpectation("=boundary", false), peg$c204 = function (vmargin, marker, config) {
|
|
384
384
|
return {
|
|
385
385
|
name: 'boundary',
|
|
386
386
|
type: 'block',
|
|
@@ -389,11 +389,9 @@ function peg$parse(input, options) {
|
|
|
389
389
|
margin: vmargin,
|
|
390
390
|
location: location()
|
|
391
391
|
};
|
|
392
|
-
}, peg$
|
|
393
|
-
return (
|
|
394
|
-
|
|
395
|
-
isNamedBlock(name));
|
|
396
|
-
}, peg$c205 = function (vmargin, marker, name, config, content) {
|
|
392
|
+
}, peg$c205 = function (vmargin, marker, name, config) {
|
|
393
|
+
return isRawBlock(name);
|
|
394
|
+
}, peg$c206 = function (vmargin, marker, name, config, content) {
|
|
397
395
|
return {
|
|
398
396
|
type: 'block',
|
|
399
397
|
content: content === "" ? [] : [{ type: 'verbatim', value: content }],
|
|
@@ -402,7 +400,7 @@ function peg$parse(input, options) {
|
|
|
402
400
|
config,
|
|
403
401
|
location: location()
|
|
404
402
|
};
|
|
405
|
-
}, peg$
|
|
403
|
+
}, peg$c207 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c208 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c209 = function (vmargin, marker, name, config, content) {
|
|
406
404
|
return {
|
|
407
405
|
type: 'block',
|
|
408
406
|
content: content === "" ? [] : content,
|
|
@@ -411,7 +409,7 @@ function peg$parse(input, options) {
|
|
|
411
409
|
config,
|
|
412
410
|
location: location()
|
|
413
411
|
};
|
|
414
|
-
}, peg$
|
|
412
|
+
}, peg$c210 = function (vmargin, marker, name, config, content) {
|
|
415
413
|
return {
|
|
416
414
|
type: 'block',
|
|
417
415
|
content: content === "" ? []
|
|
@@ -434,7 +432,7 @@ function peg$parse(input, options) {
|
|
|
434
432
|
config,
|
|
435
433
|
location: location()
|
|
436
434
|
};
|
|
437
|
-
}, peg$
|
|
435
|
+
}, peg$c211 = /^[a-zA-Z]/, peg$c212 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c213 = peg$otherExpectation("whitespace"), peg$c214 = /^[\r\n \t\f]/, peg$c215 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c216 = peg$otherExpectation("space characters"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
|
|
438
436
|
if ("startRule" in options) {
|
|
439
437
|
if (!(options.startRule in peg$startRuleFunctions)) {
|
|
440
438
|
throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
|
|
@@ -1401,7 +1399,7 @@ function peg$parse(input, options) {
|
|
|
1401
1399
|
s2 = peg$parseEOL();
|
|
1402
1400
|
if (s2 !== peg$FAILED) {
|
|
1403
1401
|
peg$savedPos = s0;
|
|
1404
|
-
s1 = peg$
|
|
1402
|
+
s1 = peg$c36();
|
|
1405
1403
|
s0 = s1;
|
|
1406
1404
|
}
|
|
1407
1405
|
else {
|
|
@@ -1415,6 +1413,106 @@ function peg$parse(input, options) {
|
|
|
1415
1413
|
}
|
|
1416
1414
|
return s0;
|
|
1417
1415
|
}
|
|
1416
|
+
function peg$parseplain_line() {
|
|
1417
|
+
var s0, s1, s2, s3, s4, s5, s6;
|
|
1418
|
+
s0 = peg$currPos;
|
|
1419
|
+
s1 = peg$currPos;
|
|
1420
|
+
peg$silentFails++;
|
|
1421
|
+
s2 = peg$currPos;
|
|
1422
|
+
s3 = peg$parse_();
|
|
1423
|
+
if (s3 !== peg$FAILED) {
|
|
1424
|
+
s4 = peg$parsemarkerConfig();
|
|
1425
|
+
if (s4 === peg$FAILED) {
|
|
1426
|
+
s4 = peg$parsemarkerAlias();
|
|
1427
|
+
if (s4 === peg$FAILED) {
|
|
1428
|
+
s4 = peg$currPos;
|
|
1429
|
+
s5 = peg$parsemarkers();
|
|
1430
|
+
if (s5 !== peg$FAILED) {
|
|
1431
|
+
s6 = peg$parsestrictIdentifier();
|
|
1432
|
+
if (s6 !== peg$FAILED) {
|
|
1433
|
+
s5 = [s5, s6];
|
|
1434
|
+
s4 = s5;
|
|
1435
|
+
}
|
|
1436
|
+
else {
|
|
1437
|
+
peg$currPos = s4;
|
|
1438
|
+
s4 = peg$FAILED;
|
|
1439
|
+
}
|
|
1440
|
+
}
|
|
1441
|
+
else {
|
|
1442
|
+
peg$currPos = s4;
|
|
1443
|
+
s4 = peg$FAILED;
|
|
1444
|
+
}
|
|
1445
|
+
if (s4 === peg$FAILED) {
|
|
1446
|
+
s4 = peg$parsemarkerAbbreviatedBlock();
|
|
1447
|
+
}
|
|
1448
|
+
}
|
|
1449
|
+
}
|
|
1450
|
+
if (s4 !== peg$FAILED) {
|
|
1451
|
+
s3 = [s3, s4];
|
|
1452
|
+
s2 = s3;
|
|
1453
|
+
}
|
|
1454
|
+
else {
|
|
1455
|
+
peg$currPos = s2;
|
|
1456
|
+
s2 = peg$FAILED;
|
|
1457
|
+
}
|
|
1458
|
+
}
|
|
1459
|
+
else {
|
|
1460
|
+
peg$currPos = s2;
|
|
1461
|
+
s2 = peg$FAILED;
|
|
1462
|
+
}
|
|
1463
|
+
if (s2 === peg$FAILED) {
|
|
1464
|
+
s2 = peg$parseblankline();
|
|
1465
|
+
}
|
|
1466
|
+
peg$silentFails--;
|
|
1467
|
+
if (s2 === peg$FAILED) {
|
|
1468
|
+
s1 = void 0;
|
|
1469
|
+
}
|
|
1470
|
+
else {
|
|
1471
|
+
peg$currPos = s1;
|
|
1472
|
+
s1 = peg$FAILED;
|
|
1473
|
+
}
|
|
1474
|
+
if (s1 !== peg$FAILED) {
|
|
1475
|
+
s2 = peg$currPos;
|
|
1476
|
+
s3 = [];
|
|
1477
|
+
s4 = peg$parseText();
|
|
1478
|
+
if (s4 !== peg$FAILED) {
|
|
1479
|
+
while (s4 !== peg$FAILED) {
|
|
1480
|
+
s3.push(s4);
|
|
1481
|
+
s4 = peg$parseText();
|
|
1482
|
+
}
|
|
1483
|
+
}
|
|
1484
|
+
else {
|
|
1485
|
+
s3 = peg$FAILED;
|
|
1486
|
+
}
|
|
1487
|
+
if (s3 !== peg$FAILED) {
|
|
1488
|
+
s2 = input.substring(s2, peg$currPos);
|
|
1489
|
+
}
|
|
1490
|
+
else {
|
|
1491
|
+
s2 = s3;
|
|
1492
|
+
}
|
|
1493
|
+
if (s2 !== peg$FAILED) {
|
|
1494
|
+
s3 = peg$parseEOL();
|
|
1495
|
+
if (s3 !== peg$FAILED) {
|
|
1496
|
+
peg$savedPos = s0;
|
|
1497
|
+
s1 = peg$c36();
|
|
1498
|
+
s0 = s1;
|
|
1499
|
+
}
|
|
1500
|
+
else {
|
|
1501
|
+
peg$currPos = s0;
|
|
1502
|
+
s0 = peg$FAILED;
|
|
1503
|
+
}
|
|
1504
|
+
}
|
|
1505
|
+
else {
|
|
1506
|
+
peg$currPos = s0;
|
|
1507
|
+
s0 = peg$FAILED;
|
|
1508
|
+
}
|
|
1509
|
+
}
|
|
1510
|
+
else {
|
|
1511
|
+
peg$currPos = s0;
|
|
1512
|
+
s0 = peg$FAILED;
|
|
1513
|
+
}
|
|
1514
|
+
return s0;
|
|
1515
|
+
}
|
|
1418
1516
|
function peg$parseerror_para() {
|
|
1419
1517
|
var s0, s1, s2, s3, s4, s5;
|
|
1420
1518
|
s0 = peg$currPos;
|
|
@@ -1510,7 +1608,7 @@ function peg$parse(input, options) {
|
|
|
1510
1608
|
s2 = peg$parseEOL();
|
|
1511
1609
|
if (s2 !== peg$FAILED) {
|
|
1512
1610
|
peg$savedPos = s0;
|
|
1513
|
-
s1 = peg$
|
|
1611
|
+
s1 = peg$c37();
|
|
1514
1612
|
s0 = s1;
|
|
1515
1613
|
}
|
|
1516
1614
|
else {
|
|
@@ -1544,7 +1642,7 @@ function peg$parse(input, options) {
|
|
|
1544
1642
|
s3 = peg$parsearray_codes();
|
|
1545
1643
|
if (s3 !== peg$FAILED) {
|
|
1546
1644
|
peg$savedPos = s0;
|
|
1547
|
-
s1 = peg$
|
|
1645
|
+
s1 = peg$c38(s1, s3);
|
|
1548
1646
|
s0 = s1;
|
|
1549
1647
|
}
|
|
1550
1648
|
else {
|
|
@@ -1566,7 +1664,7 @@ function peg$parse(input, options) {
|
|
|
1566
1664
|
s1 = peg$parseFCode();
|
|
1567
1665
|
if (s1 !== peg$FAILED) {
|
|
1568
1666
|
peg$savedPos = s0;
|
|
1569
|
-
s1 = peg$
|
|
1667
|
+
s1 = peg$c39(s1);
|
|
1570
1668
|
}
|
|
1571
1669
|
s0 = s1;
|
|
1572
1670
|
}
|
|
@@ -1601,27 +1699,27 @@ function peg$parse(input, options) {
|
|
|
1601
1699
|
}
|
|
1602
1700
|
if (s2 !== peg$FAILED) {
|
|
1603
1701
|
s3 = [];
|
|
1604
|
-
if (peg$
|
|
1702
|
+
if (peg$c40.test(input.charAt(peg$currPos))) {
|
|
1605
1703
|
s4 = input.charAt(peg$currPos);
|
|
1606
1704
|
peg$currPos++;
|
|
1607
1705
|
}
|
|
1608
1706
|
else {
|
|
1609
1707
|
s4 = peg$FAILED;
|
|
1610
1708
|
if (peg$silentFails === 0) {
|
|
1611
|
-
peg$fail(peg$
|
|
1709
|
+
peg$fail(peg$c41);
|
|
1612
1710
|
}
|
|
1613
1711
|
}
|
|
1614
1712
|
if (s4 !== peg$FAILED) {
|
|
1615
1713
|
while (s4 !== peg$FAILED) {
|
|
1616
1714
|
s3.push(s4);
|
|
1617
|
-
if (peg$
|
|
1715
|
+
if (peg$c40.test(input.charAt(peg$currPos))) {
|
|
1618
1716
|
s4 = input.charAt(peg$currPos);
|
|
1619
1717
|
peg$currPos++;
|
|
1620
1718
|
}
|
|
1621
1719
|
else {
|
|
1622
1720
|
s4 = peg$FAILED;
|
|
1623
1721
|
if (peg$silentFails === 0) {
|
|
1624
|
-
peg$fail(peg$
|
|
1722
|
+
peg$fail(peg$c41);
|
|
1625
1723
|
}
|
|
1626
1724
|
}
|
|
1627
1725
|
}
|
|
@@ -1704,13 +1802,13 @@ function peg$parse(input, options) {
|
|
|
1704
1802
|
s3 = peg$parsegap();
|
|
1705
1803
|
if (s3 !== peg$FAILED) {
|
|
1706
1804
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
1707
|
-
s4 = peg$
|
|
1805
|
+
s4 = peg$c42;
|
|
1708
1806
|
peg$currPos++;
|
|
1709
1807
|
}
|
|
1710
1808
|
else {
|
|
1711
1809
|
s4 = peg$FAILED;
|
|
1712
1810
|
if (peg$silentFails === 0) {
|
|
1713
|
-
peg$fail(peg$
|
|
1811
|
+
peg$fail(peg$c43);
|
|
1714
1812
|
}
|
|
1715
1813
|
}
|
|
1716
1814
|
if (s4 !== peg$FAILED) {
|
|
@@ -1738,7 +1836,7 @@ function peg$parse(input, options) {
|
|
|
1738
1836
|
s3 = peg$parsearray_items();
|
|
1739
1837
|
if (s3 !== peg$FAILED) {
|
|
1740
1838
|
peg$savedPos = s0;
|
|
1741
|
-
s1 = peg$
|
|
1839
|
+
s1 = peg$c44(s1, s3);
|
|
1742
1840
|
s0 = s1;
|
|
1743
1841
|
}
|
|
1744
1842
|
else {
|
|
@@ -1760,7 +1858,7 @@ function peg$parse(input, options) {
|
|
|
1760
1858
|
s1 = peg$parseitem();
|
|
1761
1859
|
if (s1 !== peg$FAILED) {
|
|
1762
1860
|
peg$savedPos = s0;
|
|
1763
|
-
s1 = peg$
|
|
1861
|
+
s1 = peg$c39(s1);
|
|
1764
1862
|
}
|
|
1765
1863
|
s0 = s1;
|
|
1766
1864
|
}
|
|
@@ -1771,27 +1869,27 @@ function peg$parse(input, options) {
|
|
|
1771
1869
|
s0 = peg$currPos;
|
|
1772
1870
|
s1 = peg$currPos;
|
|
1773
1871
|
s2 = [];
|
|
1774
|
-
if (peg$
|
|
1872
|
+
if (peg$c45.test(input.charAt(peg$currPos))) {
|
|
1775
1873
|
s3 = input.charAt(peg$currPos);
|
|
1776
1874
|
peg$currPos++;
|
|
1777
1875
|
}
|
|
1778
1876
|
else {
|
|
1779
1877
|
s3 = peg$FAILED;
|
|
1780
1878
|
if (peg$silentFails === 0) {
|
|
1781
|
-
peg$fail(peg$
|
|
1879
|
+
peg$fail(peg$c46);
|
|
1782
1880
|
}
|
|
1783
1881
|
}
|
|
1784
1882
|
if (s3 !== peg$FAILED) {
|
|
1785
1883
|
while (s3 !== peg$FAILED) {
|
|
1786
1884
|
s2.push(s3);
|
|
1787
|
-
if (peg$
|
|
1885
|
+
if (peg$c45.test(input.charAt(peg$currPos))) {
|
|
1788
1886
|
s3 = input.charAt(peg$currPos);
|
|
1789
1887
|
peg$currPos++;
|
|
1790
1888
|
}
|
|
1791
1889
|
else {
|
|
1792
1890
|
s3 = peg$FAILED;
|
|
1793
1891
|
if (peg$silentFails === 0) {
|
|
1794
|
-
peg$fail(peg$
|
|
1892
|
+
peg$fail(peg$c46);
|
|
1795
1893
|
}
|
|
1796
1894
|
}
|
|
1797
1895
|
}
|
|
@@ -1801,26 +1899,26 @@ function peg$parse(input, options) {
|
|
|
1801
1899
|
}
|
|
1802
1900
|
if (s2 !== peg$FAILED) {
|
|
1803
1901
|
s3 = [];
|
|
1804
|
-
if (peg$
|
|
1902
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
1805
1903
|
s4 = input.charAt(peg$currPos);
|
|
1806
1904
|
peg$currPos++;
|
|
1807
1905
|
}
|
|
1808
1906
|
else {
|
|
1809
1907
|
s4 = peg$FAILED;
|
|
1810
1908
|
if (peg$silentFails === 0) {
|
|
1811
|
-
peg$fail(peg$
|
|
1909
|
+
peg$fail(peg$c48);
|
|
1812
1910
|
}
|
|
1813
1911
|
}
|
|
1814
1912
|
while (s4 !== peg$FAILED) {
|
|
1815
1913
|
s3.push(s4);
|
|
1816
|
-
if (peg$
|
|
1914
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
1817
1915
|
s4 = input.charAt(peg$currPos);
|
|
1818
1916
|
peg$currPos++;
|
|
1819
1917
|
}
|
|
1820
1918
|
else {
|
|
1821
1919
|
s4 = peg$FAILED;
|
|
1822
1920
|
if (peg$silentFails === 0) {
|
|
1823
|
-
peg$fail(peg$
|
|
1921
|
+
peg$fail(peg$c48);
|
|
1824
1922
|
}
|
|
1825
1923
|
}
|
|
1826
1924
|
}
|
|
@@ -1853,7 +1951,7 @@ function peg$parse(input, options) {
|
|
|
1853
1951
|
s2 = peg$parseattributes();
|
|
1854
1952
|
if (s2 !== peg$FAILED) {
|
|
1855
1953
|
peg$savedPos = peg$currPos;
|
|
1856
|
-
s3 = peg$
|
|
1954
|
+
s3 = peg$c49(s2);
|
|
1857
1955
|
if (s3) {
|
|
1858
1956
|
s3 = void 0;
|
|
1859
1957
|
}
|
|
@@ -1862,7 +1960,7 @@ function peg$parse(input, options) {
|
|
|
1862
1960
|
}
|
|
1863
1961
|
if (s3 !== peg$FAILED) {
|
|
1864
1962
|
peg$savedPos = s0;
|
|
1865
|
-
s1 = peg$
|
|
1963
|
+
s1 = peg$c50(s2);
|
|
1866
1964
|
s0 = s1;
|
|
1867
1965
|
}
|
|
1868
1966
|
else {
|
|
@@ -1888,24 +1986,24 @@ function peg$parse(input, options) {
|
|
|
1888
1986
|
s3 = peg$parsegap();
|
|
1889
1987
|
if (s3 !== peg$FAILED) {
|
|
1890
1988
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
1891
|
-
s4 = peg$
|
|
1989
|
+
s4 = peg$c42;
|
|
1892
1990
|
peg$currPos++;
|
|
1893
1991
|
}
|
|
1894
1992
|
else {
|
|
1895
1993
|
s4 = peg$FAILED;
|
|
1896
1994
|
if (peg$silentFails === 0) {
|
|
1897
|
-
peg$fail(peg$
|
|
1995
|
+
peg$fail(peg$c43);
|
|
1898
1996
|
}
|
|
1899
1997
|
}
|
|
1900
1998
|
if (s4 === peg$FAILED) {
|
|
1901
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
1902
|
-
s4 = peg$
|
|
1999
|
+
if (input.substr(peg$currPos, 2) === peg$c51) {
|
|
2000
|
+
s4 = peg$c51;
|
|
1903
2001
|
peg$currPos += 2;
|
|
1904
2002
|
}
|
|
1905
2003
|
else {
|
|
1906
2004
|
s4 = peg$FAILED;
|
|
1907
2005
|
if (peg$silentFails === 0) {
|
|
1908
|
-
peg$fail(peg$
|
|
2006
|
+
peg$fail(peg$c52);
|
|
1909
2007
|
}
|
|
1910
2008
|
}
|
|
1911
2009
|
}
|
|
@@ -1915,7 +2013,7 @@ function peg$parse(input, options) {
|
|
|
1915
2013
|
s6 = peg$parseitem();
|
|
1916
2014
|
if (s6 !== peg$FAILED) {
|
|
1917
2015
|
peg$savedPos = s0;
|
|
1918
|
-
s1 = peg$
|
|
2016
|
+
s1 = peg$c53(s2, s6);
|
|
1919
2017
|
s0 = s1;
|
|
1920
2018
|
}
|
|
1921
2019
|
else {
|
|
@@ -1958,13 +2056,13 @@ function peg$parse(input, options) {
|
|
|
1958
2056
|
s2 = peg$parsegap();
|
|
1959
2057
|
if (s2 !== peg$FAILED) {
|
|
1960
2058
|
if (input.charCodeAt(peg$currPos) === 44) {
|
|
1961
|
-
s3 = peg$
|
|
2059
|
+
s3 = peg$c42;
|
|
1962
2060
|
peg$currPos++;
|
|
1963
2061
|
}
|
|
1964
2062
|
else {
|
|
1965
2063
|
s3 = peg$FAILED;
|
|
1966
2064
|
if (peg$silentFails === 0) {
|
|
1967
|
-
peg$fail(peg$
|
|
2065
|
+
peg$fail(peg$c43);
|
|
1968
2066
|
}
|
|
1969
2067
|
}
|
|
1970
2068
|
if (s3 !== peg$FAILED) {
|
|
@@ -1973,7 +2071,7 @@ function peg$parse(input, options) {
|
|
|
1973
2071
|
s5 = peg$parsearray_pairs();
|
|
1974
2072
|
if (s5 !== peg$FAILED) {
|
|
1975
2073
|
peg$savedPos = s0;
|
|
1976
|
-
s1 = peg$
|
|
2074
|
+
s1 = peg$c54(s1, s5);
|
|
1977
2075
|
s0 = s1;
|
|
1978
2076
|
}
|
|
1979
2077
|
else {
|
|
@@ -2005,7 +2103,7 @@ function peg$parse(input, options) {
|
|
|
2005
2103
|
s1 = peg$parsepair_item();
|
|
2006
2104
|
if (s1 !== peg$FAILED) {
|
|
2007
2105
|
peg$savedPos = s0;
|
|
2008
|
-
s1 = peg$
|
|
2106
|
+
s1 = peg$c55(s1);
|
|
2009
2107
|
}
|
|
2010
2108
|
s0 = s1;
|
|
2011
2109
|
}
|
|
@@ -2017,50 +2115,50 @@ function peg$parse(input, options) {
|
|
|
2017
2115
|
s1 = peg$parse_();
|
|
2018
2116
|
if (s1 !== peg$FAILED) {
|
|
2019
2117
|
if (input.charCodeAt(peg$currPos) === 58) {
|
|
2020
|
-
s2 = peg$
|
|
2118
|
+
s2 = peg$c56;
|
|
2021
2119
|
peg$currPos++;
|
|
2022
2120
|
}
|
|
2023
2121
|
else {
|
|
2024
2122
|
s2 = peg$FAILED;
|
|
2025
2123
|
if (peg$silentFails === 0) {
|
|
2026
|
-
peg$fail(peg$
|
|
2124
|
+
peg$fail(peg$c57);
|
|
2027
2125
|
}
|
|
2028
2126
|
}
|
|
2029
2127
|
if (s2 !== peg$FAILED) {
|
|
2030
|
-
if (peg$
|
|
2128
|
+
if (peg$c58.test(input.charAt(peg$currPos))) {
|
|
2031
2129
|
s3 = input.charAt(peg$currPos);
|
|
2032
2130
|
peg$currPos++;
|
|
2033
2131
|
}
|
|
2034
2132
|
else {
|
|
2035
2133
|
s3 = peg$FAILED;
|
|
2036
2134
|
if (peg$silentFails === 0) {
|
|
2037
|
-
peg$fail(peg$
|
|
2135
|
+
peg$fail(peg$c59);
|
|
2038
2136
|
}
|
|
2039
2137
|
}
|
|
2040
2138
|
if (s3 === peg$FAILED) {
|
|
2041
2139
|
s3 = null;
|
|
2042
2140
|
}
|
|
2043
2141
|
if (s3 !== peg$FAILED) {
|
|
2044
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
2045
|
-
s4 = peg$
|
|
2142
|
+
if (input.substr(peg$currPos, 5) === peg$c60) {
|
|
2143
|
+
s4 = peg$c60;
|
|
2046
2144
|
peg$currPos += 5;
|
|
2047
2145
|
}
|
|
2048
2146
|
else {
|
|
2049
2147
|
s4 = peg$FAILED;
|
|
2050
2148
|
if (peg$silentFails === 0) {
|
|
2051
|
-
peg$fail(peg$
|
|
2149
|
+
peg$fail(peg$c61);
|
|
2052
2150
|
}
|
|
2053
2151
|
}
|
|
2054
2152
|
if (s4 !== peg$FAILED) {
|
|
2055
2153
|
s5 = peg$currPos;
|
|
2056
2154
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
2057
|
-
s6 = peg$
|
|
2155
|
+
s6 = peg$c62;
|
|
2058
2156
|
peg$currPos++;
|
|
2059
2157
|
}
|
|
2060
2158
|
else {
|
|
2061
2159
|
s6 = peg$FAILED;
|
|
2062
2160
|
if (peg$silentFails === 0) {
|
|
2063
|
-
peg$fail(peg$
|
|
2161
|
+
peg$fail(peg$c63);
|
|
2064
2162
|
}
|
|
2065
2163
|
}
|
|
2066
2164
|
if (s6 !== peg$FAILED) {
|
|
@@ -2071,18 +2169,18 @@ function peg$parse(input, options) {
|
|
|
2071
2169
|
s9 = peg$parse_();
|
|
2072
2170
|
if (s9 !== peg$FAILED) {
|
|
2073
2171
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
2074
|
-
s10 = peg$
|
|
2172
|
+
s10 = peg$c64;
|
|
2075
2173
|
peg$currPos++;
|
|
2076
2174
|
}
|
|
2077
2175
|
else {
|
|
2078
2176
|
s10 = peg$FAILED;
|
|
2079
2177
|
if (peg$silentFails === 0) {
|
|
2080
|
-
peg$fail(peg$
|
|
2178
|
+
peg$fail(peg$c65);
|
|
2081
2179
|
}
|
|
2082
2180
|
}
|
|
2083
2181
|
if (s10 !== peg$FAILED) {
|
|
2084
2182
|
peg$savedPos = s5;
|
|
2085
|
-
s6 = peg$
|
|
2183
|
+
s6 = peg$c66(s3, s4, s8);
|
|
2086
2184
|
s5 = s6;
|
|
2087
2185
|
}
|
|
2088
2186
|
else {
|
|
@@ -2112,31 +2210,31 @@ function peg$parse(input, options) {
|
|
|
2112
2210
|
if (s5 === peg$FAILED) {
|
|
2113
2211
|
s5 = peg$currPos;
|
|
2114
2212
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
2115
|
-
s6 = peg$
|
|
2213
|
+
s6 = peg$c62;
|
|
2116
2214
|
peg$currPos++;
|
|
2117
2215
|
}
|
|
2118
2216
|
else {
|
|
2119
2217
|
s6 = peg$FAILED;
|
|
2120
2218
|
if (peg$silentFails === 0) {
|
|
2121
|
-
peg$fail(peg$
|
|
2219
|
+
peg$fail(peg$c63);
|
|
2122
2220
|
}
|
|
2123
2221
|
}
|
|
2124
2222
|
if (s6 !== peg$FAILED) {
|
|
2125
2223
|
s7 = peg$parse_();
|
|
2126
2224
|
if (s7 !== peg$FAILED) {
|
|
2127
2225
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
2128
|
-
s8 = peg$
|
|
2226
|
+
s8 = peg$c64;
|
|
2129
2227
|
peg$currPos++;
|
|
2130
2228
|
}
|
|
2131
2229
|
else {
|
|
2132
2230
|
s8 = peg$FAILED;
|
|
2133
2231
|
if (peg$silentFails === 0) {
|
|
2134
|
-
peg$fail(peg$
|
|
2232
|
+
peg$fail(peg$c65);
|
|
2135
2233
|
}
|
|
2136
2234
|
}
|
|
2137
2235
|
if (s8 !== peg$FAILED) {
|
|
2138
2236
|
peg$savedPos = s5;
|
|
2139
|
-
s6 = peg$
|
|
2237
|
+
s6 = peg$c67(s3, s4);
|
|
2140
2238
|
s5 = s6;
|
|
2141
2239
|
}
|
|
2142
2240
|
else {
|
|
@@ -2158,7 +2256,7 @@ function peg$parse(input, options) {
|
|
|
2158
2256
|
s6 = peg$parse_();
|
|
2159
2257
|
if (s6 !== peg$FAILED) {
|
|
2160
2258
|
peg$savedPos = s0;
|
|
2161
|
-
s1 = peg$
|
|
2259
|
+
s1 = peg$c68(s3, s4, s5);
|
|
2162
2260
|
s0 = s1;
|
|
2163
2261
|
}
|
|
2164
2262
|
else {
|
|
@@ -2196,27 +2294,27 @@ function peg$parse(input, options) {
|
|
|
2196
2294
|
var s0, s1, s2;
|
|
2197
2295
|
s0 = peg$currPos;
|
|
2198
2296
|
s1 = [];
|
|
2199
|
-
if (peg$
|
|
2297
|
+
if (peg$c69.test(input.charAt(peg$currPos))) {
|
|
2200
2298
|
s2 = input.charAt(peg$currPos);
|
|
2201
2299
|
peg$currPos++;
|
|
2202
2300
|
}
|
|
2203
2301
|
else {
|
|
2204
2302
|
s2 = peg$FAILED;
|
|
2205
2303
|
if (peg$silentFails === 0) {
|
|
2206
|
-
peg$fail(peg$
|
|
2304
|
+
peg$fail(peg$c70);
|
|
2207
2305
|
}
|
|
2208
2306
|
}
|
|
2209
2307
|
if (s2 !== peg$FAILED) {
|
|
2210
2308
|
while (s2 !== peg$FAILED) {
|
|
2211
2309
|
s1.push(s2);
|
|
2212
|
-
if (peg$
|
|
2310
|
+
if (peg$c69.test(input.charAt(peg$currPos))) {
|
|
2213
2311
|
s2 = input.charAt(peg$currPos);
|
|
2214
2312
|
peg$currPos++;
|
|
2215
2313
|
}
|
|
2216
2314
|
else {
|
|
2217
2315
|
s2 = peg$FAILED;
|
|
2218
2316
|
if (peg$silentFails === 0) {
|
|
2219
|
-
peg$fail(peg$
|
|
2317
|
+
peg$fail(peg$c70);
|
|
2220
2318
|
}
|
|
2221
2319
|
}
|
|
2222
2320
|
}
|
|
@@ -2262,7 +2360,7 @@ function peg$parse(input, options) {
|
|
|
2262
2360
|
s5 = peg$parselistItem();
|
|
2263
2361
|
if (s5 !== peg$FAILED) {
|
|
2264
2362
|
peg$savedPos = s3;
|
|
2265
|
-
s4 = peg$
|
|
2363
|
+
s4 = peg$c71(s1, s5);
|
|
2266
2364
|
s3 = s4;
|
|
2267
2365
|
}
|
|
2268
2366
|
else {
|
|
@@ -2293,7 +2391,7 @@ function peg$parse(input, options) {
|
|
|
2293
2391
|
s5 = peg$parselistItem();
|
|
2294
2392
|
if (s5 !== peg$FAILED) {
|
|
2295
2393
|
peg$savedPos = s3;
|
|
2296
|
-
s4 = peg$
|
|
2394
|
+
s4 = peg$c71(s1, s5);
|
|
2297
2395
|
s3 = s4;
|
|
2298
2396
|
}
|
|
2299
2397
|
else {
|
|
@@ -2312,7 +2410,7 @@ function peg$parse(input, options) {
|
|
|
2312
2410
|
}
|
|
2313
2411
|
if (s2 !== peg$FAILED) {
|
|
2314
2412
|
peg$savedPos = s0;
|
|
2315
|
-
s1 = peg$
|
|
2413
|
+
s1 = peg$c72(s1, s2);
|
|
2316
2414
|
s0 = s1;
|
|
2317
2415
|
}
|
|
2318
2416
|
else {
|
|
@@ -2338,7 +2436,7 @@ function peg$parse(input, options) {
|
|
|
2338
2436
|
s5 = peg$parse_();
|
|
2339
2437
|
if (s5 !== peg$FAILED) {
|
|
2340
2438
|
peg$savedPos = s2;
|
|
2341
|
-
s3 = peg$
|
|
2439
|
+
s3 = peg$c73(s4);
|
|
2342
2440
|
s2 = s3;
|
|
2343
2441
|
}
|
|
2344
2442
|
else {
|
|
@@ -2365,7 +2463,7 @@ function peg$parse(input, options) {
|
|
|
2365
2463
|
s5 = peg$parse_();
|
|
2366
2464
|
if (s5 !== peg$FAILED) {
|
|
2367
2465
|
peg$savedPos = s2;
|
|
2368
|
-
s3 = peg$
|
|
2466
|
+
s3 = peg$c73(s4);
|
|
2369
2467
|
s2 = s3;
|
|
2370
2468
|
}
|
|
2371
2469
|
else {
|
|
@@ -2385,7 +2483,7 @@ function peg$parse(input, options) {
|
|
|
2385
2483
|
}
|
|
2386
2484
|
if (s1 !== peg$FAILED) {
|
|
2387
2485
|
peg$savedPos = s0;
|
|
2388
|
-
s1 = peg$
|
|
2486
|
+
s1 = peg$c74(s1);
|
|
2389
2487
|
}
|
|
2390
2488
|
s0 = s1;
|
|
2391
2489
|
if (s0 === peg$FAILED) {
|
|
@@ -2393,7 +2491,7 @@ function peg$parse(input, options) {
|
|
|
2393
2491
|
s1 = peg$parseitem();
|
|
2394
2492
|
if (s1 !== peg$FAILED) {
|
|
2395
2493
|
peg$savedPos = s0;
|
|
2396
|
-
s1 = peg$
|
|
2494
|
+
s1 = peg$c75(s1);
|
|
2397
2495
|
}
|
|
2398
2496
|
s0 = s1;
|
|
2399
2497
|
if (s0 === peg$FAILED) {
|
|
@@ -2401,7 +2499,7 @@ function peg$parse(input, options) {
|
|
|
2401
2499
|
s1 = peg$parse_();
|
|
2402
2500
|
if (s1 !== peg$FAILED) {
|
|
2403
2501
|
peg$savedPos = s0;
|
|
2404
|
-
s1 = peg$
|
|
2502
|
+
s1 = peg$c76();
|
|
2405
2503
|
}
|
|
2406
2504
|
s0 = s1;
|
|
2407
2505
|
}
|
|
@@ -2416,24 +2514,24 @@ function peg$parse(input, options) {
|
|
|
2416
2514
|
s1 = peg$parse_();
|
|
2417
2515
|
if (s1 !== peg$FAILED) {
|
|
2418
2516
|
if (input.charCodeAt(peg$currPos) === 58) {
|
|
2419
|
-
s2 = peg$
|
|
2517
|
+
s2 = peg$c56;
|
|
2420
2518
|
peg$currPos++;
|
|
2421
2519
|
}
|
|
2422
2520
|
else {
|
|
2423
2521
|
s2 = peg$FAILED;
|
|
2424
2522
|
if (peg$silentFails === 0) {
|
|
2425
|
-
peg$fail(peg$
|
|
2523
|
+
peg$fail(peg$c57);
|
|
2426
2524
|
}
|
|
2427
2525
|
}
|
|
2428
2526
|
if (s2 !== peg$FAILED) {
|
|
2429
|
-
if (peg$
|
|
2527
|
+
if (peg$c58.test(input.charAt(peg$currPos))) {
|
|
2430
2528
|
s3 = input.charAt(peg$currPos);
|
|
2431
2529
|
peg$currPos++;
|
|
2432
2530
|
}
|
|
2433
2531
|
else {
|
|
2434
2532
|
s3 = peg$FAILED;
|
|
2435
2533
|
if (peg$silentFails === 0) {
|
|
2436
|
-
peg$fail(peg$
|
|
2534
|
+
peg$fail(peg$c59);
|
|
2437
2535
|
}
|
|
2438
2536
|
}
|
|
2439
2537
|
if (s3 === peg$FAILED) {
|
|
@@ -2444,13 +2542,13 @@ function peg$parse(input, options) {
|
|
|
2444
2542
|
if (s4 !== peg$FAILED) {
|
|
2445
2543
|
s5 = peg$currPos;
|
|
2446
2544
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
2447
|
-
s6 = peg$
|
|
2545
|
+
s6 = peg$c77;
|
|
2448
2546
|
peg$currPos++;
|
|
2449
2547
|
}
|
|
2450
2548
|
else {
|
|
2451
2549
|
s6 = peg$FAILED;
|
|
2452
2550
|
if (peg$silentFails === 0) {
|
|
2453
|
-
peg$fail(peg$
|
|
2551
|
+
peg$fail(peg$c78);
|
|
2454
2552
|
}
|
|
2455
2553
|
}
|
|
2456
2554
|
if (s6 !== peg$FAILED) {
|
|
@@ -2461,18 +2559,18 @@ function peg$parse(input, options) {
|
|
|
2461
2559
|
s9 = peg$parsegap();
|
|
2462
2560
|
if (s9 !== peg$FAILED) {
|
|
2463
2561
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2464
|
-
s10 = peg$
|
|
2562
|
+
s10 = peg$c79;
|
|
2465
2563
|
peg$currPos++;
|
|
2466
2564
|
}
|
|
2467
2565
|
else {
|
|
2468
2566
|
s10 = peg$FAILED;
|
|
2469
2567
|
if (peg$silentFails === 0) {
|
|
2470
|
-
peg$fail(peg$
|
|
2568
|
+
peg$fail(peg$c80);
|
|
2471
2569
|
}
|
|
2472
2570
|
}
|
|
2473
2571
|
if (s10 !== peg$FAILED) {
|
|
2474
2572
|
peg$savedPos = s5;
|
|
2475
|
-
s6 = peg$
|
|
2573
|
+
s6 = peg$c81(s3, s4, s8);
|
|
2476
2574
|
s5 = s6;
|
|
2477
2575
|
}
|
|
2478
2576
|
else {
|
|
@@ -2502,31 +2600,31 @@ function peg$parse(input, options) {
|
|
|
2502
2600
|
if (s5 === peg$FAILED) {
|
|
2503
2601
|
s5 = peg$currPos;
|
|
2504
2602
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
2505
|
-
s6 = peg$
|
|
2603
|
+
s6 = peg$c77;
|
|
2506
2604
|
peg$currPos++;
|
|
2507
2605
|
}
|
|
2508
2606
|
else {
|
|
2509
2607
|
s6 = peg$FAILED;
|
|
2510
2608
|
if (peg$silentFails === 0) {
|
|
2511
|
-
peg$fail(peg$
|
|
2609
|
+
peg$fail(peg$c78);
|
|
2512
2610
|
}
|
|
2513
2611
|
}
|
|
2514
2612
|
if (s6 !== peg$FAILED) {
|
|
2515
2613
|
s7 = peg$parsegap();
|
|
2516
2614
|
if (s7 !== peg$FAILED) {
|
|
2517
2615
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2518
|
-
s8 = peg$
|
|
2616
|
+
s8 = peg$c79;
|
|
2519
2617
|
peg$currPos++;
|
|
2520
2618
|
}
|
|
2521
2619
|
else {
|
|
2522
2620
|
s8 = peg$FAILED;
|
|
2523
2621
|
if (peg$silentFails === 0) {
|
|
2524
|
-
peg$fail(peg$
|
|
2622
|
+
peg$fail(peg$c80);
|
|
2525
2623
|
}
|
|
2526
2624
|
}
|
|
2527
2625
|
if (s8 !== peg$FAILED) {
|
|
2528
2626
|
peg$savedPos = s5;
|
|
2529
|
-
s6 = peg$
|
|
2627
|
+
s6 = peg$c82(s3, s4);
|
|
2530
2628
|
s5 = s6;
|
|
2531
2629
|
}
|
|
2532
2630
|
else {
|
|
@@ -2546,13 +2644,13 @@ function peg$parse(input, options) {
|
|
|
2546
2644
|
if (s5 === peg$FAILED) {
|
|
2547
2645
|
s5 = peg$currPos;
|
|
2548
2646
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
2549
|
-
s6 = peg$
|
|
2647
|
+
s6 = peg$c77;
|
|
2550
2648
|
peg$currPos++;
|
|
2551
2649
|
}
|
|
2552
2650
|
else {
|
|
2553
2651
|
s6 = peg$FAILED;
|
|
2554
2652
|
if (peg$silentFails === 0) {
|
|
2555
|
-
peg$fail(peg$
|
|
2653
|
+
peg$fail(peg$c78);
|
|
2556
2654
|
}
|
|
2557
2655
|
}
|
|
2558
2656
|
if (s6 !== peg$FAILED) {
|
|
@@ -2562,13 +2660,13 @@ function peg$parse(input, options) {
|
|
|
2562
2660
|
s10 = peg$currPos;
|
|
2563
2661
|
peg$silentFails++;
|
|
2564
2662
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2565
|
-
s11 = peg$
|
|
2663
|
+
s11 = peg$c79;
|
|
2566
2664
|
peg$currPos++;
|
|
2567
2665
|
}
|
|
2568
2666
|
else {
|
|
2569
2667
|
s11 = peg$FAILED;
|
|
2570
2668
|
if (peg$silentFails === 0) {
|
|
2571
|
-
peg$fail(peg$
|
|
2669
|
+
peg$fail(peg$c80);
|
|
2572
2670
|
}
|
|
2573
2671
|
}
|
|
2574
2672
|
if (s11 === peg$FAILED) {
|
|
@@ -2612,13 +2710,13 @@ function peg$parse(input, options) {
|
|
|
2612
2710
|
s10 = peg$currPos;
|
|
2613
2711
|
peg$silentFails++;
|
|
2614
2712
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2615
|
-
s11 = peg$
|
|
2713
|
+
s11 = peg$c79;
|
|
2616
2714
|
peg$currPos++;
|
|
2617
2715
|
}
|
|
2618
2716
|
else {
|
|
2619
2717
|
s11 = peg$FAILED;
|
|
2620
2718
|
if (peg$silentFails === 0) {
|
|
2621
|
-
peg$fail(peg$
|
|
2719
|
+
peg$fail(peg$c80);
|
|
2622
2720
|
}
|
|
2623
2721
|
}
|
|
2624
2722
|
if (s11 === peg$FAILED) {
|
|
@@ -2665,18 +2763,18 @@ function peg$parse(input, options) {
|
|
|
2665
2763
|
}
|
|
2666
2764
|
if (s7 !== peg$FAILED) {
|
|
2667
2765
|
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2668
|
-
s8 = peg$
|
|
2766
|
+
s8 = peg$c79;
|
|
2669
2767
|
peg$currPos++;
|
|
2670
2768
|
}
|
|
2671
2769
|
else {
|
|
2672
2770
|
s8 = peg$FAILED;
|
|
2673
2771
|
if (peg$silentFails === 0) {
|
|
2674
|
-
peg$fail(peg$
|
|
2772
|
+
peg$fail(peg$c80);
|
|
2675
2773
|
}
|
|
2676
2774
|
}
|
|
2677
2775
|
if (s8 !== peg$FAILED) {
|
|
2678
2776
|
peg$savedPos = s5;
|
|
2679
|
-
s6 = peg$
|
|
2777
|
+
s6 = peg$c83(s3, s4);
|
|
2680
2778
|
s5 = s6;
|
|
2681
2779
|
}
|
|
2682
2780
|
else {
|
|
@@ -2696,13 +2794,13 @@ function peg$parse(input, options) {
|
|
|
2696
2794
|
if (s5 === peg$FAILED) {
|
|
2697
2795
|
s5 = peg$currPos;
|
|
2698
2796
|
if (input.charCodeAt(peg$currPos) === 91) {
|
|
2699
|
-
s6 = peg$
|
|
2797
|
+
s6 = peg$c84;
|
|
2700
2798
|
peg$currPos++;
|
|
2701
2799
|
}
|
|
2702
2800
|
else {
|
|
2703
2801
|
s6 = peg$FAILED;
|
|
2704
2802
|
if (peg$silentFails === 0) {
|
|
2705
|
-
peg$fail(peg$
|
|
2803
|
+
peg$fail(peg$c85);
|
|
2706
2804
|
}
|
|
2707
2805
|
}
|
|
2708
2806
|
if (s6 !== peg$FAILED) {
|
|
@@ -2712,13 +2810,13 @@ function peg$parse(input, options) {
|
|
|
2712
2810
|
s10 = peg$currPos;
|
|
2713
2811
|
peg$silentFails++;
|
|
2714
2812
|
if (input.charCodeAt(peg$currPos) === 93) {
|
|
2715
|
-
s11 = peg$
|
|
2813
|
+
s11 = peg$c86;
|
|
2716
2814
|
peg$currPos++;
|
|
2717
2815
|
}
|
|
2718
2816
|
else {
|
|
2719
2817
|
s11 = peg$FAILED;
|
|
2720
2818
|
if (peg$silentFails === 0) {
|
|
2721
|
-
peg$fail(peg$
|
|
2819
|
+
peg$fail(peg$c87);
|
|
2722
2820
|
}
|
|
2723
2821
|
}
|
|
2724
2822
|
if (s11 === peg$FAILED) {
|
|
@@ -2762,13 +2860,13 @@ function peg$parse(input, options) {
|
|
|
2762
2860
|
s10 = peg$currPos;
|
|
2763
2861
|
peg$silentFails++;
|
|
2764
2862
|
if (input.charCodeAt(peg$currPos) === 93) {
|
|
2765
|
-
s11 = peg$
|
|
2863
|
+
s11 = peg$c86;
|
|
2766
2864
|
peg$currPos++;
|
|
2767
2865
|
}
|
|
2768
2866
|
else {
|
|
2769
2867
|
s11 = peg$FAILED;
|
|
2770
2868
|
if (peg$silentFails === 0) {
|
|
2771
|
-
peg$fail(peg$
|
|
2869
|
+
peg$fail(peg$c87);
|
|
2772
2870
|
}
|
|
2773
2871
|
}
|
|
2774
2872
|
if (s11 === peg$FAILED) {
|
|
@@ -2815,18 +2913,18 @@ function peg$parse(input, options) {
|
|
|
2815
2913
|
}
|
|
2816
2914
|
if (s7 !== peg$FAILED) {
|
|
2817
2915
|
if (input.charCodeAt(peg$currPos) === 93) {
|
|
2818
|
-
s8 = peg$
|
|
2916
|
+
s8 = peg$c86;
|
|
2819
2917
|
peg$currPos++;
|
|
2820
2918
|
}
|
|
2821
2919
|
else {
|
|
2822
2920
|
s8 = peg$FAILED;
|
|
2823
2921
|
if (peg$silentFails === 0) {
|
|
2824
|
-
peg$fail(peg$
|
|
2922
|
+
peg$fail(peg$c87);
|
|
2825
2923
|
}
|
|
2826
2924
|
}
|
|
2827
2925
|
if (s8 !== peg$FAILED) {
|
|
2828
2926
|
peg$savedPos = s5;
|
|
2829
|
-
s6 = peg$
|
|
2927
|
+
s6 = peg$c88(s3, s4);
|
|
2830
2928
|
s5 = s6;
|
|
2831
2929
|
}
|
|
2832
2930
|
else {
|
|
@@ -2846,13 +2944,13 @@ function peg$parse(input, options) {
|
|
|
2846
2944
|
if (s5 === peg$FAILED) {
|
|
2847
2945
|
s5 = peg$currPos;
|
|
2848
2946
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
2849
|
-
s6 = peg$
|
|
2947
|
+
s6 = peg$c62;
|
|
2850
2948
|
peg$currPos++;
|
|
2851
2949
|
}
|
|
2852
2950
|
else {
|
|
2853
2951
|
s6 = peg$FAILED;
|
|
2854
2952
|
if (peg$silentFails === 0) {
|
|
2855
|
-
peg$fail(peg$
|
|
2953
|
+
peg$fail(peg$c63);
|
|
2856
2954
|
}
|
|
2857
2955
|
}
|
|
2858
2956
|
if (s6 !== peg$FAILED) {
|
|
@@ -2863,18 +2961,18 @@ function peg$parse(input, options) {
|
|
|
2863
2961
|
s9 = peg$parse_();
|
|
2864
2962
|
if (s9 !== peg$FAILED) {
|
|
2865
2963
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
2866
|
-
s10 = peg$
|
|
2964
|
+
s10 = peg$c64;
|
|
2867
2965
|
peg$currPos++;
|
|
2868
2966
|
}
|
|
2869
2967
|
else {
|
|
2870
2968
|
s10 = peg$FAILED;
|
|
2871
2969
|
if (peg$silentFails === 0) {
|
|
2872
|
-
peg$fail(peg$
|
|
2970
|
+
peg$fail(peg$c65);
|
|
2873
2971
|
}
|
|
2874
2972
|
}
|
|
2875
2973
|
if (s10 !== peg$FAILED) {
|
|
2876
2974
|
peg$savedPos = s5;
|
|
2877
|
-
s6 = peg$
|
|
2975
|
+
s6 = peg$c89(s3, s4, s8);
|
|
2878
2976
|
s5 = s6;
|
|
2879
2977
|
}
|
|
2880
2978
|
else {
|
|
@@ -2904,51 +3002,51 @@ function peg$parse(input, options) {
|
|
|
2904
3002
|
if (s5 === peg$FAILED) {
|
|
2905
3003
|
s5 = peg$currPos;
|
|
2906
3004
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
2907
|
-
s6 = peg$
|
|
3005
|
+
s6 = peg$c62;
|
|
2908
3006
|
peg$currPos++;
|
|
2909
3007
|
}
|
|
2910
3008
|
else {
|
|
2911
3009
|
s6 = peg$FAILED;
|
|
2912
3010
|
if (peg$silentFails === 0) {
|
|
2913
|
-
peg$fail(peg$
|
|
3011
|
+
peg$fail(peg$c63);
|
|
2914
3012
|
}
|
|
2915
3013
|
}
|
|
2916
3014
|
if (s6 !== peg$FAILED) {
|
|
2917
3015
|
s7 = peg$parse_();
|
|
2918
3016
|
if (s7 !== peg$FAILED) {
|
|
2919
|
-
if (peg$
|
|
3017
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
2920
3018
|
s8 = input.charAt(peg$currPos);
|
|
2921
3019
|
peg$currPos++;
|
|
2922
3020
|
}
|
|
2923
3021
|
else {
|
|
2924
3022
|
s8 = peg$FAILED;
|
|
2925
3023
|
if (peg$silentFails === 0) {
|
|
2926
|
-
peg$fail(peg$
|
|
3024
|
+
peg$fail(peg$c91);
|
|
2927
3025
|
}
|
|
2928
3026
|
}
|
|
2929
3027
|
if (s8 !== peg$FAILED) {
|
|
2930
3028
|
s9 = peg$currPos;
|
|
2931
3029
|
s10 = [];
|
|
2932
|
-
if (peg$
|
|
3030
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
2933
3031
|
s11 = input.charAt(peg$currPos);
|
|
2934
3032
|
peg$currPos++;
|
|
2935
3033
|
}
|
|
2936
3034
|
else {
|
|
2937
3035
|
s11 = peg$FAILED;
|
|
2938
3036
|
if (peg$silentFails === 0) {
|
|
2939
|
-
peg$fail(peg$
|
|
3037
|
+
peg$fail(peg$c93);
|
|
2940
3038
|
}
|
|
2941
3039
|
}
|
|
2942
3040
|
while (s11 !== peg$FAILED) {
|
|
2943
3041
|
s10.push(s11);
|
|
2944
|
-
if (peg$
|
|
3042
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
2945
3043
|
s11 = input.charAt(peg$currPos);
|
|
2946
3044
|
peg$currPos++;
|
|
2947
3045
|
}
|
|
2948
3046
|
else {
|
|
2949
3047
|
s11 = peg$FAILED;
|
|
2950
3048
|
if (peg$silentFails === 0) {
|
|
2951
|
-
peg$fail(peg$
|
|
3049
|
+
peg$fail(peg$c93);
|
|
2952
3050
|
}
|
|
2953
3051
|
}
|
|
2954
3052
|
}
|
|
@@ -2959,32 +3057,32 @@ function peg$parse(input, options) {
|
|
|
2959
3057
|
s9 = s10;
|
|
2960
3058
|
}
|
|
2961
3059
|
if (s9 !== peg$FAILED) {
|
|
2962
|
-
if (peg$
|
|
3060
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
2963
3061
|
s10 = input.charAt(peg$currPos);
|
|
2964
3062
|
peg$currPos++;
|
|
2965
3063
|
}
|
|
2966
3064
|
else {
|
|
2967
3065
|
s10 = peg$FAILED;
|
|
2968
3066
|
if (peg$silentFails === 0) {
|
|
2969
|
-
peg$fail(peg$
|
|
3067
|
+
peg$fail(peg$c91);
|
|
2970
3068
|
}
|
|
2971
3069
|
}
|
|
2972
3070
|
if (s10 !== peg$FAILED) {
|
|
2973
3071
|
s11 = peg$parse_();
|
|
2974
3072
|
if (s11 !== peg$FAILED) {
|
|
2975
3073
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
2976
|
-
s12 = peg$
|
|
3074
|
+
s12 = peg$c64;
|
|
2977
3075
|
peg$currPos++;
|
|
2978
3076
|
}
|
|
2979
3077
|
else {
|
|
2980
3078
|
s12 = peg$FAILED;
|
|
2981
3079
|
if (peg$silentFails === 0) {
|
|
2982
|
-
peg$fail(peg$
|
|
3080
|
+
peg$fail(peg$c65);
|
|
2983
3081
|
}
|
|
2984
3082
|
}
|
|
2985
3083
|
if (s12 !== peg$FAILED) {
|
|
2986
3084
|
peg$savedPos = s5;
|
|
2987
|
-
s6 = peg$
|
|
3085
|
+
s6 = peg$c94(s3, s4, s9);
|
|
2988
3086
|
s5 = s6;
|
|
2989
3087
|
}
|
|
2990
3088
|
else {
|
|
@@ -3024,51 +3122,51 @@ function peg$parse(input, options) {
|
|
|
3024
3122
|
if (s5 === peg$FAILED) {
|
|
3025
3123
|
s5 = peg$currPos;
|
|
3026
3124
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
3027
|
-
s6 = peg$
|
|
3125
|
+
s6 = peg$c62;
|
|
3028
3126
|
peg$currPos++;
|
|
3029
3127
|
}
|
|
3030
3128
|
else {
|
|
3031
3129
|
s6 = peg$FAILED;
|
|
3032
3130
|
if (peg$silentFails === 0) {
|
|
3033
|
-
peg$fail(peg$
|
|
3131
|
+
peg$fail(peg$c63);
|
|
3034
3132
|
}
|
|
3035
3133
|
}
|
|
3036
3134
|
if (s6 !== peg$FAILED) {
|
|
3037
3135
|
s7 = peg$parse_();
|
|
3038
3136
|
if (s7 !== peg$FAILED) {
|
|
3039
|
-
if (peg$
|
|
3137
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
3040
3138
|
s8 = input.charAt(peg$currPos);
|
|
3041
3139
|
peg$currPos++;
|
|
3042
3140
|
}
|
|
3043
3141
|
else {
|
|
3044
3142
|
s8 = peg$FAILED;
|
|
3045
3143
|
if (peg$silentFails === 0) {
|
|
3046
|
-
peg$fail(peg$
|
|
3144
|
+
peg$fail(peg$c96);
|
|
3047
3145
|
}
|
|
3048
3146
|
}
|
|
3049
3147
|
if (s8 !== peg$FAILED) {
|
|
3050
3148
|
s9 = peg$currPos;
|
|
3051
3149
|
s10 = [];
|
|
3052
|
-
if (peg$
|
|
3150
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
3053
3151
|
s11 = input.charAt(peg$currPos);
|
|
3054
3152
|
peg$currPos++;
|
|
3055
3153
|
}
|
|
3056
3154
|
else {
|
|
3057
3155
|
s11 = peg$FAILED;
|
|
3058
3156
|
if (peg$silentFails === 0) {
|
|
3059
|
-
peg$fail(peg$
|
|
3157
|
+
peg$fail(peg$c98);
|
|
3060
3158
|
}
|
|
3061
3159
|
}
|
|
3062
3160
|
while (s11 !== peg$FAILED) {
|
|
3063
3161
|
s10.push(s11);
|
|
3064
|
-
if (peg$
|
|
3162
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
3065
3163
|
s11 = input.charAt(peg$currPos);
|
|
3066
3164
|
peg$currPos++;
|
|
3067
3165
|
}
|
|
3068
3166
|
else {
|
|
3069
3167
|
s11 = peg$FAILED;
|
|
3070
3168
|
if (peg$silentFails === 0) {
|
|
3071
|
-
peg$fail(peg$
|
|
3169
|
+
peg$fail(peg$c98);
|
|
3072
3170
|
}
|
|
3073
3171
|
}
|
|
3074
3172
|
}
|
|
@@ -3079,32 +3177,32 @@ function peg$parse(input, options) {
|
|
|
3079
3177
|
s9 = s10;
|
|
3080
3178
|
}
|
|
3081
3179
|
if (s9 !== peg$FAILED) {
|
|
3082
|
-
if (peg$
|
|
3180
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
3083
3181
|
s10 = input.charAt(peg$currPos);
|
|
3084
3182
|
peg$currPos++;
|
|
3085
3183
|
}
|
|
3086
3184
|
else {
|
|
3087
3185
|
s10 = peg$FAILED;
|
|
3088
3186
|
if (peg$silentFails === 0) {
|
|
3089
|
-
peg$fail(peg$
|
|
3187
|
+
peg$fail(peg$c96);
|
|
3090
3188
|
}
|
|
3091
3189
|
}
|
|
3092
3190
|
if (s10 !== peg$FAILED) {
|
|
3093
3191
|
s11 = peg$parse_();
|
|
3094
3192
|
if (s11 !== peg$FAILED) {
|
|
3095
3193
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
3096
|
-
s12 = peg$
|
|
3194
|
+
s12 = peg$c64;
|
|
3097
3195
|
peg$currPos++;
|
|
3098
3196
|
}
|
|
3099
3197
|
else {
|
|
3100
3198
|
s12 = peg$FAILED;
|
|
3101
3199
|
if (peg$silentFails === 0) {
|
|
3102
|
-
peg$fail(peg$
|
|
3200
|
+
peg$fail(peg$c65);
|
|
3103
3201
|
}
|
|
3104
3202
|
}
|
|
3105
3203
|
if (s12 !== peg$FAILED) {
|
|
3106
3204
|
peg$savedPos = s5;
|
|
3107
|
-
s6 = peg$
|
|
3205
|
+
s6 = peg$c94(s3, s4, s9);
|
|
3108
3206
|
s5 = s6;
|
|
3109
3207
|
}
|
|
3110
3208
|
else {
|
|
@@ -3144,13 +3242,13 @@ function peg$parse(input, options) {
|
|
|
3144
3242
|
if (s5 === peg$FAILED) {
|
|
3145
3243
|
s5 = peg$currPos;
|
|
3146
3244
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
3147
|
-
s6 = peg$
|
|
3245
|
+
s6 = peg$c62;
|
|
3148
3246
|
peg$currPos++;
|
|
3149
3247
|
}
|
|
3150
3248
|
else {
|
|
3151
3249
|
s6 = peg$FAILED;
|
|
3152
3250
|
if (peg$silentFails === 0) {
|
|
3153
|
-
peg$fail(peg$
|
|
3251
|
+
peg$fail(peg$c63);
|
|
3154
3252
|
}
|
|
3155
3253
|
}
|
|
3156
3254
|
if (s6 !== peg$FAILED) {
|
|
@@ -3162,24 +3260,24 @@ function peg$parse(input, options) {
|
|
|
3162
3260
|
s11 = peg$currPos;
|
|
3163
3261
|
peg$silentFails++;
|
|
3164
3262
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
3165
|
-
s12 = peg$
|
|
3263
|
+
s12 = peg$c62;
|
|
3166
3264
|
peg$currPos++;
|
|
3167
3265
|
}
|
|
3168
3266
|
else {
|
|
3169
3267
|
s12 = peg$FAILED;
|
|
3170
3268
|
if (peg$silentFails === 0) {
|
|
3171
|
-
peg$fail(peg$
|
|
3269
|
+
peg$fail(peg$c63);
|
|
3172
3270
|
}
|
|
3173
3271
|
}
|
|
3174
3272
|
if (s12 === peg$FAILED) {
|
|
3175
3273
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
3176
|
-
s12 = peg$
|
|
3274
|
+
s12 = peg$c64;
|
|
3177
3275
|
peg$currPos++;
|
|
3178
3276
|
}
|
|
3179
3277
|
else {
|
|
3180
3278
|
s12 = peg$FAILED;
|
|
3181
3279
|
if (peg$silentFails === 0) {
|
|
3182
|
-
peg$fail(peg$
|
|
3280
|
+
peg$fail(peg$c65);
|
|
3183
3281
|
}
|
|
3184
3282
|
}
|
|
3185
3283
|
if (s12 === peg$FAILED) {
|
|
@@ -3225,24 +3323,24 @@ function peg$parse(input, options) {
|
|
|
3225
3323
|
s11 = peg$currPos;
|
|
3226
3324
|
peg$silentFails++;
|
|
3227
3325
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
3228
|
-
s12 = peg$
|
|
3326
|
+
s12 = peg$c62;
|
|
3229
3327
|
peg$currPos++;
|
|
3230
3328
|
}
|
|
3231
3329
|
else {
|
|
3232
3330
|
s12 = peg$FAILED;
|
|
3233
3331
|
if (peg$silentFails === 0) {
|
|
3234
|
-
peg$fail(peg$
|
|
3332
|
+
peg$fail(peg$c63);
|
|
3235
3333
|
}
|
|
3236
3334
|
}
|
|
3237
3335
|
if (s12 === peg$FAILED) {
|
|
3238
3336
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
3239
|
-
s12 = peg$
|
|
3337
|
+
s12 = peg$c64;
|
|
3240
3338
|
peg$currPos++;
|
|
3241
3339
|
}
|
|
3242
3340
|
else {
|
|
3243
3341
|
s12 = peg$FAILED;
|
|
3244
3342
|
if (peg$silentFails === 0) {
|
|
3245
|
-
peg$fail(peg$
|
|
3343
|
+
peg$fail(peg$c65);
|
|
3246
3344
|
}
|
|
3247
3345
|
}
|
|
3248
3346
|
if (s12 === peg$FAILED) {
|
|
@@ -3294,18 +3392,18 @@ function peg$parse(input, options) {
|
|
|
3294
3392
|
}
|
|
3295
3393
|
if (s8 !== peg$FAILED) {
|
|
3296
3394
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
3297
|
-
s9 = peg$
|
|
3395
|
+
s9 = peg$c64;
|
|
3298
3396
|
peg$currPos++;
|
|
3299
3397
|
}
|
|
3300
3398
|
else {
|
|
3301
3399
|
s9 = peg$FAILED;
|
|
3302
3400
|
if (peg$silentFails === 0) {
|
|
3303
|
-
peg$fail(peg$
|
|
3401
|
+
peg$fail(peg$c65);
|
|
3304
3402
|
}
|
|
3305
3403
|
}
|
|
3306
3404
|
if (s9 !== peg$FAILED) {
|
|
3307
3405
|
peg$savedPos = s5;
|
|
3308
|
-
s6 = peg$
|
|
3406
|
+
s6 = peg$c99(s3, s4, s8);
|
|
3309
3407
|
s5 = s6;
|
|
3310
3408
|
}
|
|
3311
3409
|
else {
|
|
@@ -3330,31 +3428,31 @@ function peg$parse(input, options) {
|
|
|
3330
3428
|
if (s5 === peg$FAILED) {
|
|
3331
3429
|
s5 = peg$currPos;
|
|
3332
3430
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
3333
|
-
s6 = peg$
|
|
3431
|
+
s6 = peg$c62;
|
|
3334
3432
|
peg$currPos++;
|
|
3335
3433
|
}
|
|
3336
3434
|
else {
|
|
3337
3435
|
s6 = peg$FAILED;
|
|
3338
3436
|
if (peg$silentFails === 0) {
|
|
3339
|
-
peg$fail(peg$
|
|
3437
|
+
peg$fail(peg$c63);
|
|
3340
3438
|
}
|
|
3341
3439
|
}
|
|
3342
3440
|
if (s6 !== peg$FAILED) {
|
|
3343
3441
|
s7 = peg$parse_();
|
|
3344
3442
|
if (s7 !== peg$FAILED) {
|
|
3345
3443
|
if (input.charCodeAt(peg$currPos) === 62) {
|
|
3346
|
-
s8 = peg$
|
|
3444
|
+
s8 = peg$c64;
|
|
3347
3445
|
peg$currPos++;
|
|
3348
3446
|
}
|
|
3349
3447
|
else {
|
|
3350
3448
|
s8 = peg$FAILED;
|
|
3351
3449
|
if (peg$silentFails === 0) {
|
|
3352
|
-
peg$fail(peg$
|
|
3450
|
+
peg$fail(peg$c65);
|
|
3353
3451
|
}
|
|
3354
3452
|
}
|
|
3355
3453
|
if (s8 !== peg$FAILED) {
|
|
3356
3454
|
peg$savedPos = s5;
|
|
3357
|
-
s6 = peg$
|
|
3455
|
+
s6 = peg$c100(s3, s4);
|
|
3358
3456
|
s5 = s6;
|
|
3359
3457
|
}
|
|
3360
3458
|
else {
|
|
@@ -3374,13 +3472,13 @@ function peg$parse(input, options) {
|
|
|
3374
3472
|
if (s5 === peg$FAILED) {
|
|
3375
3473
|
s5 = peg$currPos;
|
|
3376
3474
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3377
|
-
s6 = peg$
|
|
3475
|
+
s6 = peg$c101;
|
|
3378
3476
|
peg$currPos++;
|
|
3379
3477
|
}
|
|
3380
3478
|
else {
|
|
3381
3479
|
s6 = peg$FAILED;
|
|
3382
3480
|
if (peg$silentFails === 0) {
|
|
3383
|
-
peg$fail(peg$
|
|
3481
|
+
peg$fail(peg$c102);
|
|
3384
3482
|
}
|
|
3385
3483
|
}
|
|
3386
3484
|
if (s6 !== peg$FAILED) {
|
|
@@ -3390,25 +3488,25 @@ function peg$parse(input, options) {
|
|
|
3390
3488
|
s9 = peg$parsearray_items();
|
|
3391
3489
|
if (s9 !== peg$FAILED) {
|
|
3392
3490
|
peg$savedPos = s8;
|
|
3393
|
-
s9 = peg$
|
|
3491
|
+
s9 = peg$c103(s3, s4, s9);
|
|
3394
3492
|
}
|
|
3395
3493
|
s8 = s9;
|
|
3396
3494
|
if (s8 !== peg$FAILED) {
|
|
3397
3495
|
s9 = peg$parsegap();
|
|
3398
3496
|
if (s9 !== peg$FAILED) {
|
|
3399
3497
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3400
|
-
s10 = peg$
|
|
3498
|
+
s10 = peg$c104;
|
|
3401
3499
|
peg$currPos++;
|
|
3402
3500
|
}
|
|
3403
3501
|
else {
|
|
3404
3502
|
s10 = peg$FAILED;
|
|
3405
3503
|
if (peg$silentFails === 0) {
|
|
3406
|
-
peg$fail(peg$
|
|
3504
|
+
peg$fail(peg$c105);
|
|
3407
3505
|
}
|
|
3408
3506
|
}
|
|
3409
3507
|
if (s10 !== peg$FAILED) {
|
|
3410
3508
|
peg$savedPos = s5;
|
|
3411
|
-
s6 = peg$
|
|
3509
|
+
s6 = peg$c106(s3, s4, s8);
|
|
3412
3510
|
s5 = s6;
|
|
3413
3511
|
}
|
|
3414
3512
|
else {
|
|
@@ -3438,31 +3536,31 @@ function peg$parse(input, options) {
|
|
|
3438
3536
|
if (s5 === peg$FAILED) {
|
|
3439
3537
|
s5 = peg$currPos;
|
|
3440
3538
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3441
|
-
s6 = peg$
|
|
3539
|
+
s6 = peg$c101;
|
|
3442
3540
|
peg$currPos++;
|
|
3443
3541
|
}
|
|
3444
3542
|
else {
|
|
3445
3543
|
s6 = peg$FAILED;
|
|
3446
3544
|
if (peg$silentFails === 0) {
|
|
3447
|
-
peg$fail(peg$
|
|
3545
|
+
peg$fail(peg$c102);
|
|
3448
3546
|
}
|
|
3449
3547
|
}
|
|
3450
3548
|
if (s6 !== peg$FAILED) {
|
|
3451
3549
|
s7 = peg$parsegap();
|
|
3452
3550
|
if (s7 !== peg$FAILED) {
|
|
3453
3551
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3454
|
-
s8 = peg$
|
|
3552
|
+
s8 = peg$c104;
|
|
3455
3553
|
peg$currPos++;
|
|
3456
3554
|
}
|
|
3457
3555
|
else {
|
|
3458
3556
|
s8 = peg$FAILED;
|
|
3459
3557
|
if (peg$silentFails === 0) {
|
|
3460
|
-
peg$fail(peg$
|
|
3558
|
+
peg$fail(peg$c105);
|
|
3461
3559
|
}
|
|
3462
3560
|
}
|
|
3463
3561
|
if (s8 !== peg$FAILED) {
|
|
3464
3562
|
peg$savedPos = s5;
|
|
3465
|
-
s6 = peg$
|
|
3563
|
+
s6 = peg$c100(s3, s4);
|
|
3466
3564
|
s5 = s6;
|
|
3467
3565
|
}
|
|
3468
3566
|
else {
|
|
@@ -3482,13 +3580,13 @@ function peg$parse(input, options) {
|
|
|
3482
3580
|
if (s5 === peg$FAILED) {
|
|
3483
3581
|
s5 = peg$currPos;
|
|
3484
3582
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3485
|
-
s6 = peg$
|
|
3583
|
+
s6 = peg$c101;
|
|
3486
3584
|
peg$currPos++;
|
|
3487
3585
|
}
|
|
3488
3586
|
else {
|
|
3489
3587
|
s6 = peg$FAILED;
|
|
3490
3588
|
if (peg$silentFails === 0) {
|
|
3491
|
-
peg$fail(peg$
|
|
3589
|
+
peg$fail(peg$c102);
|
|
3492
3590
|
}
|
|
3493
3591
|
}
|
|
3494
3592
|
if (s6 !== peg$FAILED) {
|
|
@@ -3497,13 +3595,13 @@ function peg$parse(input, options) {
|
|
|
3497
3595
|
s8 = peg$currPos;
|
|
3498
3596
|
s9 = peg$currPos;
|
|
3499
3597
|
if (input.charCodeAt(peg$currPos) === 58) {
|
|
3500
|
-
s10 = peg$
|
|
3598
|
+
s10 = peg$c56;
|
|
3501
3599
|
peg$currPos++;
|
|
3502
3600
|
}
|
|
3503
3601
|
else {
|
|
3504
3602
|
s10 = peg$FAILED;
|
|
3505
3603
|
if (peg$silentFails === 0) {
|
|
3506
|
-
peg$fail(peg$
|
|
3604
|
+
peg$fail(peg$c57);
|
|
3507
3605
|
}
|
|
3508
3606
|
}
|
|
3509
3607
|
if (s10 !== peg$FAILED) {
|
|
@@ -3512,24 +3610,24 @@ function peg$parse(input, options) {
|
|
|
3512
3610
|
s13 = peg$currPos;
|
|
3513
3611
|
peg$silentFails++;
|
|
3514
3612
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3515
|
-
s14 = peg$
|
|
3613
|
+
s14 = peg$c104;
|
|
3516
3614
|
peg$currPos++;
|
|
3517
3615
|
}
|
|
3518
3616
|
else {
|
|
3519
3617
|
s14 = peg$FAILED;
|
|
3520
3618
|
if (peg$silentFails === 0) {
|
|
3521
|
-
peg$fail(peg$
|
|
3619
|
+
peg$fail(peg$c105);
|
|
3522
3620
|
}
|
|
3523
3621
|
}
|
|
3524
3622
|
if (s14 === peg$FAILED) {
|
|
3525
3623
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3526
|
-
s14 = peg$
|
|
3624
|
+
s14 = peg$c101;
|
|
3527
3625
|
peg$currPos++;
|
|
3528
3626
|
}
|
|
3529
3627
|
else {
|
|
3530
3628
|
s14 = peg$FAILED;
|
|
3531
3629
|
if (peg$silentFails === 0) {
|
|
3532
|
-
peg$fail(peg$
|
|
3630
|
+
peg$fail(peg$c102);
|
|
3533
3631
|
}
|
|
3534
3632
|
}
|
|
3535
3633
|
}
|
|
@@ -3571,24 +3669,24 @@ function peg$parse(input, options) {
|
|
|
3571
3669
|
s13 = peg$currPos;
|
|
3572
3670
|
peg$silentFails++;
|
|
3573
3671
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3574
|
-
s14 = peg$
|
|
3672
|
+
s14 = peg$c104;
|
|
3575
3673
|
peg$currPos++;
|
|
3576
3674
|
}
|
|
3577
3675
|
else {
|
|
3578
3676
|
s14 = peg$FAILED;
|
|
3579
3677
|
if (peg$silentFails === 0) {
|
|
3580
|
-
peg$fail(peg$
|
|
3678
|
+
peg$fail(peg$c105);
|
|
3581
3679
|
}
|
|
3582
3680
|
}
|
|
3583
3681
|
if (s14 === peg$FAILED) {
|
|
3584
3682
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3585
|
-
s14 = peg$
|
|
3683
|
+
s14 = peg$c101;
|
|
3586
3684
|
peg$currPos++;
|
|
3587
3685
|
}
|
|
3588
3686
|
else {
|
|
3589
3687
|
s14 = peg$FAILED;
|
|
3590
3688
|
if (peg$silentFails === 0) {
|
|
3591
|
-
peg$fail(peg$
|
|
3689
|
+
peg$fail(peg$c102);
|
|
3592
3690
|
}
|
|
3593
3691
|
}
|
|
3594
3692
|
}
|
|
@@ -3646,18 +3744,18 @@ function peg$parse(input, options) {
|
|
|
3646
3744
|
}
|
|
3647
3745
|
if (s8 !== peg$FAILED) {
|
|
3648
3746
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3649
|
-
s9 = peg$
|
|
3747
|
+
s9 = peg$c104;
|
|
3650
3748
|
peg$currPos++;
|
|
3651
3749
|
}
|
|
3652
3750
|
else {
|
|
3653
3751
|
s9 = peg$FAILED;
|
|
3654
3752
|
if (peg$silentFails === 0) {
|
|
3655
|
-
peg$fail(peg$
|
|
3753
|
+
peg$fail(peg$c105);
|
|
3656
3754
|
}
|
|
3657
3755
|
}
|
|
3658
3756
|
if (s9 !== peg$FAILED) {
|
|
3659
3757
|
peg$savedPos = s5;
|
|
3660
|
-
s6 = peg$
|
|
3758
|
+
s6 = peg$c94(s3, s4, s8);
|
|
3661
3759
|
s5 = s6;
|
|
3662
3760
|
}
|
|
3663
3761
|
else {
|
|
@@ -3682,13 +3780,13 @@ function peg$parse(input, options) {
|
|
|
3682
3780
|
if (s5 === peg$FAILED) {
|
|
3683
3781
|
s5 = peg$currPos;
|
|
3684
3782
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
3685
|
-
s6 = peg$
|
|
3783
|
+
s6 = peg$c101;
|
|
3686
3784
|
peg$currPos++;
|
|
3687
3785
|
}
|
|
3688
3786
|
else {
|
|
3689
3787
|
s6 = peg$FAILED;
|
|
3690
3788
|
if (peg$silentFails === 0) {
|
|
3691
|
-
peg$fail(peg$
|
|
3789
|
+
peg$fail(peg$c102);
|
|
3692
3790
|
}
|
|
3693
3791
|
}
|
|
3694
3792
|
if (s6 !== peg$FAILED) {
|
|
@@ -3698,13 +3796,13 @@ function peg$parse(input, options) {
|
|
|
3698
3796
|
s10 = peg$currPos;
|
|
3699
3797
|
peg$silentFails++;
|
|
3700
3798
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3701
|
-
s11 = peg$
|
|
3799
|
+
s11 = peg$c104;
|
|
3702
3800
|
peg$currPos++;
|
|
3703
3801
|
}
|
|
3704
3802
|
else {
|
|
3705
3803
|
s11 = peg$FAILED;
|
|
3706
3804
|
if (peg$silentFails === 0) {
|
|
3707
|
-
peg$fail(peg$
|
|
3805
|
+
peg$fail(peg$c105);
|
|
3708
3806
|
}
|
|
3709
3807
|
}
|
|
3710
3808
|
if (s11 === peg$FAILED) {
|
|
@@ -3748,13 +3846,13 @@ function peg$parse(input, options) {
|
|
|
3748
3846
|
s10 = peg$currPos;
|
|
3749
3847
|
peg$silentFails++;
|
|
3750
3848
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3751
|
-
s11 = peg$
|
|
3849
|
+
s11 = peg$c104;
|
|
3752
3850
|
peg$currPos++;
|
|
3753
3851
|
}
|
|
3754
3852
|
else {
|
|
3755
3853
|
s11 = peg$FAILED;
|
|
3756
3854
|
if (peg$silentFails === 0) {
|
|
3757
|
-
peg$fail(peg$
|
|
3855
|
+
peg$fail(peg$c105);
|
|
3758
3856
|
}
|
|
3759
3857
|
}
|
|
3760
3858
|
if (s11 === peg$FAILED) {
|
|
@@ -3801,18 +3899,18 @@ function peg$parse(input, options) {
|
|
|
3801
3899
|
}
|
|
3802
3900
|
if (s7 !== peg$FAILED) {
|
|
3803
3901
|
if (input.charCodeAt(peg$currPos) === 41) {
|
|
3804
|
-
s8 = peg$
|
|
3902
|
+
s8 = peg$c104;
|
|
3805
3903
|
peg$currPos++;
|
|
3806
3904
|
}
|
|
3807
3905
|
else {
|
|
3808
3906
|
s8 = peg$FAILED;
|
|
3809
3907
|
if (peg$silentFails === 0) {
|
|
3810
|
-
peg$fail(peg$
|
|
3908
|
+
peg$fail(peg$c105);
|
|
3811
3909
|
}
|
|
3812
3910
|
}
|
|
3813
3911
|
if (s8 !== peg$FAILED) {
|
|
3814
3912
|
peg$savedPos = s5;
|
|
3815
|
-
s6 = peg$
|
|
3913
|
+
s6 = peg$c107(s3, s4);
|
|
3816
3914
|
s5 = s6;
|
|
3817
3915
|
}
|
|
3818
3916
|
else {
|
|
@@ -3831,39 +3929,39 @@ function peg$parse(input, options) {
|
|
|
3831
3929
|
}
|
|
3832
3930
|
if (s5 === peg$FAILED) {
|
|
3833
3931
|
s5 = peg$currPos;
|
|
3834
|
-
if (peg$
|
|
3932
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
3835
3933
|
s6 = input.charAt(peg$currPos);
|
|
3836
3934
|
peg$currPos++;
|
|
3837
3935
|
}
|
|
3838
3936
|
else {
|
|
3839
3937
|
s6 = peg$FAILED;
|
|
3840
3938
|
if (peg$silentFails === 0) {
|
|
3841
|
-
peg$fail(peg$
|
|
3939
|
+
peg$fail(peg$c91);
|
|
3842
3940
|
}
|
|
3843
3941
|
}
|
|
3844
3942
|
if (s6 !== peg$FAILED) {
|
|
3845
3943
|
s7 = peg$currPos;
|
|
3846
3944
|
s8 = [];
|
|
3847
|
-
if (peg$
|
|
3945
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
3848
3946
|
s9 = input.charAt(peg$currPos);
|
|
3849
3947
|
peg$currPos++;
|
|
3850
3948
|
}
|
|
3851
3949
|
else {
|
|
3852
3950
|
s9 = peg$FAILED;
|
|
3853
3951
|
if (peg$silentFails === 0) {
|
|
3854
|
-
peg$fail(peg$
|
|
3952
|
+
peg$fail(peg$c93);
|
|
3855
3953
|
}
|
|
3856
3954
|
}
|
|
3857
3955
|
while (s9 !== peg$FAILED) {
|
|
3858
3956
|
s8.push(s9);
|
|
3859
|
-
if (peg$
|
|
3957
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
3860
3958
|
s9 = input.charAt(peg$currPos);
|
|
3861
3959
|
peg$currPos++;
|
|
3862
3960
|
}
|
|
3863
3961
|
else {
|
|
3864
3962
|
s9 = peg$FAILED;
|
|
3865
3963
|
if (peg$silentFails === 0) {
|
|
3866
|
-
peg$fail(peg$
|
|
3964
|
+
peg$fail(peg$c93);
|
|
3867
3965
|
}
|
|
3868
3966
|
}
|
|
3869
3967
|
}
|
|
@@ -3874,19 +3972,19 @@ function peg$parse(input, options) {
|
|
|
3874
3972
|
s7 = s8;
|
|
3875
3973
|
}
|
|
3876
3974
|
if (s7 !== peg$FAILED) {
|
|
3877
|
-
if (peg$
|
|
3975
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
3878
3976
|
s8 = input.charAt(peg$currPos);
|
|
3879
3977
|
peg$currPos++;
|
|
3880
3978
|
}
|
|
3881
3979
|
else {
|
|
3882
3980
|
s8 = peg$FAILED;
|
|
3883
3981
|
if (peg$silentFails === 0) {
|
|
3884
|
-
peg$fail(peg$
|
|
3982
|
+
peg$fail(peg$c91);
|
|
3885
3983
|
}
|
|
3886
3984
|
}
|
|
3887
3985
|
if (s8 !== peg$FAILED) {
|
|
3888
3986
|
peg$savedPos = s5;
|
|
3889
|
-
s6 = peg$
|
|
3987
|
+
s6 = peg$c94(s3, s4, s7);
|
|
3890
3988
|
s5 = s6;
|
|
3891
3989
|
}
|
|
3892
3990
|
else {
|
|
@@ -3905,39 +4003,39 @@ function peg$parse(input, options) {
|
|
|
3905
4003
|
}
|
|
3906
4004
|
if (s5 === peg$FAILED) {
|
|
3907
4005
|
s5 = peg$currPos;
|
|
3908
|
-
if (peg$
|
|
4006
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
3909
4007
|
s6 = input.charAt(peg$currPos);
|
|
3910
4008
|
peg$currPos++;
|
|
3911
4009
|
}
|
|
3912
4010
|
else {
|
|
3913
4011
|
s6 = peg$FAILED;
|
|
3914
4012
|
if (peg$silentFails === 0) {
|
|
3915
|
-
peg$fail(peg$
|
|
4013
|
+
peg$fail(peg$c96);
|
|
3916
4014
|
}
|
|
3917
4015
|
}
|
|
3918
4016
|
if (s6 !== peg$FAILED) {
|
|
3919
4017
|
s7 = peg$currPos;
|
|
3920
4018
|
s8 = [];
|
|
3921
|
-
if (peg$
|
|
4019
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
3922
4020
|
s9 = input.charAt(peg$currPos);
|
|
3923
4021
|
peg$currPos++;
|
|
3924
4022
|
}
|
|
3925
4023
|
else {
|
|
3926
4024
|
s9 = peg$FAILED;
|
|
3927
4025
|
if (peg$silentFails === 0) {
|
|
3928
|
-
peg$fail(peg$
|
|
4026
|
+
peg$fail(peg$c98);
|
|
3929
4027
|
}
|
|
3930
4028
|
}
|
|
3931
4029
|
while (s9 !== peg$FAILED) {
|
|
3932
4030
|
s8.push(s9);
|
|
3933
|
-
if (peg$
|
|
4031
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
3934
4032
|
s9 = input.charAt(peg$currPos);
|
|
3935
4033
|
peg$currPos++;
|
|
3936
4034
|
}
|
|
3937
4035
|
else {
|
|
3938
4036
|
s9 = peg$FAILED;
|
|
3939
4037
|
if (peg$silentFails === 0) {
|
|
3940
|
-
peg$fail(peg$
|
|
4038
|
+
peg$fail(peg$c98);
|
|
3941
4039
|
}
|
|
3942
4040
|
}
|
|
3943
4041
|
}
|
|
@@ -3948,19 +4046,19 @@ function peg$parse(input, options) {
|
|
|
3948
4046
|
s7 = s8;
|
|
3949
4047
|
}
|
|
3950
4048
|
if (s7 !== peg$FAILED) {
|
|
3951
|
-
if (peg$
|
|
4049
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
3952
4050
|
s8 = input.charAt(peg$currPos);
|
|
3953
4051
|
peg$currPos++;
|
|
3954
4052
|
}
|
|
3955
4053
|
else {
|
|
3956
4054
|
s8 = peg$FAILED;
|
|
3957
4055
|
if (peg$silentFails === 0) {
|
|
3958
|
-
peg$fail(peg$
|
|
4056
|
+
peg$fail(peg$c96);
|
|
3959
4057
|
}
|
|
3960
4058
|
}
|
|
3961
4059
|
if (s8 !== peg$FAILED) {
|
|
3962
4060
|
peg$savedPos = s5;
|
|
3963
|
-
s6 = peg$
|
|
4061
|
+
s6 = peg$c94(s3, s4, s7);
|
|
3964
4062
|
s5 = s6;
|
|
3965
4063
|
}
|
|
3966
4064
|
else {
|
|
@@ -3980,38 +4078,38 @@ function peg$parse(input, options) {
|
|
|
3980
4078
|
if (s5 === peg$FAILED) {
|
|
3981
4079
|
s5 = peg$currPos;
|
|
3982
4080
|
if (input.charCodeAt(peg$currPos) === 65378) {
|
|
3983
|
-
s6 = peg$
|
|
4081
|
+
s6 = peg$c108;
|
|
3984
4082
|
peg$currPos++;
|
|
3985
4083
|
}
|
|
3986
4084
|
else {
|
|
3987
4085
|
s6 = peg$FAILED;
|
|
3988
4086
|
if (peg$silentFails === 0) {
|
|
3989
|
-
peg$fail(peg$
|
|
4087
|
+
peg$fail(peg$c109);
|
|
3990
4088
|
}
|
|
3991
4089
|
}
|
|
3992
4090
|
if (s6 !== peg$FAILED) {
|
|
3993
4091
|
s7 = peg$currPos;
|
|
3994
4092
|
s8 = [];
|
|
3995
|
-
if (peg$
|
|
4093
|
+
if (peg$c110.test(input.charAt(peg$currPos))) {
|
|
3996
4094
|
s9 = input.charAt(peg$currPos);
|
|
3997
4095
|
peg$currPos++;
|
|
3998
4096
|
}
|
|
3999
4097
|
else {
|
|
4000
4098
|
s9 = peg$FAILED;
|
|
4001
4099
|
if (peg$silentFails === 0) {
|
|
4002
|
-
peg$fail(peg$
|
|
4100
|
+
peg$fail(peg$c111);
|
|
4003
4101
|
}
|
|
4004
4102
|
}
|
|
4005
4103
|
while (s9 !== peg$FAILED) {
|
|
4006
4104
|
s8.push(s9);
|
|
4007
|
-
if (peg$
|
|
4105
|
+
if (peg$c110.test(input.charAt(peg$currPos))) {
|
|
4008
4106
|
s9 = input.charAt(peg$currPos);
|
|
4009
4107
|
peg$currPos++;
|
|
4010
4108
|
}
|
|
4011
4109
|
else {
|
|
4012
4110
|
s9 = peg$FAILED;
|
|
4013
4111
|
if (peg$silentFails === 0) {
|
|
4014
|
-
peg$fail(peg$
|
|
4112
|
+
peg$fail(peg$c111);
|
|
4015
4113
|
}
|
|
4016
4114
|
}
|
|
4017
4115
|
}
|
|
@@ -4023,18 +4121,18 @@ function peg$parse(input, options) {
|
|
|
4023
4121
|
}
|
|
4024
4122
|
if (s7 !== peg$FAILED) {
|
|
4025
4123
|
if (input.charCodeAt(peg$currPos) === 65379) {
|
|
4026
|
-
s8 = peg$
|
|
4124
|
+
s8 = peg$c112;
|
|
4027
4125
|
peg$currPos++;
|
|
4028
4126
|
}
|
|
4029
4127
|
else {
|
|
4030
4128
|
s8 = peg$FAILED;
|
|
4031
4129
|
if (peg$silentFails === 0) {
|
|
4032
|
-
peg$fail(peg$
|
|
4130
|
+
peg$fail(peg$c113);
|
|
4033
4131
|
}
|
|
4034
4132
|
}
|
|
4035
4133
|
if (s8 !== peg$FAILED) {
|
|
4036
4134
|
peg$savedPos = s5;
|
|
4037
|
-
s6 = peg$
|
|
4135
|
+
s6 = peg$c94(s3, s4, s7);
|
|
4038
4136
|
s5 = s6;
|
|
4039
4137
|
}
|
|
4040
4138
|
else {
|
|
@@ -4054,79 +4152,79 @@ function peg$parse(input, options) {
|
|
|
4054
4152
|
if (s5 === peg$FAILED) {
|
|
4055
4153
|
s5 = peg$currPos;
|
|
4056
4154
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
4057
|
-
s6 = peg$
|
|
4155
|
+
s6 = peg$c62;
|
|
4058
4156
|
peg$currPos++;
|
|
4059
4157
|
}
|
|
4060
4158
|
else {
|
|
4061
4159
|
s6 = peg$FAILED;
|
|
4062
4160
|
if (peg$silentFails === 0) {
|
|
4063
|
-
peg$fail(peg$
|
|
4161
|
+
peg$fail(peg$c63);
|
|
4064
4162
|
}
|
|
4065
4163
|
}
|
|
4066
4164
|
if (s6 === peg$FAILED) {
|
|
4067
4165
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
4068
|
-
s6 = peg$
|
|
4166
|
+
s6 = peg$c101;
|
|
4069
4167
|
peg$currPos++;
|
|
4070
4168
|
}
|
|
4071
4169
|
else {
|
|
4072
4170
|
s6 = peg$FAILED;
|
|
4073
4171
|
if (peg$silentFails === 0) {
|
|
4074
|
-
peg$fail(peg$
|
|
4172
|
+
peg$fail(peg$c102);
|
|
4075
4173
|
}
|
|
4076
4174
|
}
|
|
4077
4175
|
if (s6 === peg$FAILED) {
|
|
4078
4176
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
4079
|
-
s6 = peg$
|
|
4177
|
+
s6 = peg$c77;
|
|
4080
4178
|
peg$currPos++;
|
|
4081
4179
|
}
|
|
4082
4180
|
else {
|
|
4083
4181
|
s6 = peg$FAILED;
|
|
4084
4182
|
if (peg$silentFails === 0) {
|
|
4085
|
-
peg$fail(peg$
|
|
4183
|
+
peg$fail(peg$c78);
|
|
4086
4184
|
}
|
|
4087
4185
|
}
|
|
4088
4186
|
if (s6 === peg$FAILED) {
|
|
4089
4187
|
if (input.charCodeAt(peg$currPos) === 91) {
|
|
4090
|
-
s6 = peg$
|
|
4188
|
+
s6 = peg$c84;
|
|
4091
4189
|
peg$currPos++;
|
|
4092
4190
|
}
|
|
4093
4191
|
else {
|
|
4094
4192
|
s6 = peg$FAILED;
|
|
4095
4193
|
if (peg$silentFails === 0) {
|
|
4096
|
-
peg$fail(peg$
|
|
4194
|
+
peg$fail(peg$c85);
|
|
4097
4195
|
}
|
|
4098
4196
|
}
|
|
4099
4197
|
if (s6 === peg$FAILED) {
|
|
4100
|
-
if (peg$
|
|
4198
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
4101
4199
|
s6 = input.charAt(peg$currPos);
|
|
4102
4200
|
peg$currPos++;
|
|
4103
4201
|
}
|
|
4104
4202
|
else {
|
|
4105
4203
|
s6 = peg$FAILED;
|
|
4106
4204
|
if (peg$silentFails === 0) {
|
|
4107
|
-
peg$fail(peg$
|
|
4205
|
+
peg$fail(peg$c91);
|
|
4108
4206
|
}
|
|
4109
4207
|
}
|
|
4110
4208
|
if (s6 === peg$FAILED) {
|
|
4111
|
-
if (peg$
|
|
4209
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
4112
4210
|
s6 = input.charAt(peg$currPos);
|
|
4113
4211
|
peg$currPos++;
|
|
4114
4212
|
}
|
|
4115
4213
|
else {
|
|
4116
4214
|
s6 = peg$FAILED;
|
|
4117
4215
|
if (peg$silentFails === 0) {
|
|
4118
|
-
peg$fail(peg$
|
|
4216
|
+
peg$fail(peg$c96);
|
|
4119
4217
|
}
|
|
4120
4218
|
}
|
|
4121
4219
|
if (s6 === peg$FAILED) {
|
|
4122
4220
|
if (input.charCodeAt(peg$currPos) === 65378) {
|
|
4123
|
-
s6 = peg$
|
|
4221
|
+
s6 = peg$c108;
|
|
4124
4222
|
peg$currPos++;
|
|
4125
4223
|
}
|
|
4126
4224
|
else {
|
|
4127
4225
|
s6 = peg$FAILED;
|
|
4128
4226
|
if (peg$silentFails === 0) {
|
|
4129
|
-
peg$fail(peg$
|
|
4227
|
+
peg$fail(peg$c109);
|
|
4130
4228
|
}
|
|
4131
4229
|
}
|
|
4132
4230
|
}
|
|
@@ -4221,7 +4319,7 @@ function peg$parse(input, options) {
|
|
|
4221
4319
|
}
|
|
4222
4320
|
if (s7 !== peg$FAILED) {
|
|
4223
4321
|
peg$savedPos = s5;
|
|
4224
|
-
s6 = peg$
|
|
4322
|
+
s6 = peg$c114(s3, s4);
|
|
4225
4323
|
s5 = s6;
|
|
4226
4324
|
}
|
|
4227
4325
|
else {
|
|
@@ -4238,7 +4336,7 @@ function peg$parse(input, options) {
|
|
|
4238
4336
|
s6 = peg$parse_();
|
|
4239
4337
|
if (s6 !== peg$FAILED) {
|
|
4240
4338
|
peg$savedPos = s5;
|
|
4241
|
-
s6 = peg$
|
|
4339
|
+
s6 = peg$c115(s3, s4);
|
|
4242
4340
|
}
|
|
4243
4341
|
s5 = s6;
|
|
4244
4342
|
}
|
|
@@ -4262,7 +4360,7 @@ function peg$parse(input, options) {
|
|
|
4262
4360
|
s6 = peg$parse_();
|
|
4263
4361
|
if (s6 !== peg$FAILED) {
|
|
4264
4362
|
peg$savedPos = s0;
|
|
4265
|
-
s1 = peg$
|
|
4363
|
+
s1 = peg$c116(s3, s4, s5);
|
|
4266
4364
|
s0 = s1;
|
|
4267
4365
|
}
|
|
4268
4366
|
else {
|
|
@@ -4341,7 +4439,7 @@ function peg$parse(input, options) {
|
|
|
4341
4439
|
s9 = peg$parsenewline();
|
|
4342
4440
|
if (s9 !== peg$FAILED) {
|
|
4343
4441
|
peg$savedPos = s4;
|
|
4344
|
-
s5 = peg$
|
|
4442
|
+
s5 = peg$c117(s1, s7);
|
|
4345
4443
|
s4 = s5;
|
|
4346
4444
|
}
|
|
4347
4445
|
else {
|
|
@@ -4401,7 +4499,7 @@ function peg$parse(input, options) {
|
|
|
4401
4499
|
s9 = peg$parsenewline();
|
|
4402
4500
|
if (s9 !== peg$FAILED) {
|
|
4403
4501
|
peg$savedPos = s4;
|
|
4404
|
-
s5 = peg$
|
|
4502
|
+
s5 = peg$c117(s1, s7);
|
|
4405
4503
|
s4 = s5;
|
|
4406
4504
|
}
|
|
4407
4505
|
else {
|
|
@@ -4436,7 +4534,7 @@ function peg$parse(input, options) {
|
|
|
4436
4534
|
}
|
|
4437
4535
|
if (s4 !== peg$FAILED) {
|
|
4438
4536
|
peg$savedPos = s0;
|
|
4439
|
-
s1 = peg$
|
|
4537
|
+
s1 = peg$c118(s1, s3, s4);
|
|
4440
4538
|
s0 = s1;
|
|
4441
4539
|
}
|
|
4442
4540
|
else {
|
|
@@ -4477,14 +4575,14 @@ function peg$parse(input, options) {
|
|
|
4477
4575
|
}
|
|
4478
4576
|
}
|
|
4479
4577
|
if (s3 !== peg$FAILED) {
|
|
4480
|
-
if (peg$
|
|
4578
|
+
if (peg$c40.test(input.charAt(peg$currPos))) {
|
|
4481
4579
|
s4 = input.charAt(peg$currPos);
|
|
4482
4580
|
peg$currPos++;
|
|
4483
4581
|
}
|
|
4484
4582
|
else {
|
|
4485
4583
|
s4 = peg$FAILED;
|
|
4486
4584
|
if (peg$silentFails === 0) {
|
|
4487
|
-
peg$fail(peg$
|
|
4585
|
+
peg$fail(peg$c41);
|
|
4488
4586
|
}
|
|
4489
4587
|
}
|
|
4490
4588
|
if (s4 !== peg$FAILED) {
|
|
@@ -4510,7 +4608,7 @@ function peg$parse(input, options) {
|
|
|
4510
4608
|
}
|
|
4511
4609
|
if (s1 !== peg$FAILED) {
|
|
4512
4610
|
peg$savedPos = s0;
|
|
4513
|
-
s1 = peg$
|
|
4611
|
+
s1 = peg$c119();
|
|
4514
4612
|
}
|
|
4515
4613
|
s0 = s1;
|
|
4516
4614
|
return s0;
|
|
@@ -4520,27 +4618,27 @@ function peg$parse(input, options) {
|
|
|
4520
4618
|
s0 = peg$currPos;
|
|
4521
4619
|
s1 = peg$currPos;
|
|
4522
4620
|
s2 = [];
|
|
4523
|
-
if (peg$
|
|
4621
|
+
if (peg$c120.test(input.charAt(peg$currPos))) {
|
|
4524
4622
|
s3 = input.charAt(peg$currPos);
|
|
4525
4623
|
peg$currPos++;
|
|
4526
4624
|
}
|
|
4527
4625
|
else {
|
|
4528
4626
|
s3 = peg$FAILED;
|
|
4529
4627
|
if (peg$silentFails === 0) {
|
|
4530
|
-
peg$fail(peg$
|
|
4628
|
+
peg$fail(peg$c121);
|
|
4531
4629
|
}
|
|
4532
4630
|
}
|
|
4533
4631
|
if (s3 !== peg$FAILED) {
|
|
4534
4632
|
while (s3 !== peg$FAILED) {
|
|
4535
4633
|
s2.push(s3);
|
|
4536
|
-
if (peg$
|
|
4634
|
+
if (peg$c120.test(input.charAt(peg$currPos))) {
|
|
4537
4635
|
s3 = input.charAt(peg$currPos);
|
|
4538
4636
|
peg$currPos++;
|
|
4539
4637
|
}
|
|
4540
4638
|
else {
|
|
4541
4639
|
s3 = peg$FAILED;
|
|
4542
4640
|
if (peg$silentFails === 0) {
|
|
4543
|
-
peg$fail(peg$
|
|
4641
|
+
peg$fail(peg$c121);
|
|
4544
4642
|
}
|
|
4545
4643
|
}
|
|
4546
4644
|
}
|
|
@@ -4556,7 +4654,7 @@ function peg$parse(input, options) {
|
|
|
4556
4654
|
}
|
|
4557
4655
|
if (s1 !== peg$FAILED) {
|
|
4558
4656
|
peg$savedPos = s0;
|
|
4559
|
-
s1 = peg$
|
|
4657
|
+
s1 = peg$c122(s1);
|
|
4560
4658
|
}
|
|
4561
4659
|
s0 = s1;
|
|
4562
4660
|
return s0;
|
|
@@ -4565,27 +4663,27 @@ function peg$parse(input, options) {
|
|
|
4565
4663
|
var s0, s1, s2;
|
|
4566
4664
|
s0 = peg$currPos;
|
|
4567
4665
|
s1 = [];
|
|
4568
|
-
if (peg$
|
|
4666
|
+
if (peg$c123.test(input.charAt(peg$currPos))) {
|
|
4569
4667
|
s2 = input.charAt(peg$currPos);
|
|
4570
4668
|
peg$currPos++;
|
|
4571
4669
|
}
|
|
4572
4670
|
else {
|
|
4573
4671
|
s2 = peg$FAILED;
|
|
4574
4672
|
if (peg$silentFails === 0) {
|
|
4575
|
-
peg$fail(peg$
|
|
4673
|
+
peg$fail(peg$c124);
|
|
4576
4674
|
}
|
|
4577
4675
|
}
|
|
4578
4676
|
if (s2 !== peg$FAILED) {
|
|
4579
4677
|
while (s2 !== peg$FAILED) {
|
|
4580
4678
|
s1.push(s2);
|
|
4581
|
-
if (peg$
|
|
4679
|
+
if (peg$c123.test(input.charAt(peg$currPos))) {
|
|
4582
4680
|
s2 = input.charAt(peg$currPos);
|
|
4583
4681
|
peg$currPos++;
|
|
4584
4682
|
}
|
|
4585
4683
|
else {
|
|
4586
4684
|
s2 = peg$FAILED;
|
|
4587
4685
|
if (peg$silentFails === 0) {
|
|
4588
|
-
peg$fail(peg$
|
|
4686
|
+
peg$fail(peg$c124);
|
|
4589
4687
|
}
|
|
4590
4688
|
}
|
|
4591
4689
|
}
|
|
@@ -4605,14 +4703,14 @@ function peg$parse(input, options) {
|
|
|
4605
4703
|
var s0, s1, s2, s3, s4;
|
|
4606
4704
|
s0 = peg$currPos;
|
|
4607
4705
|
s1 = peg$currPos;
|
|
4608
|
-
if (peg$
|
|
4706
|
+
if (peg$c125.test(input.charAt(peg$currPos))) {
|
|
4609
4707
|
s2 = input.charAt(peg$currPos);
|
|
4610
4708
|
peg$currPos++;
|
|
4611
4709
|
}
|
|
4612
4710
|
else {
|
|
4613
4711
|
s2 = peg$FAILED;
|
|
4614
4712
|
if (peg$silentFails === 0) {
|
|
4615
|
-
peg$fail(peg$
|
|
4713
|
+
peg$fail(peg$c126);
|
|
4616
4714
|
}
|
|
4617
4715
|
}
|
|
4618
4716
|
if (s2 === peg$FAILED) {
|
|
@@ -4620,27 +4718,27 @@ function peg$parse(input, options) {
|
|
|
4620
4718
|
}
|
|
4621
4719
|
if (s2 !== peg$FAILED) {
|
|
4622
4720
|
s3 = [];
|
|
4623
|
-
if (peg$
|
|
4721
|
+
if (peg$c123.test(input.charAt(peg$currPos))) {
|
|
4624
4722
|
s4 = input.charAt(peg$currPos);
|
|
4625
4723
|
peg$currPos++;
|
|
4626
4724
|
}
|
|
4627
4725
|
else {
|
|
4628
4726
|
s4 = peg$FAILED;
|
|
4629
4727
|
if (peg$silentFails === 0) {
|
|
4630
|
-
peg$fail(peg$
|
|
4728
|
+
peg$fail(peg$c124);
|
|
4631
4729
|
}
|
|
4632
4730
|
}
|
|
4633
4731
|
if (s4 !== peg$FAILED) {
|
|
4634
4732
|
while (s4 !== peg$FAILED) {
|
|
4635
4733
|
s3.push(s4);
|
|
4636
|
-
if (peg$
|
|
4734
|
+
if (peg$c123.test(input.charAt(peg$currPos))) {
|
|
4637
4735
|
s4 = input.charAt(peg$currPos);
|
|
4638
4736
|
peg$currPos++;
|
|
4639
4737
|
}
|
|
4640
4738
|
else {
|
|
4641
4739
|
s4 = peg$FAILED;
|
|
4642
4740
|
if (peg$silentFails === 0) {
|
|
4643
|
-
peg$fail(peg$
|
|
4741
|
+
peg$fail(peg$c124);
|
|
4644
4742
|
}
|
|
4645
4743
|
}
|
|
4646
4744
|
}
|
|
@@ -4672,36 +4770,36 @@ function peg$parse(input, options) {
|
|
|
4672
4770
|
function peg$parseBoolean() {
|
|
4673
4771
|
var s0, s1;
|
|
4674
4772
|
s0 = peg$currPos;
|
|
4675
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
4676
|
-
s1 = peg$
|
|
4773
|
+
if (input.substr(peg$currPos, 4) === peg$c127) {
|
|
4774
|
+
s1 = peg$c127;
|
|
4677
4775
|
peg$currPos += 4;
|
|
4678
4776
|
}
|
|
4679
4777
|
else {
|
|
4680
4778
|
s1 = peg$FAILED;
|
|
4681
4779
|
if (peg$silentFails === 0) {
|
|
4682
|
-
peg$fail(peg$
|
|
4780
|
+
peg$fail(peg$c128);
|
|
4683
4781
|
}
|
|
4684
4782
|
}
|
|
4685
4783
|
if (s1 !== peg$FAILED) {
|
|
4686
4784
|
peg$savedPos = s0;
|
|
4687
|
-
s1 = peg$
|
|
4785
|
+
s1 = peg$c129();
|
|
4688
4786
|
}
|
|
4689
4787
|
s0 = s1;
|
|
4690
4788
|
if (s0 === peg$FAILED) {
|
|
4691
4789
|
s0 = peg$currPos;
|
|
4692
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4693
|
-
s1 = peg$
|
|
4790
|
+
if (input.substr(peg$currPos, 5) === peg$c130) {
|
|
4791
|
+
s1 = peg$c130;
|
|
4694
4792
|
peg$currPos += 5;
|
|
4695
4793
|
}
|
|
4696
4794
|
else {
|
|
4697
4795
|
s1 = peg$FAILED;
|
|
4698
4796
|
if (peg$silentFails === 0) {
|
|
4699
|
-
peg$fail(peg$
|
|
4797
|
+
peg$fail(peg$c131);
|
|
4700
4798
|
}
|
|
4701
4799
|
}
|
|
4702
4800
|
if (s1 !== peg$FAILED) {
|
|
4703
4801
|
peg$savedPos = s0;
|
|
4704
|
-
s1 = peg$
|
|
4802
|
+
s1 = peg$c132();
|
|
4705
4803
|
}
|
|
4706
4804
|
s0 = s1;
|
|
4707
4805
|
}
|
|
@@ -4715,13 +4813,13 @@ function peg$parse(input, options) {
|
|
|
4715
4813
|
if (s2 !== peg$FAILED) {
|
|
4716
4814
|
s3 = peg$currPos;
|
|
4717
4815
|
if (input.charCodeAt(peg$currPos) === 46) {
|
|
4718
|
-
s4 = peg$
|
|
4816
|
+
s4 = peg$c133;
|
|
4719
4817
|
peg$currPos++;
|
|
4720
4818
|
}
|
|
4721
4819
|
else {
|
|
4722
4820
|
s4 = peg$FAILED;
|
|
4723
4821
|
if (peg$silentFails === 0) {
|
|
4724
|
-
peg$fail(peg$
|
|
4822
|
+
peg$fail(peg$c134);
|
|
4725
4823
|
}
|
|
4726
4824
|
}
|
|
4727
4825
|
if (s4 !== peg$FAILED) {
|
|
@@ -4743,14 +4841,14 @@ function peg$parse(input, options) {
|
|
|
4743
4841
|
s3 = null;
|
|
4744
4842
|
}
|
|
4745
4843
|
if (s3 !== peg$FAILED) {
|
|
4746
|
-
if (peg$
|
|
4844
|
+
if (peg$c135.test(input.charAt(peg$currPos))) {
|
|
4747
4845
|
s4 = input.charAt(peg$currPos);
|
|
4748
4846
|
peg$currPos++;
|
|
4749
4847
|
}
|
|
4750
4848
|
else {
|
|
4751
4849
|
s4 = peg$FAILED;
|
|
4752
4850
|
if (peg$silentFails === 0) {
|
|
4753
|
-
peg$fail(peg$
|
|
4851
|
+
peg$fail(peg$c136);
|
|
4754
4852
|
}
|
|
4755
4853
|
}
|
|
4756
4854
|
if (s4 !== peg$FAILED) {
|
|
@@ -4790,13 +4888,13 @@ function peg$parse(input, options) {
|
|
|
4790
4888
|
s2 = peg$parsenumber();
|
|
4791
4889
|
if (s2 !== peg$FAILED) {
|
|
4792
4890
|
if (input.charCodeAt(peg$currPos) === 46) {
|
|
4793
|
-
s3 = peg$
|
|
4891
|
+
s3 = peg$c133;
|
|
4794
4892
|
peg$currPos++;
|
|
4795
4893
|
}
|
|
4796
4894
|
else {
|
|
4797
4895
|
s3 = peg$FAILED;
|
|
4798
4896
|
if (peg$silentFails === 0) {
|
|
4799
|
-
peg$fail(peg$
|
|
4897
|
+
peg$fail(peg$c134);
|
|
4800
4898
|
}
|
|
4801
4899
|
}
|
|
4802
4900
|
if (s3 !== peg$FAILED) {
|
|
@@ -4831,39 +4929,39 @@ function peg$parse(input, options) {
|
|
|
4831
4929
|
function peg$parseitem() {
|
|
4832
4930
|
var s0, s1, s2, s3, s4;
|
|
4833
4931
|
s0 = peg$currPos;
|
|
4834
|
-
if (peg$
|
|
4932
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
4835
4933
|
s1 = input.charAt(peg$currPos);
|
|
4836
4934
|
peg$currPos++;
|
|
4837
4935
|
}
|
|
4838
4936
|
else {
|
|
4839
4937
|
s1 = peg$FAILED;
|
|
4840
4938
|
if (peg$silentFails === 0) {
|
|
4841
|
-
peg$fail(peg$
|
|
4939
|
+
peg$fail(peg$c96);
|
|
4842
4940
|
}
|
|
4843
4941
|
}
|
|
4844
4942
|
if (s1 !== peg$FAILED) {
|
|
4845
4943
|
s2 = peg$currPos;
|
|
4846
4944
|
s3 = [];
|
|
4847
|
-
if (peg$
|
|
4945
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
4848
4946
|
s4 = input.charAt(peg$currPos);
|
|
4849
4947
|
peg$currPos++;
|
|
4850
4948
|
}
|
|
4851
4949
|
else {
|
|
4852
4950
|
s4 = peg$FAILED;
|
|
4853
4951
|
if (peg$silentFails === 0) {
|
|
4854
|
-
peg$fail(peg$
|
|
4952
|
+
peg$fail(peg$c98);
|
|
4855
4953
|
}
|
|
4856
4954
|
}
|
|
4857
4955
|
while (s4 !== peg$FAILED) {
|
|
4858
4956
|
s3.push(s4);
|
|
4859
|
-
if (peg$
|
|
4957
|
+
if (peg$c97.test(input.charAt(peg$currPos))) {
|
|
4860
4958
|
s4 = input.charAt(peg$currPos);
|
|
4861
4959
|
peg$currPos++;
|
|
4862
4960
|
}
|
|
4863
4961
|
else {
|
|
4864
4962
|
s4 = peg$FAILED;
|
|
4865
4963
|
if (peg$silentFails === 0) {
|
|
4866
|
-
peg$fail(peg$
|
|
4964
|
+
peg$fail(peg$c98);
|
|
4867
4965
|
}
|
|
4868
4966
|
}
|
|
4869
4967
|
}
|
|
@@ -4874,19 +4972,19 @@ function peg$parse(input, options) {
|
|
|
4874
4972
|
s2 = s3;
|
|
4875
4973
|
}
|
|
4876
4974
|
if (s2 !== peg$FAILED) {
|
|
4877
|
-
if (peg$
|
|
4975
|
+
if (peg$c95.test(input.charAt(peg$currPos))) {
|
|
4878
4976
|
s3 = input.charAt(peg$currPos);
|
|
4879
4977
|
peg$currPos++;
|
|
4880
4978
|
}
|
|
4881
4979
|
else {
|
|
4882
4980
|
s3 = peg$FAILED;
|
|
4883
4981
|
if (peg$silentFails === 0) {
|
|
4884
|
-
peg$fail(peg$
|
|
4982
|
+
peg$fail(peg$c96);
|
|
4885
4983
|
}
|
|
4886
4984
|
}
|
|
4887
4985
|
if (s3 !== peg$FAILED) {
|
|
4888
4986
|
peg$savedPos = s0;
|
|
4889
|
-
s1 = peg$
|
|
4987
|
+
s1 = peg$c122(s2);
|
|
4890
4988
|
s0 = s1;
|
|
4891
4989
|
}
|
|
4892
4990
|
else {
|
|
@@ -4905,39 +5003,39 @@ function peg$parse(input, options) {
|
|
|
4905
5003
|
}
|
|
4906
5004
|
if (s0 === peg$FAILED) {
|
|
4907
5005
|
s0 = peg$currPos;
|
|
4908
|
-
if (peg$
|
|
5006
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
4909
5007
|
s1 = input.charAt(peg$currPos);
|
|
4910
5008
|
peg$currPos++;
|
|
4911
5009
|
}
|
|
4912
5010
|
else {
|
|
4913
5011
|
s1 = peg$FAILED;
|
|
4914
5012
|
if (peg$silentFails === 0) {
|
|
4915
|
-
peg$fail(peg$
|
|
5013
|
+
peg$fail(peg$c91);
|
|
4916
5014
|
}
|
|
4917
5015
|
}
|
|
4918
5016
|
if (s1 !== peg$FAILED) {
|
|
4919
5017
|
s2 = peg$currPos;
|
|
4920
5018
|
s3 = [];
|
|
4921
|
-
if (peg$
|
|
5019
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
4922
5020
|
s4 = input.charAt(peg$currPos);
|
|
4923
5021
|
peg$currPos++;
|
|
4924
5022
|
}
|
|
4925
5023
|
else {
|
|
4926
5024
|
s4 = peg$FAILED;
|
|
4927
5025
|
if (peg$silentFails === 0) {
|
|
4928
|
-
peg$fail(peg$
|
|
5026
|
+
peg$fail(peg$c93);
|
|
4929
5027
|
}
|
|
4930
5028
|
}
|
|
4931
5029
|
while (s4 !== peg$FAILED) {
|
|
4932
5030
|
s3.push(s4);
|
|
4933
|
-
if (peg$
|
|
5031
|
+
if (peg$c92.test(input.charAt(peg$currPos))) {
|
|
4934
5032
|
s4 = input.charAt(peg$currPos);
|
|
4935
5033
|
peg$currPos++;
|
|
4936
5034
|
}
|
|
4937
5035
|
else {
|
|
4938
5036
|
s4 = peg$FAILED;
|
|
4939
5037
|
if (peg$silentFails === 0) {
|
|
4940
|
-
peg$fail(peg$
|
|
5038
|
+
peg$fail(peg$c93);
|
|
4941
5039
|
}
|
|
4942
5040
|
}
|
|
4943
5041
|
}
|
|
@@ -4948,19 +5046,19 @@ function peg$parse(input, options) {
|
|
|
4948
5046
|
s2 = s3;
|
|
4949
5047
|
}
|
|
4950
5048
|
if (s2 !== peg$FAILED) {
|
|
4951
|
-
if (peg$
|
|
5049
|
+
if (peg$c90.test(input.charAt(peg$currPos))) {
|
|
4952
5050
|
s3 = input.charAt(peg$currPos);
|
|
4953
5051
|
peg$currPos++;
|
|
4954
5052
|
}
|
|
4955
5053
|
else {
|
|
4956
5054
|
s3 = peg$FAILED;
|
|
4957
5055
|
if (peg$silentFails === 0) {
|
|
4958
|
-
peg$fail(peg$
|
|
5056
|
+
peg$fail(peg$c91);
|
|
4959
5057
|
}
|
|
4960
5058
|
}
|
|
4961
5059
|
if (s3 !== peg$FAILED) {
|
|
4962
5060
|
peg$savedPos = s0;
|
|
4963
|
-
s1 = peg$
|
|
5061
|
+
s1 = peg$c122(s2);
|
|
4964
5062
|
s0 = s1;
|
|
4965
5063
|
}
|
|
4966
5064
|
else {
|
|
@@ -4984,7 +5082,7 @@ function peg$parse(input, options) {
|
|
|
4984
5082
|
s1 = peg$parsefloatNumber();
|
|
4985
5083
|
if (s1 !== peg$FAILED) {
|
|
4986
5084
|
peg$savedPos = s0;
|
|
4987
|
-
s1 = peg$
|
|
5085
|
+
s1 = peg$c137(s1);
|
|
4988
5086
|
}
|
|
4989
5087
|
s0 = s1;
|
|
4990
5088
|
if (s0 === peg$FAILED) {
|
|
@@ -4992,7 +5090,7 @@ function peg$parse(input, options) {
|
|
|
4992
5090
|
s1 = peg$parsenumber();
|
|
4993
5091
|
if (s1 !== peg$FAILED) {
|
|
4994
5092
|
peg$savedPos = s0;
|
|
4995
|
-
s1 = peg$
|
|
5093
|
+
s1 = peg$c138(s1);
|
|
4996
5094
|
}
|
|
4997
5095
|
s0 = s1;
|
|
4998
5096
|
}
|
|
@@ -5022,7 +5120,7 @@ function peg$parse(input, options) {
|
|
|
5022
5120
|
s5 = peg$parsepod_configuration();
|
|
5023
5121
|
if (s5 !== peg$FAILED) {
|
|
5024
5122
|
peg$savedPos = peg$currPos;
|
|
5025
|
-
s6 = peg$
|
|
5123
|
+
s6 = peg$c139(s1, s3, s5);
|
|
5026
5124
|
if (s6) {
|
|
5027
5125
|
s6 = void 0;
|
|
5028
5126
|
}
|
|
@@ -5065,7 +5163,7 @@ function peg$parse(input, options) {
|
|
|
5065
5163
|
s15 = peg$parsestrictIdentifier();
|
|
5066
5164
|
if (s15 !== peg$FAILED) {
|
|
5067
5165
|
peg$savedPos = peg$currPos;
|
|
5068
|
-
s16 = peg$
|
|
5166
|
+
s16 = peg$c140(s1, s3, s5, s9, s15);
|
|
5069
5167
|
if (s16) {
|
|
5070
5168
|
s16 = void 0;
|
|
5071
5169
|
}
|
|
@@ -5133,7 +5231,7 @@ function peg$parse(input, options) {
|
|
|
5133
5231
|
}
|
|
5134
5232
|
if (s10 !== peg$FAILED) {
|
|
5135
5233
|
peg$savedPos = s8;
|
|
5136
|
-
s9 = peg$
|
|
5234
|
+
s9 = peg$c141(s1, s3, s5, s9, s10);
|
|
5137
5235
|
s8 = s9;
|
|
5138
5236
|
}
|
|
5139
5237
|
else {
|
|
@@ -5182,7 +5280,7 @@ function peg$parse(input, options) {
|
|
|
5182
5280
|
s15 = peg$parsestrictIdentifier();
|
|
5183
5281
|
if (s15 !== peg$FAILED) {
|
|
5184
5282
|
peg$savedPos = peg$currPos;
|
|
5185
|
-
s16 = peg$
|
|
5283
|
+
s16 = peg$c140(s1, s3, s5, s9, s15);
|
|
5186
5284
|
if (s16) {
|
|
5187
5285
|
s16 = void 0;
|
|
5188
5286
|
}
|
|
@@ -5250,7 +5348,7 @@ function peg$parse(input, options) {
|
|
|
5250
5348
|
}
|
|
5251
5349
|
if (s10 !== peg$FAILED) {
|
|
5252
5350
|
peg$savedPos = s8;
|
|
5253
|
-
s9 = peg$
|
|
5351
|
+
s9 = peg$c141(s1, s3, s5, s9, s10);
|
|
5254
5352
|
s8 = s9;
|
|
5255
5353
|
}
|
|
5256
5354
|
else {
|
|
@@ -5283,7 +5381,7 @@ function peg$parse(input, options) {
|
|
|
5283
5381
|
s11 = peg$parsestrictIdentifier();
|
|
5284
5382
|
if (s11 !== peg$FAILED) {
|
|
5285
5383
|
peg$savedPos = peg$currPos;
|
|
5286
|
-
s12 = peg$
|
|
5384
|
+
s12 = peg$c142(s1, s3, s5, s7, s8, s11);
|
|
5287
5385
|
if (s12) {
|
|
5288
5386
|
s12 = void 0;
|
|
5289
5387
|
}
|
|
@@ -5297,7 +5395,7 @@ function peg$parse(input, options) {
|
|
|
5297
5395
|
}
|
|
5298
5396
|
if (s13 !== peg$FAILED) {
|
|
5299
5397
|
peg$savedPos = s9;
|
|
5300
|
-
s10 = peg$
|
|
5398
|
+
s10 = peg$c143(s1, s3, s5, s7, s8, s11);
|
|
5301
5399
|
s9 = s10;
|
|
5302
5400
|
}
|
|
5303
5401
|
else {
|
|
@@ -5321,7 +5419,7 @@ function peg$parse(input, options) {
|
|
|
5321
5419
|
}
|
|
5322
5420
|
if (s9 !== peg$FAILED) {
|
|
5323
5421
|
peg$savedPos = peg$currPos;
|
|
5324
|
-
s10 = peg$
|
|
5422
|
+
s10 = peg$c144(s1, s3, s5, s7, s8, s9);
|
|
5325
5423
|
if (s10) {
|
|
5326
5424
|
s10 = void 0;
|
|
5327
5425
|
}
|
|
@@ -5330,7 +5428,7 @@ function peg$parse(input, options) {
|
|
|
5330
5428
|
}
|
|
5331
5429
|
if (s10 !== peg$FAILED) {
|
|
5332
5430
|
peg$savedPos = s0;
|
|
5333
|
-
s1 = peg$
|
|
5431
|
+
s1 = peg$c145(s1, s3, s5, s7, s8, s9);
|
|
5334
5432
|
s0 = s1;
|
|
5335
5433
|
}
|
|
5336
5434
|
else {
|
|
@@ -5431,14 +5529,14 @@ function peg$parse(input, options) {
|
|
|
5431
5529
|
s3 = peg$currPos;
|
|
5432
5530
|
s4 = [];
|
|
5433
5531
|
s5 = peg$currPos;
|
|
5434
|
-
if (peg$
|
|
5532
|
+
if (peg$c146.test(input.charAt(peg$currPos))) {
|
|
5435
5533
|
s6 = input.charAt(peg$currPos);
|
|
5436
5534
|
peg$currPos++;
|
|
5437
5535
|
}
|
|
5438
5536
|
else {
|
|
5439
5537
|
s6 = peg$FAILED;
|
|
5440
5538
|
if (peg$silentFails === 0) {
|
|
5441
|
-
peg$fail(peg$
|
|
5539
|
+
peg$fail(peg$c147);
|
|
5442
5540
|
}
|
|
5443
5541
|
}
|
|
5444
5542
|
if (s6 !== peg$FAILED) {
|
|
@@ -5465,14 +5563,14 @@ function peg$parse(input, options) {
|
|
|
5465
5563
|
while (s5 !== peg$FAILED) {
|
|
5466
5564
|
s4.push(s5);
|
|
5467
5565
|
s5 = peg$currPos;
|
|
5468
|
-
if (peg$
|
|
5566
|
+
if (peg$c146.test(input.charAt(peg$currPos))) {
|
|
5469
5567
|
s6 = input.charAt(peg$currPos);
|
|
5470
5568
|
peg$currPos++;
|
|
5471
5569
|
}
|
|
5472
5570
|
else {
|
|
5473
5571
|
s6 = peg$FAILED;
|
|
5474
5572
|
if (peg$silentFails === 0) {
|
|
5475
|
-
peg$fail(peg$
|
|
5573
|
+
peg$fail(peg$c147);
|
|
5476
5574
|
}
|
|
5477
5575
|
}
|
|
5478
5576
|
if (s6 !== peg$FAILED) {
|
|
@@ -5510,7 +5608,7 @@ function peg$parse(input, options) {
|
|
|
5510
5608
|
s4 = peg$parseEOL();
|
|
5511
5609
|
if (s4 !== peg$FAILED) {
|
|
5512
5610
|
peg$savedPos = s0;
|
|
5513
|
-
s1 = peg$
|
|
5611
|
+
s1 = peg$c148();
|
|
5514
5612
|
s0 = s1;
|
|
5515
5613
|
}
|
|
5516
5614
|
else {
|
|
@@ -5542,7 +5640,7 @@ function peg$parse(input, options) {
|
|
|
5542
5640
|
if (s2 === peg$FAILED) {
|
|
5543
5641
|
s2 = peg$currPos;
|
|
5544
5642
|
peg$savedPos = peg$currPos;
|
|
5545
|
-
s3 = peg$
|
|
5643
|
+
s3 = peg$c149();
|
|
5546
5644
|
if (s3) {
|
|
5547
5645
|
s3 = void 0;
|
|
5548
5646
|
}
|
|
@@ -5573,7 +5671,7 @@ function peg$parse(input, options) {
|
|
|
5573
5671
|
}
|
|
5574
5672
|
if (s1 !== peg$FAILED) {
|
|
5575
5673
|
peg$savedPos = s0;
|
|
5576
|
-
s1 = peg$
|
|
5674
|
+
s1 = peg$c150();
|
|
5577
5675
|
}
|
|
5578
5676
|
s0 = s1;
|
|
5579
5677
|
return s0;
|
|
@@ -5581,10 +5679,10 @@ function peg$parse(input, options) {
|
|
|
5581
5679
|
function peg$parsetableRow() {
|
|
5582
5680
|
var s0, s1;
|
|
5583
5681
|
s0 = peg$currPos;
|
|
5584
|
-
s1 = peg$
|
|
5682
|
+
s1 = peg$parseplain_line();
|
|
5585
5683
|
if (s1 !== peg$FAILED) {
|
|
5586
5684
|
peg$savedPos = s0;
|
|
5587
|
-
s1 = peg$
|
|
5685
|
+
s1 = peg$c151(s1);
|
|
5588
5686
|
}
|
|
5589
5687
|
s0 = s1;
|
|
5590
5688
|
return s0;
|
|
@@ -5593,7 +5691,7 @@ function peg$parse(input, options) {
|
|
|
5593
5691
|
var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
|
5594
5692
|
s0 = peg$currPos;
|
|
5595
5693
|
peg$savedPos = peg$currPos;
|
|
5596
|
-
s1 = peg$
|
|
5694
|
+
s1 = peg$c152();
|
|
5597
5695
|
if (s1) {
|
|
5598
5696
|
s1 = void 0;
|
|
5599
5697
|
}
|
|
@@ -5676,7 +5774,7 @@ function peg$parse(input, options) {
|
|
|
5676
5774
|
s4 = peg$parsetableHeadSeparator();
|
|
5677
5775
|
if (s4 !== peg$FAILED) {
|
|
5678
5776
|
peg$savedPos = s3;
|
|
5679
|
-
s4 = peg$
|
|
5777
|
+
s4 = peg$c153(s2, s4);
|
|
5680
5778
|
}
|
|
5681
5779
|
s3 = s4;
|
|
5682
5780
|
if (s3 !== peg$FAILED) {
|
|
@@ -5757,12 +5855,12 @@ function peg$parse(input, options) {
|
|
|
5757
5855
|
s8 = peg$parsetableBodyRowSeparator();
|
|
5758
5856
|
if (s8 !== peg$FAILED) {
|
|
5759
5857
|
peg$savedPos = s7;
|
|
5760
|
-
s8 = peg$
|
|
5858
|
+
s8 = peg$c154(s2, s3, s6, s8);
|
|
5761
5859
|
}
|
|
5762
5860
|
s7 = s8;
|
|
5763
5861
|
if (s7 !== peg$FAILED) {
|
|
5764
5862
|
peg$savedPos = s5;
|
|
5765
|
-
s6 = peg$
|
|
5863
|
+
s6 = peg$c155(s2, s3, s6, s7);
|
|
5766
5864
|
s5 = s6;
|
|
5767
5865
|
}
|
|
5768
5866
|
else {
|
|
@@ -5803,7 +5901,7 @@ function peg$parse(input, options) {
|
|
|
5803
5901
|
s8 = peg$parsetableRow();
|
|
5804
5902
|
if (s8 !== peg$FAILED) {
|
|
5805
5903
|
peg$savedPos = s5;
|
|
5806
|
-
s6 = peg$
|
|
5904
|
+
s6 = peg$c156(s2, s3, s8);
|
|
5807
5905
|
s5 = s6;
|
|
5808
5906
|
}
|
|
5809
5907
|
else {
|
|
@@ -5900,12 +5998,12 @@ function peg$parse(input, options) {
|
|
|
5900
5998
|
s8 = peg$parsetableBodyRowSeparator();
|
|
5901
5999
|
if (s8 !== peg$FAILED) {
|
|
5902
6000
|
peg$savedPos = s7;
|
|
5903
|
-
s8 = peg$
|
|
6001
|
+
s8 = peg$c154(s2, s3, s6, s8);
|
|
5904
6002
|
}
|
|
5905
6003
|
s7 = s8;
|
|
5906
6004
|
if (s7 !== peg$FAILED) {
|
|
5907
6005
|
peg$savedPos = s5;
|
|
5908
|
-
s6 = peg$
|
|
6006
|
+
s6 = peg$c155(s2, s3, s6, s7);
|
|
5909
6007
|
s5 = s6;
|
|
5910
6008
|
}
|
|
5911
6009
|
else {
|
|
@@ -5946,7 +6044,7 @@ function peg$parse(input, options) {
|
|
|
5946
6044
|
s8 = peg$parsetableRow();
|
|
5947
6045
|
if (s8 !== peg$FAILED) {
|
|
5948
6046
|
peg$savedPos = s5;
|
|
5949
|
-
s6 = peg$
|
|
6047
|
+
s6 = peg$c156(s2, s3, s8);
|
|
5950
6048
|
s5 = s6;
|
|
5951
6049
|
}
|
|
5952
6050
|
else {
|
|
@@ -5971,7 +6069,7 @@ function peg$parse(input, options) {
|
|
|
5971
6069
|
}
|
|
5972
6070
|
if (s4 !== peg$FAILED) {
|
|
5973
6071
|
peg$savedPos = peg$currPos;
|
|
5974
|
-
s5 = peg$
|
|
6072
|
+
s5 = peg$c157(s2, s3, s4);
|
|
5975
6073
|
if (s5) {
|
|
5976
6074
|
s5 = void 0;
|
|
5977
6075
|
}
|
|
@@ -5980,7 +6078,7 @@ function peg$parse(input, options) {
|
|
|
5980
6078
|
}
|
|
5981
6079
|
if (s5 !== peg$FAILED) {
|
|
5982
6080
|
peg$savedPos = s0;
|
|
5983
|
-
s1 = peg$
|
|
6081
|
+
s1 = peg$c158(s2, s3, s4);
|
|
5984
6082
|
s0 = s1;
|
|
5985
6083
|
}
|
|
5986
6084
|
else {
|
|
@@ -6054,7 +6152,7 @@ function peg$parse(input, options) {
|
|
|
6054
6152
|
}
|
|
6055
6153
|
if (s4 !== peg$FAILED) {
|
|
6056
6154
|
peg$savedPos = s2;
|
|
6057
|
-
s3 = peg$
|
|
6155
|
+
s3 = peg$c159(s3, s4);
|
|
6058
6156
|
s2 = s3;
|
|
6059
6157
|
}
|
|
6060
6158
|
else {
|
|
@@ -6113,7 +6211,7 @@ function peg$parse(input, options) {
|
|
|
6113
6211
|
}
|
|
6114
6212
|
if (s4 !== peg$FAILED) {
|
|
6115
6213
|
peg$savedPos = s2;
|
|
6116
|
-
s3 = peg$
|
|
6214
|
+
s3 = peg$c159(s3, s4);
|
|
6117
6215
|
s2 = s3;
|
|
6118
6216
|
}
|
|
6119
6217
|
else {
|
|
@@ -6132,7 +6230,7 @@ function peg$parse(input, options) {
|
|
|
6132
6230
|
}
|
|
6133
6231
|
if (s1 !== peg$FAILED) {
|
|
6134
6232
|
peg$savedPos = s0;
|
|
6135
|
-
s1 = peg$
|
|
6233
|
+
s1 = peg$c160(s1);
|
|
6136
6234
|
}
|
|
6137
6235
|
s0 = s1;
|
|
6138
6236
|
if (s0 === peg$FAILED) {
|
|
@@ -6172,7 +6270,7 @@ function peg$parse(input, options) {
|
|
|
6172
6270
|
s5 = peg$parsepod_configuration();
|
|
6173
6271
|
if (s5 !== peg$FAILED) {
|
|
6174
6272
|
peg$savedPos = peg$currPos;
|
|
6175
|
-
s6 = peg$
|
|
6273
|
+
s6 = peg$c161(s1, s3, s5);
|
|
6176
6274
|
if (s6) {
|
|
6177
6275
|
s6 = void 0;
|
|
6178
6276
|
}
|
|
@@ -6181,7 +6279,7 @@ function peg$parse(input, options) {
|
|
|
6181
6279
|
}
|
|
6182
6280
|
if (s6 !== peg$FAILED) {
|
|
6183
6281
|
peg$savedPos = peg$currPos;
|
|
6184
|
-
s7 = peg$
|
|
6282
|
+
s7 = peg$c162(s1, s3, s5);
|
|
6185
6283
|
if (s7) {
|
|
6186
6284
|
s7 = void 0;
|
|
6187
6285
|
}
|
|
@@ -6234,12 +6332,12 @@ function peg$parse(input, options) {
|
|
|
6234
6332
|
}
|
|
6235
6333
|
if (s9 !== peg$FAILED) {
|
|
6236
6334
|
peg$savedPos = s8;
|
|
6237
|
-
s9 = peg$
|
|
6335
|
+
s9 = peg$c163(s1, s3, s5, s9);
|
|
6238
6336
|
}
|
|
6239
6337
|
s8 = s9;
|
|
6240
6338
|
if (s8 !== peg$FAILED) {
|
|
6241
6339
|
peg$savedPos = peg$currPos;
|
|
6242
|
-
s9 = peg$
|
|
6340
|
+
s9 = peg$c164(s1, s3, s5, s8);
|
|
6243
6341
|
if (s9) {
|
|
6244
6342
|
s9 = void 0;
|
|
6245
6343
|
}
|
|
@@ -6262,7 +6360,7 @@ function peg$parse(input, options) {
|
|
|
6262
6360
|
s13 = peg$parsestrictIdentifier();
|
|
6263
6361
|
if (s13 !== peg$FAILED) {
|
|
6264
6362
|
peg$savedPos = peg$currPos;
|
|
6265
|
-
s14 = peg$
|
|
6363
|
+
s14 = peg$c142(s1, s3, s5, s8, s10, s13);
|
|
6266
6364
|
if (s14) {
|
|
6267
6365
|
s14 = void 0;
|
|
6268
6366
|
}
|
|
@@ -6276,7 +6374,7 @@ function peg$parse(input, options) {
|
|
|
6276
6374
|
}
|
|
6277
6375
|
if (s15 !== peg$FAILED) {
|
|
6278
6376
|
peg$savedPos = s11;
|
|
6279
|
-
s12 = peg$
|
|
6377
|
+
s12 = peg$c165(s1, s3, s5, s8, s10, s13);
|
|
6280
6378
|
s11 = s12;
|
|
6281
6379
|
}
|
|
6282
6380
|
else {
|
|
@@ -6300,7 +6398,7 @@ function peg$parse(input, options) {
|
|
|
6300
6398
|
}
|
|
6301
6399
|
if (s11 !== peg$FAILED) {
|
|
6302
6400
|
peg$savedPos = s0;
|
|
6303
|
-
s1 = peg$
|
|
6401
|
+
s1 = peg$c166(s1, s3, s5, s8, s10, s11);
|
|
6304
6402
|
s0 = s1;
|
|
6305
6403
|
}
|
|
6306
6404
|
else {
|
|
@@ -6380,7 +6478,7 @@ function peg$parse(input, options) {
|
|
|
6380
6478
|
s5 = peg$parsepod_configuration();
|
|
6381
6479
|
if (s5 !== peg$FAILED) {
|
|
6382
6480
|
peg$savedPos = peg$currPos;
|
|
6383
|
-
s6 = peg$
|
|
6481
|
+
s6 = peg$c161(s1, s3, s5);
|
|
6384
6482
|
if (s6) {
|
|
6385
6483
|
s6 = void 0;
|
|
6386
6484
|
}
|
|
@@ -6389,7 +6487,7 @@ function peg$parse(input, options) {
|
|
|
6389
6487
|
}
|
|
6390
6488
|
if (s6 !== peg$FAILED) {
|
|
6391
6489
|
peg$savedPos = peg$currPos;
|
|
6392
|
-
s7 = peg$
|
|
6490
|
+
s7 = peg$c167(s1, s3, s5);
|
|
6393
6491
|
if (s7) {
|
|
6394
6492
|
s7 = void 0;
|
|
6395
6493
|
}
|
|
@@ -6415,7 +6513,7 @@ function peg$parse(input, options) {
|
|
|
6415
6513
|
}
|
|
6416
6514
|
if (s11 !== peg$FAILED) {
|
|
6417
6515
|
peg$savedPos = s8;
|
|
6418
|
-
s9 = peg$
|
|
6516
|
+
s9 = peg$c168(s1, s3, s5, s10);
|
|
6419
6517
|
s8 = s9;
|
|
6420
6518
|
}
|
|
6421
6519
|
else {
|
|
@@ -6448,7 +6546,7 @@ function peg$parse(input, options) {
|
|
|
6448
6546
|
s12 = peg$parsestrictIdentifier();
|
|
6449
6547
|
if (s12 !== peg$FAILED) {
|
|
6450
6548
|
peg$savedPos = peg$currPos;
|
|
6451
|
-
s13 = peg$
|
|
6549
|
+
s13 = peg$c142(s1, s3, s5, s8, s9, s12);
|
|
6452
6550
|
if (s13) {
|
|
6453
6551
|
s13 = void 0;
|
|
6454
6552
|
}
|
|
@@ -6462,7 +6560,7 @@ function peg$parse(input, options) {
|
|
|
6462
6560
|
}
|
|
6463
6561
|
if (s14 !== peg$FAILED) {
|
|
6464
6562
|
peg$savedPos = s10;
|
|
6465
|
-
s11 = peg$
|
|
6563
|
+
s11 = peg$c169(s1, s3, s5, s8, s9, s12);
|
|
6466
6564
|
s10 = s11;
|
|
6467
6565
|
}
|
|
6468
6566
|
else {
|
|
@@ -6486,7 +6584,7 @@ function peg$parse(input, options) {
|
|
|
6486
6584
|
}
|
|
6487
6585
|
if (s10 !== peg$FAILED) {
|
|
6488
6586
|
peg$savedPos = peg$currPos;
|
|
6489
|
-
s11 = peg$
|
|
6587
|
+
s11 = peg$c144(s1, s3, s5, s8, s9, s10);
|
|
6490
6588
|
if (s11) {
|
|
6491
6589
|
s11 = void 0;
|
|
6492
6590
|
}
|
|
@@ -6495,7 +6593,7 @@ function peg$parse(input, options) {
|
|
|
6495
6593
|
}
|
|
6496
6594
|
if (s11 !== peg$FAILED) {
|
|
6497
6595
|
peg$savedPos = s0;
|
|
6498
|
-
s1 = peg$
|
|
6596
|
+
s1 = peg$c170(s1, s3, s5, s8, s9, s10);
|
|
6499
6597
|
s0 = s1;
|
|
6500
6598
|
}
|
|
6501
6599
|
else {
|
|
@@ -6618,7 +6716,7 @@ function peg$parse(input, options) {
|
|
|
6618
6716
|
}
|
|
6619
6717
|
if (s8 !== peg$FAILED) {
|
|
6620
6718
|
peg$savedPos = s7;
|
|
6621
|
-
s8 = peg$
|
|
6719
|
+
s8 = peg$c171(s1, s3, s5, s8);
|
|
6622
6720
|
}
|
|
6623
6721
|
s7 = s8;
|
|
6624
6722
|
if (s7 === peg$FAILED) {
|
|
@@ -6657,7 +6755,7 @@ function peg$parse(input, options) {
|
|
|
6657
6755
|
}
|
|
6658
6756
|
if (s9 !== peg$FAILED) {
|
|
6659
6757
|
peg$savedPos = s7;
|
|
6660
|
-
s8 = peg$
|
|
6758
|
+
s8 = peg$c172(s1, s3, s5, s8, s9);
|
|
6661
6759
|
s7 = s8;
|
|
6662
6760
|
}
|
|
6663
6761
|
else {
|
|
@@ -6715,7 +6813,7 @@ function peg$parse(input, options) {
|
|
|
6715
6813
|
}
|
|
6716
6814
|
if (s8 !== peg$FAILED) {
|
|
6717
6815
|
peg$savedPos = s7;
|
|
6718
|
-
s8 = peg$
|
|
6816
|
+
s8 = peg$c171(s1, s3, s5, s8);
|
|
6719
6817
|
}
|
|
6720
6818
|
s7 = s8;
|
|
6721
6819
|
if (s7 === peg$FAILED) {
|
|
@@ -6754,7 +6852,7 @@ function peg$parse(input, options) {
|
|
|
6754
6852
|
}
|
|
6755
6853
|
if (s9 !== peg$FAILED) {
|
|
6756
6854
|
peg$savedPos = s7;
|
|
6757
|
-
s8 = peg$
|
|
6855
|
+
s8 = peg$c172(s1, s3, s5, s8, s9);
|
|
6758
6856
|
s7 = s8;
|
|
6759
6857
|
}
|
|
6760
6858
|
else {
|
|
@@ -6784,7 +6882,7 @@ function peg$parse(input, options) {
|
|
|
6784
6882
|
s10 = peg$parsestrictIdentifier();
|
|
6785
6883
|
if (s10 !== peg$FAILED) {
|
|
6786
6884
|
peg$savedPos = peg$currPos;
|
|
6787
|
-
s11 = peg$
|
|
6885
|
+
s11 = peg$c142(s1, s3, s5, s6, s7, s10);
|
|
6788
6886
|
if (s11) {
|
|
6789
6887
|
s11 = void 0;
|
|
6790
6888
|
}
|
|
@@ -6798,7 +6896,7 @@ function peg$parse(input, options) {
|
|
|
6798
6896
|
}
|
|
6799
6897
|
if (s12 !== peg$FAILED) {
|
|
6800
6898
|
peg$savedPos = s8;
|
|
6801
|
-
s9 = peg$
|
|
6899
|
+
s9 = peg$c173(s1, s3, s5, s6, s7, s10);
|
|
6802
6900
|
s8 = s9;
|
|
6803
6901
|
}
|
|
6804
6902
|
else {
|
|
@@ -6822,7 +6920,7 @@ function peg$parse(input, options) {
|
|
|
6822
6920
|
}
|
|
6823
6921
|
if (s8 !== peg$FAILED) {
|
|
6824
6922
|
peg$savedPos = peg$currPos;
|
|
6825
|
-
s9 = peg$
|
|
6923
|
+
s9 = peg$c144(s1, s3, s5, s6, s7, s8);
|
|
6826
6924
|
if (s9) {
|
|
6827
6925
|
s9 = void 0;
|
|
6828
6926
|
}
|
|
@@ -6831,7 +6929,7 @@ function peg$parse(input, options) {
|
|
|
6831
6929
|
}
|
|
6832
6930
|
if (s9 !== peg$FAILED) {
|
|
6833
6931
|
peg$savedPos = s0;
|
|
6834
|
-
s1 = peg$
|
|
6932
|
+
s1 = peg$c174(s1, s3, s5, s6, s7, s8);
|
|
6835
6933
|
s0 = s1;
|
|
6836
6934
|
}
|
|
6837
6935
|
else {
|
|
@@ -6896,7 +6994,7 @@ function peg$parse(input, options) {
|
|
|
6896
6994
|
}
|
|
6897
6995
|
if (s1 !== peg$FAILED) {
|
|
6898
6996
|
peg$savedPos = s0;
|
|
6899
|
-
s1 = peg$
|
|
6997
|
+
s1 = peg$c175();
|
|
6900
6998
|
}
|
|
6901
6999
|
s0 = s1;
|
|
6902
7000
|
return s0;
|
|
@@ -6909,32 +7007,32 @@ function peg$parse(input, options) {
|
|
|
6909
7007
|
s3 = peg$parseemptyline();
|
|
6910
7008
|
if (s3 !== peg$FAILED) {
|
|
6911
7009
|
peg$savedPos = s2;
|
|
6912
|
-
s3 = peg$
|
|
7010
|
+
s3 = peg$c176();
|
|
6913
7011
|
}
|
|
6914
7012
|
s2 = s3;
|
|
6915
7013
|
if (s2 === peg$FAILED) {
|
|
6916
7014
|
s2 = [];
|
|
6917
|
-
if (peg$
|
|
7015
|
+
if (peg$c177.test(input.charAt(peg$currPos))) {
|
|
6918
7016
|
s3 = input.charAt(peg$currPos);
|
|
6919
7017
|
peg$currPos++;
|
|
6920
7018
|
}
|
|
6921
7019
|
else {
|
|
6922
7020
|
s3 = peg$FAILED;
|
|
6923
7021
|
if (peg$silentFails === 0) {
|
|
6924
|
-
peg$fail(peg$
|
|
7022
|
+
peg$fail(peg$c178);
|
|
6925
7023
|
}
|
|
6926
7024
|
}
|
|
6927
7025
|
if (s3 !== peg$FAILED) {
|
|
6928
7026
|
while (s3 !== peg$FAILED) {
|
|
6929
7027
|
s2.push(s3);
|
|
6930
|
-
if (peg$
|
|
7028
|
+
if (peg$c177.test(input.charAt(peg$currPos))) {
|
|
6931
7029
|
s3 = input.charAt(peg$currPos);
|
|
6932
7030
|
peg$currPos++;
|
|
6933
7031
|
}
|
|
6934
7032
|
else {
|
|
6935
7033
|
s3 = peg$FAILED;
|
|
6936
7034
|
if (peg$silentFails === 0) {
|
|
6937
|
-
peg$fail(peg$
|
|
7035
|
+
peg$fail(peg$c178);
|
|
6938
7036
|
}
|
|
6939
7037
|
}
|
|
6940
7038
|
}
|
|
@@ -6953,32 +7051,32 @@ function peg$parse(input, options) {
|
|
|
6953
7051
|
s3 = peg$parseemptyline();
|
|
6954
7052
|
if (s3 !== peg$FAILED) {
|
|
6955
7053
|
peg$savedPos = s2;
|
|
6956
|
-
s3 = peg$
|
|
7054
|
+
s3 = peg$c176();
|
|
6957
7055
|
}
|
|
6958
7056
|
s2 = s3;
|
|
6959
7057
|
if (s2 === peg$FAILED) {
|
|
6960
7058
|
s2 = [];
|
|
6961
|
-
if (peg$
|
|
7059
|
+
if (peg$c177.test(input.charAt(peg$currPos))) {
|
|
6962
7060
|
s3 = input.charAt(peg$currPos);
|
|
6963
7061
|
peg$currPos++;
|
|
6964
7062
|
}
|
|
6965
7063
|
else {
|
|
6966
7064
|
s3 = peg$FAILED;
|
|
6967
7065
|
if (peg$silentFails === 0) {
|
|
6968
|
-
peg$fail(peg$
|
|
7066
|
+
peg$fail(peg$c178);
|
|
6969
7067
|
}
|
|
6970
7068
|
}
|
|
6971
7069
|
if (s3 !== peg$FAILED) {
|
|
6972
7070
|
while (s3 !== peg$FAILED) {
|
|
6973
7071
|
s2.push(s3);
|
|
6974
|
-
if (peg$
|
|
7072
|
+
if (peg$c177.test(input.charAt(peg$currPos))) {
|
|
6975
7073
|
s3 = input.charAt(peg$currPos);
|
|
6976
7074
|
peg$currPos++;
|
|
6977
7075
|
}
|
|
6978
7076
|
else {
|
|
6979
7077
|
s3 = peg$FAILED;
|
|
6980
7078
|
if (peg$silentFails === 0) {
|
|
6981
|
-
peg$fail(peg$
|
|
7079
|
+
peg$fail(peg$c178);
|
|
6982
7080
|
}
|
|
6983
7081
|
}
|
|
6984
7082
|
}
|
|
@@ -6997,7 +7095,7 @@ function peg$parse(input, options) {
|
|
|
6997
7095
|
}
|
|
6998
7096
|
if (s1 !== peg$FAILED) {
|
|
6999
7097
|
peg$savedPos = s0;
|
|
7000
|
-
s1 = peg$
|
|
7098
|
+
s1 = peg$c179(s1);
|
|
7001
7099
|
}
|
|
7002
7100
|
s0 = s1;
|
|
7003
7101
|
return s0;
|
|
@@ -7036,7 +7134,7 @@ function peg$parse(input, options) {
|
|
|
7036
7134
|
}
|
|
7037
7135
|
if (s5 !== peg$FAILED) {
|
|
7038
7136
|
peg$savedPos = peg$currPos;
|
|
7039
|
-
s6 = peg$
|
|
7137
|
+
s6 = peg$c180(s1, s3);
|
|
7040
7138
|
if (s6) {
|
|
7041
7139
|
s6 = void 0;
|
|
7042
7140
|
}
|
|
@@ -7059,7 +7157,7 @@ function peg$parse(input, options) {
|
|
|
7059
7157
|
s10 = peg$FAILED;
|
|
7060
7158
|
}
|
|
7061
7159
|
if (s10 !== peg$FAILED) {
|
|
7062
|
-
s11 = peg$
|
|
7160
|
+
s11 = peg$parseplain_line();
|
|
7063
7161
|
if (s11 !== peg$FAILED) {
|
|
7064
7162
|
s10 = [s10, s11];
|
|
7065
7163
|
s9 = s10;
|
|
@@ -7088,7 +7186,7 @@ function peg$parse(input, options) {
|
|
|
7088
7186
|
s10 = peg$FAILED;
|
|
7089
7187
|
}
|
|
7090
7188
|
if (s10 !== peg$FAILED) {
|
|
7091
|
-
s11 = peg$
|
|
7189
|
+
s11 = peg$parseplain_line();
|
|
7092
7190
|
if (s11 !== peg$FAILED) {
|
|
7093
7191
|
s10 = [s10, s11];
|
|
7094
7192
|
s9 = s10;
|
|
@@ -7111,7 +7209,7 @@ function peg$parse(input, options) {
|
|
|
7111
7209
|
}
|
|
7112
7210
|
if (s7 !== peg$FAILED) {
|
|
7113
7211
|
peg$savedPos = s0;
|
|
7114
|
-
s1 = peg$
|
|
7212
|
+
s1 = peg$c181(s1, s3, s7);
|
|
7115
7213
|
s0 = s1;
|
|
7116
7214
|
}
|
|
7117
7215
|
else {
|
|
@@ -7184,7 +7282,7 @@ function peg$parse(input, options) {
|
|
|
7184
7282
|
}
|
|
7185
7283
|
if (s5 !== peg$FAILED) {
|
|
7186
7284
|
peg$savedPos = peg$currPos;
|
|
7187
|
-
s6 = peg$
|
|
7285
|
+
s6 = peg$c182(s1, s3);
|
|
7188
7286
|
if (s6) {
|
|
7189
7287
|
s6 = void 0;
|
|
7190
7288
|
}
|
|
@@ -7193,7 +7291,7 @@ function peg$parse(input, options) {
|
|
|
7193
7291
|
}
|
|
7194
7292
|
if (s6 !== peg$FAILED) {
|
|
7195
7293
|
peg$savedPos = peg$currPos;
|
|
7196
|
-
s7 = peg$
|
|
7294
|
+
s7 = peg$c183(s1, s3);
|
|
7197
7295
|
if (s7) {
|
|
7198
7296
|
s7 = void 0;
|
|
7199
7297
|
}
|
|
@@ -7204,7 +7302,7 @@ function peg$parse(input, options) {
|
|
|
7204
7302
|
s8 = peg$parsetableContents();
|
|
7205
7303
|
if (s8 !== peg$FAILED) {
|
|
7206
7304
|
peg$savedPos = s0;
|
|
7207
|
-
s1 = peg$
|
|
7305
|
+
s1 = peg$c184(s1, s3, s8);
|
|
7208
7306
|
s0 = s1;
|
|
7209
7307
|
}
|
|
7210
7308
|
else {
|
|
@@ -7348,7 +7446,7 @@ function peg$parse(input, options) {
|
|
|
7348
7446
|
}
|
|
7349
7447
|
if (s6 !== peg$FAILED) {
|
|
7350
7448
|
peg$savedPos = s0;
|
|
7351
|
-
s1 = peg$
|
|
7449
|
+
s1 = peg$c185(s1, s3, s5, s6);
|
|
7352
7450
|
s0 = s1;
|
|
7353
7451
|
}
|
|
7354
7452
|
else {
|
|
@@ -7398,14 +7496,14 @@ function peg$parse(input, options) {
|
|
|
7398
7496
|
s4 = peg$currPos;
|
|
7399
7497
|
s5 = peg$parse_();
|
|
7400
7498
|
if (s5 !== peg$FAILED) {
|
|
7401
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7402
|
-
s6 = peg$
|
|
7499
|
+
if (input.substr(peg$currPos, 2) === peg$c186) {
|
|
7500
|
+
s6 = peg$c186;
|
|
7403
7501
|
peg$currPos += 2;
|
|
7404
7502
|
}
|
|
7405
7503
|
else {
|
|
7406
7504
|
s6 = peg$FAILED;
|
|
7407
7505
|
if (peg$silentFails === 0) {
|
|
7408
|
-
peg$fail(peg$
|
|
7506
|
+
peg$fail(peg$c187);
|
|
7409
7507
|
}
|
|
7410
7508
|
}
|
|
7411
7509
|
if (s6 !== peg$FAILED) {
|
|
@@ -7428,7 +7526,7 @@ function peg$parse(input, options) {
|
|
|
7428
7526
|
s10 = peg$parsenewline();
|
|
7429
7527
|
if (s10 !== peg$FAILED) {
|
|
7430
7528
|
peg$savedPos = s4;
|
|
7431
|
-
s5 = peg$
|
|
7529
|
+
s5 = peg$c117(s1, s8);
|
|
7432
7530
|
s4 = s5;
|
|
7433
7531
|
}
|
|
7434
7532
|
else {
|
|
@@ -7465,14 +7563,14 @@ function peg$parse(input, options) {
|
|
|
7465
7563
|
s4 = peg$currPos;
|
|
7466
7564
|
s5 = peg$parse_();
|
|
7467
7565
|
if (s5 !== peg$FAILED) {
|
|
7468
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7469
|
-
s6 = peg$
|
|
7566
|
+
if (input.substr(peg$currPos, 2) === peg$c186) {
|
|
7567
|
+
s6 = peg$c186;
|
|
7470
7568
|
peg$currPos += 2;
|
|
7471
7569
|
}
|
|
7472
7570
|
else {
|
|
7473
7571
|
s6 = peg$FAILED;
|
|
7474
7572
|
if (peg$silentFails === 0) {
|
|
7475
|
-
peg$fail(peg$
|
|
7573
|
+
peg$fail(peg$c187);
|
|
7476
7574
|
}
|
|
7477
7575
|
}
|
|
7478
7576
|
if (s6 !== peg$FAILED) {
|
|
@@ -7495,7 +7593,7 @@ function peg$parse(input, options) {
|
|
|
7495
7593
|
s10 = peg$parsenewline();
|
|
7496
7594
|
if (s10 !== peg$FAILED) {
|
|
7497
7595
|
peg$savedPos = s4;
|
|
7498
|
-
s5 = peg$
|
|
7596
|
+
s5 = peg$c117(s1, s8);
|
|
7499
7597
|
s4 = s5;
|
|
7500
7598
|
}
|
|
7501
7599
|
else {
|
|
@@ -7530,7 +7628,7 @@ function peg$parse(input, options) {
|
|
|
7530
7628
|
}
|
|
7531
7629
|
if (s3 !== peg$FAILED) {
|
|
7532
7630
|
peg$savedPos = s0;
|
|
7533
|
-
s1 = peg$
|
|
7631
|
+
s1 = peg$c188(s1, s3);
|
|
7534
7632
|
s0 = s1;
|
|
7535
7633
|
}
|
|
7536
7634
|
else {
|
|
@@ -7569,7 +7667,7 @@ function peg$parse(input, options) {
|
|
|
7569
7667
|
s3 = peg$parseEOL();
|
|
7570
7668
|
if (s3 !== peg$FAILED) {
|
|
7571
7669
|
peg$savedPos = s0;
|
|
7572
|
-
s1 = peg$
|
|
7670
|
+
s1 = peg$c189(s1);
|
|
7573
7671
|
s0 = s1;
|
|
7574
7672
|
}
|
|
7575
7673
|
else {
|
|
@@ -7594,13 +7692,13 @@ function peg$parse(input, options) {
|
|
|
7594
7692
|
s1 = peg$parse_();
|
|
7595
7693
|
if (s1 !== peg$FAILED) {
|
|
7596
7694
|
if (input.charCodeAt(peg$currPos) === 58) {
|
|
7597
|
-
s2 = peg$
|
|
7695
|
+
s2 = peg$c56;
|
|
7598
7696
|
peg$currPos++;
|
|
7599
7697
|
}
|
|
7600
7698
|
else {
|
|
7601
7699
|
s2 = peg$FAILED;
|
|
7602
7700
|
if (peg$silentFails === 0) {
|
|
7603
|
-
peg$fail(peg$
|
|
7701
|
+
peg$fail(peg$c57);
|
|
7604
7702
|
}
|
|
7605
7703
|
}
|
|
7606
7704
|
if (s2 !== peg$FAILED) {
|
|
@@ -7710,7 +7808,7 @@ function peg$parse(input, options) {
|
|
|
7710
7808
|
s6 = peg$parseEOL();
|
|
7711
7809
|
if (s6 !== peg$FAILED) {
|
|
7712
7810
|
peg$savedPos = s0;
|
|
7713
|
-
s1 = peg$
|
|
7811
|
+
s1 = peg$c190(s3, s5);
|
|
7714
7812
|
s0 = s1;
|
|
7715
7813
|
}
|
|
7716
7814
|
else {
|
|
@@ -7860,7 +7958,7 @@ function peg$parse(input, options) {
|
|
|
7860
7958
|
s5 = peg$parseEOL();
|
|
7861
7959
|
if (s5 !== peg$FAILED) {
|
|
7862
7960
|
peg$savedPos = s3;
|
|
7863
|
-
s4 = peg$
|
|
7961
|
+
s4 = peg$c191(s4);
|
|
7864
7962
|
s3 = s4;
|
|
7865
7963
|
}
|
|
7866
7964
|
else {
|
|
@@ -7875,7 +7973,7 @@ function peg$parse(input, options) {
|
|
|
7875
7973
|
}
|
|
7876
7974
|
if (s3 !== peg$FAILED) {
|
|
7877
7975
|
peg$savedPos = s0;
|
|
7878
|
-
s1 = peg$
|
|
7976
|
+
s1 = peg$c192(s3);
|
|
7879
7977
|
s0 = s1;
|
|
7880
7978
|
}
|
|
7881
7979
|
else {
|
|
@@ -7906,14 +8004,14 @@ function peg$parse(input, options) {
|
|
|
7906
8004
|
s1 = s2;
|
|
7907
8005
|
}
|
|
7908
8006
|
if (s1 !== peg$FAILED) {
|
|
7909
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
7910
|
-
s2 = peg$
|
|
8007
|
+
if (input.substr(peg$currPos, 4) === peg$c193) {
|
|
8008
|
+
s2 = peg$c193;
|
|
7911
8009
|
peg$currPos += 4;
|
|
7912
8010
|
}
|
|
7913
8011
|
else {
|
|
7914
8012
|
s2 = peg$FAILED;
|
|
7915
8013
|
if (peg$silentFails === 0) {
|
|
7916
|
-
peg$fail(peg$
|
|
8014
|
+
peg$fail(peg$c194);
|
|
7917
8015
|
}
|
|
7918
8016
|
}
|
|
7919
8017
|
if (s2 !== peg$FAILED) {
|
|
@@ -7942,7 +8040,7 @@ function peg$parse(input, options) {
|
|
|
7942
8040
|
}
|
|
7943
8041
|
if (s5 !== peg$FAILED) {
|
|
7944
8042
|
peg$savedPos = s0;
|
|
7945
|
-
s1 = peg$
|
|
8043
|
+
s1 = peg$c195(s1, s4, s5);
|
|
7946
8044
|
s0 = s1;
|
|
7947
8045
|
}
|
|
7948
8046
|
else {
|
|
@@ -8010,7 +8108,7 @@ function peg$parse(input, options) {
|
|
|
8010
8108
|
s6 = peg$parsealias_replacement_text();
|
|
8011
8109
|
if (s6 !== peg$FAILED) {
|
|
8012
8110
|
peg$savedPos = s0;
|
|
8013
|
-
s1 = peg$
|
|
8111
|
+
s1 = peg$c196(s1, s2, s4, s6);
|
|
8014
8112
|
s0 = s1;
|
|
8015
8113
|
}
|
|
8016
8114
|
else {
|
|
@@ -8071,25 +8169,25 @@ function peg$parse(input, options) {
|
|
|
8071
8169
|
if (s3 !== peg$FAILED) {
|
|
8072
8170
|
s4 = peg$currPos;
|
|
8073
8171
|
s5 = peg$currPos;
|
|
8074
|
-
if (peg$
|
|
8172
|
+
if (peg$c197.test(input.charAt(peg$currPos))) {
|
|
8075
8173
|
s6 = input.charAt(peg$currPos);
|
|
8076
8174
|
peg$currPos++;
|
|
8077
8175
|
}
|
|
8078
8176
|
else {
|
|
8079
8177
|
s6 = peg$FAILED;
|
|
8080
8178
|
if (peg$silentFails === 0) {
|
|
8081
|
-
peg$fail(peg$
|
|
8179
|
+
peg$fail(peg$c198);
|
|
8082
8180
|
}
|
|
8083
8181
|
}
|
|
8084
8182
|
if (s6 !== peg$FAILED) {
|
|
8085
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
8086
|
-
s7 = peg$
|
|
8183
|
+
if (input.substr(peg$currPos, 2) === peg$c199) {
|
|
8184
|
+
s7 = peg$c199;
|
|
8087
8185
|
peg$currPos += 2;
|
|
8088
8186
|
}
|
|
8089
8187
|
else {
|
|
8090
8188
|
s7 = peg$FAILED;
|
|
8091
8189
|
if (peg$silentFails === 0) {
|
|
8092
|
-
peg$fail(peg$
|
|
8190
|
+
peg$fail(peg$c200);
|
|
8093
8191
|
}
|
|
8094
8192
|
}
|
|
8095
8193
|
if (s7 !== peg$FAILED) {
|
|
@@ -8120,7 +8218,7 @@ function peg$parse(input, options) {
|
|
|
8120
8218
|
s6 = peg$parsepod_configuration();
|
|
8121
8219
|
if (s6 !== peg$FAILED) {
|
|
8122
8220
|
peg$savedPos = s0;
|
|
8123
|
-
s1 = peg$
|
|
8221
|
+
s1 = peg$c201(s1, s2, s4, s6);
|
|
8124
8222
|
s0 = s1;
|
|
8125
8223
|
}
|
|
8126
8224
|
else {
|
|
@@ -8166,14 +8264,14 @@ function peg$parse(input, options) {
|
|
|
8166
8264
|
s1 = s2;
|
|
8167
8265
|
}
|
|
8168
8266
|
if (s1 !== peg$FAILED) {
|
|
8169
|
-
if (input.substr(peg$currPos, 9) === peg$
|
|
8170
|
-
s2 = peg$
|
|
8267
|
+
if (input.substr(peg$currPos, 9) === peg$c202) {
|
|
8268
|
+
s2 = peg$c202;
|
|
8171
8269
|
peg$currPos += 9;
|
|
8172
8270
|
}
|
|
8173
8271
|
else {
|
|
8174
8272
|
s2 = peg$FAILED;
|
|
8175
8273
|
if (peg$silentFails === 0) {
|
|
8176
|
-
peg$fail(peg$
|
|
8274
|
+
peg$fail(peg$c203);
|
|
8177
8275
|
}
|
|
8178
8276
|
}
|
|
8179
8277
|
if (s2 !== peg$FAILED) {
|
|
@@ -8182,7 +8280,7 @@ function peg$parse(input, options) {
|
|
|
8182
8280
|
s4 = peg$parsepod_configuration();
|
|
8183
8281
|
if (s4 !== peg$FAILED) {
|
|
8184
8282
|
peg$savedPos = s0;
|
|
8185
|
-
s1 = peg$
|
|
8283
|
+
s1 = peg$c204(s1, s2, s4);
|
|
8186
8284
|
s0 = s1;
|
|
8187
8285
|
}
|
|
8188
8286
|
else {
|
|
@@ -8227,7 +8325,7 @@ function peg$parse(input, options) {
|
|
|
8227
8325
|
s5 = peg$parsepod_configuration();
|
|
8228
8326
|
if (s5 !== peg$FAILED) {
|
|
8229
8327
|
peg$savedPos = peg$currPos;
|
|
8230
|
-
s6 = peg$
|
|
8328
|
+
s6 = peg$c205(s1, s2, s3, s5);
|
|
8231
8329
|
if (s6) {
|
|
8232
8330
|
s6 = void 0;
|
|
8233
8331
|
}
|
|
@@ -8250,7 +8348,7 @@ function peg$parse(input, options) {
|
|
|
8250
8348
|
s10 = peg$FAILED;
|
|
8251
8349
|
}
|
|
8252
8350
|
if (s10 !== peg$FAILED) {
|
|
8253
|
-
s11 = peg$
|
|
8351
|
+
s11 = peg$parseplain_line();
|
|
8254
8352
|
if (s11 !== peg$FAILED) {
|
|
8255
8353
|
s10 = [s10, s11];
|
|
8256
8354
|
s9 = s10;
|
|
@@ -8279,7 +8377,7 @@ function peg$parse(input, options) {
|
|
|
8279
8377
|
s10 = peg$FAILED;
|
|
8280
8378
|
}
|
|
8281
8379
|
if (s10 !== peg$FAILED) {
|
|
8282
|
-
s11 = peg$
|
|
8380
|
+
s11 = peg$parseplain_line();
|
|
8283
8381
|
if (s11 !== peg$FAILED) {
|
|
8284
8382
|
s10 = [s10, s11];
|
|
8285
8383
|
s9 = s10;
|
|
@@ -8302,7 +8400,7 @@ function peg$parse(input, options) {
|
|
|
8302
8400
|
}
|
|
8303
8401
|
if (s7 !== peg$FAILED) {
|
|
8304
8402
|
peg$savedPos = s0;
|
|
8305
|
-
s1 = peg$
|
|
8403
|
+
s1 = peg$c206(s1, s2, s3, s5, s7);
|
|
8306
8404
|
s0 = s1;
|
|
8307
8405
|
}
|
|
8308
8406
|
else {
|
|
@@ -8362,7 +8460,7 @@ function peg$parse(input, options) {
|
|
|
8362
8460
|
s5 = peg$parsepod_configuration();
|
|
8363
8461
|
if (s5 !== peg$FAILED) {
|
|
8364
8462
|
peg$savedPos = peg$currPos;
|
|
8365
|
-
s6 = peg$
|
|
8463
|
+
s6 = peg$c207(s1, s2, s3, s5);
|
|
8366
8464
|
if (s6) {
|
|
8367
8465
|
s6 = void 0;
|
|
8368
8466
|
}
|
|
@@ -8371,7 +8469,7 @@ function peg$parse(input, options) {
|
|
|
8371
8469
|
}
|
|
8372
8470
|
if (s6 !== peg$FAILED) {
|
|
8373
8471
|
peg$savedPos = peg$currPos;
|
|
8374
|
-
s7 = peg$
|
|
8472
|
+
s7 = peg$c208(s1, s2, s3, s5);
|
|
8375
8473
|
if (s7) {
|
|
8376
8474
|
s7 = void 0;
|
|
8377
8475
|
}
|
|
@@ -8382,7 +8480,7 @@ function peg$parse(input, options) {
|
|
|
8382
8480
|
s8 = peg$parsetableContents();
|
|
8383
8481
|
if (s8 !== peg$FAILED) {
|
|
8384
8482
|
peg$savedPos = s0;
|
|
8385
|
-
s1 = peg$
|
|
8483
|
+
s1 = peg$c209(s1, s2, s3, s5, s8);
|
|
8386
8484
|
s0 = s1;
|
|
8387
8485
|
}
|
|
8388
8486
|
else {
|
|
@@ -8513,7 +8611,7 @@ function peg$parse(input, options) {
|
|
|
8513
8611
|
}
|
|
8514
8612
|
if (s6 !== peg$FAILED) {
|
|
8515
8613
|
peg$savedPos = s0;
|
|
8516
|
-
s1 = peg$
|
|
8614
|
+
s1 = peg$c210(s1, s2, s3, s5, s6);
|
|
8517
8615
|
s0 = s1;
|
|
8518
8616
|
}
|
|
8519
8617
|
else {
|
|
@@ -8551,38 +8649,38 @@ function peg$parse(input, options) {
|
|
|
8551
8649
|
var s0, s1, s2, s3, s4;
|
|
8552
8650
|
s0 = peg$currPos;
|
|
8553
8651
|
s1 = peg$currPos;
|
|
8554
|
-
if (peg$
|
|
8652
|
+
if (peg$c211.test(input.charAt(peg$currPos))) {
|
|
8555
8653
|
s2 = input.charAt(peg$currPos);
|
|
8556
8654
|
peg$currPos++;
|
|
8557
8655
|
}
|
|
8558
8656
|
else {
|
|
8559
8657
|
s2 = peg$FAILED;
|
|
8560
8658
|
if (peg$silentFails === 0) {
|
|
8561
|
-
peg$fail(peg$
|
|
8659
|
+
peg$fail(peg$c212);
|
|
8562
8660
|
}
|
|
8563
8661
|
}
|
|
8564
8662
|
if (s2 !== peg$FAILED) {
|
|
8565
8663
|
s3 = [];
|
|
8566
|
-
if (peg$
|
|
8664
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
8567
8665
|
s4 = input.charAt(peg$currPos);
|
|
8568
8666
|
peg$currPos++;
|
|
8569
8667
|
}
|
|
8570
8668
|
else {
|
|
8571
8669
|
s4 = peg$FAILED;
|
|
8572
8670
|
if (peg$silentFails === 0) {
|
|
8573
|
-
peg$fail(peg$
|
|
8671
|
+
peg$fail(peg$c48);
|
|
8574
8672
|
}
|
|
8575
8673
|
}
|
|
8576
8674
|
while (s4 !== peg$FAILED) {
|
|
8577
8675
|
s3.push(s4);
|
|
8578
|
-
if (peg$
|
|
8676
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
8579
8677
|
s4 = input.charAt(peg$currPos);
|
|
8580
8678
|
peg$currPos++;
|
|
8581
8679
|
}
|
|
8582
8680
|
else {
|
|
8583
8681
|
s4 = peg$FAILED;
|
|
8584
8682
|
if (peg$silentFails === 0) {
|
|
8585
|
-
peg$fail(peg$
|
|
8683
|
+
peg$fail(peg$c48);
|
|
8586
8684
|
}
|
|
8587
8685
|
}
|
|
8588
8686
|
}
|
|
@@ -8611,26 +8709,26 @@ function peg$parse(input, options) {
|
|
|
8611
8709
|
var s0, s1;
|
|
8612
8710
|
peg$silentFails++;
|
|
8613
8711
|
s0 = [];
|
|
8614
|
-
if (peg$
|
|
8712
|
+
if (peg$c214.test(input.charAt(peg$currPos))) {
|
|
8615
8713
|
s1 = input.charAt(peg$currPos);
|
|
8616
8714
|
peg$currPos++;
|
|
8617
8715
|
}
|
|
8618
8716
|
else {
|
|
8619
8717
|
s1 = peg$FAILED;
|
|
8620
8718
|
if (peg$silentFails === 0) {
|
|
8621
|
-
peg$fail(peg$
|
|
8719
|
+
peg$fail(peg$c215);
|
|
8622
8720
|
}
|
|
8623
8721
|
}
|
|
8624
8722
|
while (s1 !== peg$FAILED) {
|
|
8625
8723
|
s0.push(s1);
|
|
8626
|
-
if (peg$
|
|
8724
|
+
if (peg$c214.test(input.charAt(peg$currPos))) {
|
|
8627
8725
|
s1 = input.charAt(peg$currPos);
|
|
8628
8726
|
peg$currPos++;
|
|
8629
8727
|
}
|
|
8630
8728
|
else {
|
|
8631
8729
|
s1 = peg$FAILED;
|
|
8632
8730
|
if (peg$silentFails === 0) {
|
|
8633
|
-
peg$fail(peg$
|
|
8731
|
+
peg$fail(peg$c215);
|
|
8634
8732
|
}
|
|
8635
8733
|
}
|
|
8636
8734
|
}
|
|
@@ -8638,7 +8736,7 @@ function peg$parse(input, options) {
|
|
|
8638
8736
|
if (s0 === peg$FAILED) {
|
|
8639
8737
|
s1 = peg$FAILED;
|
|
8640
8738
|
if (peg$silentFails === 0) {
|
|
8641
|
-
peg$fail(peg$
|
|
8739
|
+
peg$fail(peg$c213);
|
|
8642
8740
|
}
|
|
8643
8741
|
}
|
|
8644
8742
|
return s0;
|
|
@@ -8647,26 +8745,26 @@ function peg$parse(input, options) {
|
|
|
8647
8745
|
var s0, s1;
|
|
8648
8746
|
peg$silentFails++;
|
|
8649
8747
|
s0 = [];
|
|
8650
|
-
if (peg$
|
|
8748
|
+
if (peg$c214.test(input.charAt(peg$currPos))) {
|
|
8651
8749
|
s1 = input.charAt(peg$currPos);
|
|
8652
8750
|
peg$currPos++;
|
|
8653
8751
|
}
|
|
8654
8752
|
else {
|
|
8655
8753
|
s1 = peg$FAILED;
|
|
8656
8754
|
if (peg$silentFails === 0) {
|
|
8657
|
-
peg$fail(peg$
|
|
8755
|
+
peg$fail(peg$c215);
|
|
8658
8756
|
}
|
|
8659
8757
|
}
|
|
8660
8758
|
while (s1 !== peg$FAILED) {
|
|
8661
8759
|
s0.push(s1);
|
|
8662
|
-
if (peg$
|
|
8760
|
+
if (peg$c214.test(input.charAt(peg$currPos))) {
|
|
8663
8761
|
s1 = input.charAt(peg$currPos);
|
|
8664
8762
|
peg$currPos++;
|
|
8665
8763
|
}
|
|
8666
8764
|
else {
|
|
8667
8765
|
s1 = peg$FAILED;
|
|
8668
8766
|
if (peg$silentFails === 0) {
|
|
8669
|
-
peg$fail(peg$
|
|
8767
|
+
peg$fail(peg$c215);
|
|
8670
8768
|
}
|
|
8671
8769
|
}
|
|
8672
8770
|
}
|
|
@@ -8674,7 +8772,7 @@ function peg$parse(input, options) {
|
|
|
8674
8772
|
if (s0 === peg$FAILED) {
|
|
8675
8773
|
s1 = peg$FAILED;
|
|
8676
8774
|
if (peg$silentFails === 0) {
|
|
8677
|
-
peg$fail(peg$
|
|
8775
|
+
peg$fail(peg$c216);
|
|
8678
8776
|
}
|
|
8679
8777
|
}
|
|
8680
8778
|
return s0;
|
|
@@ -8685,6 +8783,12 @@ function peg$parse(input, options) {
|
|
|
8685
8783
|
&&
|
|
8686
8784
|
name !== name.toUpperCase());
|
|
8687
8785
|
}
|
|
8786
|
+
// the body of these blocks is kept as written
|
|
8787
|
+
function isRawBlock(name) {
|
|
8788
|
+
return (Boolean(name.match(/code|comment|formula|output|input|markdown|picture|toc|data|fixture|assert|resource/))
|
|
8789
|
+
||
|
|
8790
|
+
isNamedBlock(name));
|
|
8791
|
+
}
|
|
8688
8792
|
// the following names: =AUTHOR =DESCRIPTION are reserved
|
|
8689
8793
|
function isSemanticBlock(name) {
|
|
8690
8794
|
return name === name.toUpperCase();
|
|
@@ -8709,6 +8813,31 @@ function peg$parse(input, options) {
|
|
|
8709
8813
|
options.diagnostics.push({ severity: 'warning', code: code || 'value-unreadable', message, location });
|
|
8710
8814
|
}
|
|
8711
8815
|
}
|
|
8816
|
+
// Opt-in and separate from the diagnostics: a line naming a block this
|
|
8817
|
+
// parser does not know is ordinary text for every other reader.
|
|
8818
|
+
function noteRecognition(options, event) {
|
|
8819
|
+
if (!options || !Array.isArray(options.recognition))
|
|
8820
|
+
return;
|
|
8821
|
+
const seen = options.recognition.some(e => e.kind === event.kind && e.location.start.offset === event.location.start.offset);
|
|
8822
|
+
if (!seen)
|
|
8823
|
+
options.recognition.push(event);
|
|
8824
|
+
}
|
|
8825
|
+
function noteUnknownDirective(options, line, location) {
|
|
8826
|
+
const marked = line.match(/^[ \t]*=(begin|for|end)[ \t]+([a-zA-Z][a-zA-Z0-9_-]*)/);
|
|
8827
|
+
// a marker with no name, or with one no block can have, opens nothing
|
|
8828
|
+
if (!marked && /^[ \t]*=(begin|for|end)([ \t\r\n]|$)/.test(line)) {
|
|
8829
|
+
noteRecognition(options, { kind: 'unreadable-directive', location });
|
|
8830
|
+
return;
|
|
8831
|
+
}
|
|
8832
|
+
const bare = marked ? null : line.match(/^[ \t]*=([a-zA-Z][a-zA-Z0-9_-]*)/);
|
|
8833
|
+
const marker = marked ? marked[1] : 'abbreviated';
|
|
8834
|
+
const name = marked ? marked[2] : bare && bare[1];
|
|
8835
|
+
if (!name || isSupportedBlockName(name))
|
|
8836
|
+
return;
|
|
8837
|
+
if (!marked && ['begin', 'for', 'end', 'config', 'alias'].includes(name))
|
|
8838
|
+
return;
|
|
8839
|
+
noteRecognition(options, { kind: 'unknown-directive', marker, name, location });
|
|
8840
|
+
}
|
|
8712
8841
|
function keepReadable(attrs) {
|
|
8713
8842
|
return attrs.filter(a => !a.dropped);
|
|
8714
8843
|
}
|
|
@@ -8716,12 +8845,14 @@ function peg$parse(input, options) {
|
|
|
8716
8845
|
// direct call and is kept equal to it by a test
|
|
8717
8846
|
function knownBlockNames() {
|
|
8718
8847
|
return (options && options.blockNames) || [
|
|
8848
|
+
'assert',
|
|
8719
8849
|
'boundary',
|
|
8720
8850
|
'code',
|
|
8721
8851
|
'comment',
|
|
8722
8852
|
'data',
|
|
8723
8853
|
'data-table',
|
|
8724
8854
|
'defn',
|
|
8855
|
+
'fixture',
|
|
8725
8856
|
'formula',
|
|
8726
8857
|
'head',
|
|
8727
8858
|
'include',
|
|
@@ -8733,10 +8864,12 @@ function peg$parse(input, options) {
|
|
|
8733
8864
|
'para',
|
|
8734
8865
|
'picture',
|
|
8735
8866
|
'pod',
|
|
8867
|
+
'resource',
|
|
8736
8868
|
'row',
|
|
8737
8869
|
'cell',
|
|
8738
8870
|
'set',
|
|
8739
8871
|
'table',
|
|
8872
|
+
'test',
|
|
8740
8873
|
'toc',
|
|
8741
8874
|
];
|
|
8742
8875
|
}
|
|
@@ -8756,7 +8889,8 @@ function peg$parse(input, options) {
|
|
|
8756
8889
|
if (string.indexOf(vmargin) == 0) {
|
|
8757
8890
|
return string.replace(vmargin, '');
|
|
8758
8891
|
}
|
|
8759
|
-
|
|
8892
|
+
// a line indented less than the margin loses its indent, not its line break
|
|
8893
|
+
return string.replace(/^[^\S\r\n]+/, '');
|
|
8760
8894
|
}
|
|
8761
8895
|
peg$result = peg$startRuleFunction();
|
|
8762
8896
|
if (peg$result !== peg$FAILED && peg$currPos === input.length) {
|