@env-spec/parser 0.3.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,6 +1,6 @@
1
1
  'use strict';
2
2
 
3
- var chunkKJP2NVDR_js = require('./chunk-KJP2NVDR.js');
3
+ var chunkEWY3F3XT_js = require('./chunk-EWY3F3XT.js');
4
4
 
5
5
  // src/updater.ts
6
6
  function ensureHeader(file, newHeaderContents) {
@@ -8,17 +8,17 @@ function ensureHeader(file, newHeaderContents) {
8
8
  newHeaderContents ||= "This env file uses @env-spec - see https://varlock.dev/env-spec for more info\n";
9
9
  file.contents.unshift(
10
10
  // header is any comment block(s) before the first config item; we add a divider for clarity
11
- new chunkKJP2NVDR_js.ParsedEnvSpecCommentBlock({
11
+ new chunkEWY3F3XT_js.ParsedEnvSpecCommentBlock({
12
12
  // we'll break up the passed in content and add a comment line for each
13
- comments: newHeaderContents.split("\n").map((line) => new chunkKJP2NVDR_js.ParsedEnvSpecComment({ contents: line, leadingSpace: " " })),
14
- divider: new chunkKJP2NVDR_js.ParsedEnvSpecDivider({ contents: "----------", leadingSpace: " " })
13
+ comments: newHeaderContents.split("\n").map((line) => new chunkEWY3F3XT_js.ParsedEnvSpecComment({ contents: line, leadingSpace: " " })),
14
+ divider: new chunkEWY3F3XT_js.ParsedEnvSpecDivider({ contents: "----------", leadingSpace: " " })
15
15
  }),
16
- new chunkKJP2NVDR_js.ParsedEnvSpecBlankLine({})
16
+ new chunkEWY3F3XT_js.ParsedEnvSpecBlankLine({})
17
17
  // add extra blank line after header
18
18
  );
19
19
  }
20
20
  }
21
- chunkKJP2NVDR_js.__name(ensureHeader, "ensureHeader");
21
+ chunkEWY3F3XT_js.__name(ensureHeader, "ensureHeader");
22
22
  function createDummyDecoratorNode(decoratorName, valueStr, opts) {
23
23
  let decStr = `@${decoratorName}`;
24
24
  if (opts?.bareFnArgs) decStr += `(${valueStr})`;
@@ -31,7 +31,7 @@ function createDummyDecoratorNode(decoratorName, valueStr, opts) {
31
31
  if (!newDecNode) throw new Error("Creating new decorator failed");
32
32
  return newDecNode;
33
33
  }
34
- chunkKJP2NVDR_js.__name(createDummyDecoratorNode, "createDummyDecoratorNode");
34
+ chunkEWY3F3XT_js.__name(createDummyDecoratorNode, "createDummyDecoratorNode");
35
35
  function setRootDecorator(file, decoratorName, valueStr, opts) {
36
36
  ensureHeader(file);
37
37
  const newDecNode = createDummyDecoratorNode(decoratorName, valueStr, opts);
@@ -42,10 +42,10 @@ function setRootDecorator(file, decoratorName, valueStr, opts) {
42
42
  if (!file.header) throw new Error("No header found");
43
43
  const lastComment = file.header.data.comments[file.header.data.comments.length - 1];
44
44
  let decCommentLine;
45
- if (lastComment instanceof chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
45
+ if (lastComment instanceof chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
46
46
  decCommentLine = lastComment;
47
47
  } else {
48
- decCommentLine = new chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment({
48
+ decCommentLine = new chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment({
49
49
  decorators: [],
50
50
  leadingSpace: " ",
51
51
  ...opts?.comment && { postComment: `# ${opts.comment}` }
@@ -55,11 +55,11 @@ function setRootDecorator(file, decoratorName, valueStr, opts) {
55
55
  decCommentLine.decorators.push(newDecNode);
56
56
  }
57
57
  }
58
- chunkKJP2NVDR_js.__name(setRootDecorator, "setRootDecorator");
58
+ chunkEWY3F3XT_js.__name(setRootDecorator, "setRootDecorator");
59
59
  function setItemDecorator(file, key, decoratorName, valueStr, opts) {
60
60
  let item = file.configItems.find((i) => i.key === key);
61
61
  if (!item) {
62
- item = new chunkKJP2NVDR_js.ParsedEnvSpecConfigItem({
62
+ item = new chunkEWY3F3XT_js.ParsedEnvSpecConfigItem({
63
63
  key,
64
64
  value: void 0,
65
65
  preComments: [],
@@ -74,10 +74,10 @@ function setItemDecorator(file, key, decoratorName, valueStr, opts) {
74
74
  } else {
75
75
  const lastComment = item.data.preComments[item.data.preComments.length - 1];
76
76
  let decCommentLine;
77
- if (lastComment instanceof chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
77
+ if (lastComment instanceof chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
78
78
  decCommentLine = lastComment;
79
79
  } else {
80
- decCommentLine = new chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment({
80
+ decCommentLine = new chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment({
81
81
  decorators: [],
82
82
  leadingSpace: " "
83
83
  });
@@ -86,7 +86,7 @@ function setItemDecorator(file, key, decoratorName, valueStr, opts) {
86
86
  decCommentLine.decorators.push(newDecNode);
87
87
  }
88
88
  }
89
- chunkKJP2NVDR_js.__name(setItemDecorator, "setItemDecorator");
89
+ chunkEWY3F3XT_js.__name(setItemDecorator, "setItemDecorator");
90
90
  function injectFromStr(file, content, opts) {
91
91
  const parsed = parseEnvSpecDotEnvFile(content);
92
92
  let injectIndex = file.contents.length;
@@ -107,14 +107,14 @@ function injectFromStr(file, content, opts) {
107
107
  }
108
108
  file.contents.splice(injectIndex, 0, ...parsed.contents);
109
109
  }
110
- chunkKJP2NVDR_js.__name(injectFromStr, "injectFromStr");
110
+ chunkEWY3F3XT_js.__name(injectFromStr, "injectFromStr");
111
111
  function deleteItem(file, key) {
112
112
  const item = file.configItems.find((i) => i.key === key);
113
113
  if (item) {
114
114
  file.contents.splice(file.contents.indexOf(item), 1);
115
115
  }
116
116
  }
117
- chunkKJP2NVDR_js.__name(deleteItem, "deleteItem");
117
+ chunkEWY3F3XT_js.__name(deleteItem, "deleteItem");
118
118
  var envSpecUpdater = {
119
119
  ensureHeader,
120
120
  setRootDecorator,
@@ -126,7 +126,7 @@ var envSpecUpdater = {
126
126
  // src/grammar.js
127
127
  var peg$SyntaxError = class extends SyntaxError {
128
128
  static {
129
- chunkKJP2NVDR_js.__name(this, "peg$SyntaxError");
129
+ chunkEWY3F3XT_js.__name(this, "peg$SyntaxError");
130
130
  }
131
131
  constructor(message, expected, found, location) {
132
132
  super(message);
@@ -163,7 +163,7 @@ var peg$SyntaxError = class extends SyntaxError {
163
163
  function hex(ch) {
164
164
  return ch.codePointAt(0).toString(16).toUpperCase();
165
165
  }
166
- chunkKJP2NVDR_js.__name(hex, "hex");
166
+ chunkEWY3F3XT_js.__name(hex, "hex");
167
167
  const nonPrintable = Object.prototype.hasOwnProperty.call(RegExp.prototype, "unicode") ? new RegExp("[\\p{C}\\p{Mn}\\p{Mc}]", "gu") : null;
168
168
  function unicodeEscape(s) {
169
169
  if (nonPrintable) {
@@ -171,15 +171,15 @@ var peg$SyntaxError = class extends SyntaxError {
171
171
  }
172
172
  return s;
173
173
  }
174
- chunkKJP2NVDR_js.__name(unicodeEscape, "unicodeEscape");
174
+ chunkEWY3F3XT_js.__name(unicodeEscape, "unicodeEscape");
175
175
  function literalEscape(s) {
176
176
  return unicodeEscape(s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, (ch) => "\\x0" + hex(ch)).replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => "\\x" + hex(ch)));
177
177
  }
178
- chunkKJP2NVDR_js.__name(literalEscape, "literalEscape");
178
+ chunkEWY3F3XT_js.__name(literalEscape, "literalEscape");
179
179
  function classEscape(s) {
180
180
  return unicodeEscape(s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, (ch) => "\\x0" + hex(ch)).replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => "\\x" + hex(ch)));
181
181
  }
182
- chunkKJP2NVDR_js.__name(classEscape, "classEscape");
182
+ chunkEWY3F3XT_js.__name(classEscape, "classEscape");
183
183
  const DESCRIBE_EXPECTATION_FNS = {
184
184
  literal(expectation) {
185
185
  return '"' + literalEscape(expectation.text) + '"';
@@ -203,7 +203,7 @@ var peg$SyntaxError = class extends SyntaxError {
203
203
  function describeExpectation(expectation) {
204
204
  return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
205
205
  }
206
- chunkKJP2NVDR_js.__name(describeExpectation, "describeExpectation");
206
+ chunkEWY3F3XT_js.__name(describeExpectation, "describeExpectation");
207
207
  function describeExpected(expected2) {
208
208
  const descriptions = expected2.map(describeExpectation);
209
209
  descriptions.sort();
@@ -226,11 +226,11 @@ var peg$SyntaxError = class extends SyntaxError {
226
226
  return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
227
227
  }
228
228
  }
229
- chunkKJP2NVDR_js.__name(describeExpected, "describeExpected");
229
+ chunkEWY3F3XT_js.__name(describeExpected, "describeExpected");
230
230
  function describeFound(found2) {
231
231
  return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
232
232
  }
233
- chunkKJP2NVDR_js.__name(describeFound, "describeFound");
233
+ chunkEWY3F3XT_js.__name(describeFound, "describeFound");
234
234
  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
235
235
  }
236
236
  };
@@ -247,36 +247,37 @@ function peg$parse(input, options) {
247
247
  const peg$c2 = "=";
248
248
  const peg$c3 = "#";
249
249
  const peg$c4 = "@";
250
- const peg$c5 = ":";
251
- const peg$c6 = "(";
252
- const peg$c7 = ",";
253
- const peg$c8 = ")";
254
- const peg$c9 = '\\"';
255
- const peg$c10 = "\\'";
256
- const peg$c11 = "\\`";
257
- const peg$c12 = '"""';
258
- const peg$c13 = '\\"""';
259
- const peg$c14 = "```";
260
- const peg$c15 = "\\```";
250
+ const peg$c5 = "(";
251
+ const peg$c6 = ",";
252
+ const peg$c7 = ")";
253
+ const peg$c8 = '\\"';
254
+ const peg$c9 = "\\'";
255
+ const peg$c10 = "\\`";
256
+ const peg$c11 = '"""';
257
+ const peg$c12 = '\\"""';
258
+ const peg$c13 = "```";
259
+ const peg$c14 = "\\```";
261
260
  const peg$r0 = /^[a-zA-Z_]/;
262
261
  const peg$r1 = /^[a-zA-Z0-9_.\-]/;
263
262
  const peg$r2 = /^[^\n]/;
264
- const peg$r3 = /^[a-zA-Z]/;
265
- const peg$r4 = /^[@#]/;
266
- const peg$r5 = /^[a-zA-Z0-9_]/;
267
- const peg$r6 = /^[^ \n,)]/;
268
- const peg$r7 = /^[ \t]/;
269
- const peg$r8 = /^[ \t\n]/;
270
- const peg$r9 = /^[\-=*#]/;
271
- const peg$r10 = /^['"`]/;
272
- const peg$r11 = /^[^#\n]/;
273
- const peg$r12 = /^[^# \n]/;
274
- const peg$r13 = /^["]/;
275
- const peg$r14 = /^[^"\n]/;
276
- const peg$r15 = /^[']/;
277
- const peg$r16 = /^[^'\n]/;
278
- const peg$r17 = /^[`]/;
279
- const peg$r18 = /^[^`\n]/;
263
+ const peg$r3 = /^[^ \t@#\n]/;
264
+ const peg$r4 = /^[^ \t@\n]/;
265
+ const peg$r5 = /^[a-zA-Z]/;
266
+ const peg$r6 = /^[^ \t\n=()#@]/;
267
+ const peg$r7 = /^[^ \n,)]/;
268
+ const peg$r8 = /^[ \t]/;
269
+ const peg$r9 = /^[a-zA-Z0-9_]/;
270
+ const peg$r10 = /^[ \t\n]/;
271
+ const peg$r11 = /^[\-=*#]/;
272
+ const peg$r12 = /^['"`]/;
273
+ const peg$r13 = /^[^#\n]/;
274
+ const peg$r14 = /^[^# \n]/;
275
+ const peg$r15 = /^["]/;
276
+ const peg$r16 = /^[^"\n]/;
277
+ const peg$r17 = /^[']/;
278
+ const peg$r18 = /^[^'\n]/;
279
+ const peg$r19 = /^[`]/;
280
+ const peg$r20 = /^[^`\n]/;
280
281
  const peg$e0 = peg$literalExpectation("\n", false);
281
282
  const peg$e1 = peg$literalExpectation("export ", false);
282
283
  const peg$e2 = peg$literalExpectation("=", false);
@@ -285,44 +286,45 @@ function peg$parse(input, options) {
285
286
  const peg$e5 = peg$literalExpectation("#", false);
286
287
  const peg$e6 = peg$literalExpectation("@", false);
287
288
  const peg$e7 = peg$classExpectation(["\n"], true, false, false);
288
- const peg$e8 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false, false);
289
- const peg$e9 = peg$literalExpectation(":", false);
290
- const peg$e10 = peg$classExpectation(["@", "#"], false, false, false);
291
- const peg$e11 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false, false);
289
+ const peg$e8 = peg$classExpectation([" ", " ", "@", "#", "\n"], true, false, false);
290
+ const peg$e9 = peg$classExpectation([" ", " ", "@", "\n"], true, false, false);
291
+ const peg$e10 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false, false);
292
+ const peg$e11 = peg$classExpectation([" ", " ", "\n", "=", "(", ")", "#", "@"], true, false, false);
292
293
  const peg$e12 = peg$literalExpectation("(", false);
293
294
  const peg$e13 = peg$literalExpectation(",", false);
294
295
  const peg$e14 = peg$literalExpectation(")", false);
295
296
  const peg$e15 = peg$classExpectation([" ", "\n", ",", ")"], true, false, false);
296
297
  const peg$e16 = peg$classExpectation([" ", " "], false, false, false);
297
- const peg$e17 = peg$classExpectation([" ", " ", "\n"], false, false, false);
298
- const peg$e18 = peg$classExpectation(["-", "=", "*", "#"], false, false, false);
299
- const peg$e19 = peg$classExpectation(["'", '"', "`"], false, false, false);
300
- const peg$e20 = peg$classExpectation(["#", "\n"], true, false, false);
301
- const peg$e21 = peg$classExpectation(["#", " ", "\n"], true, false, false);
302
- const peg$e22 = peg$classExpectation(['"'], false, false, false);
303
- const peg$e23 = peg$literalExpectation('\\"', false);
304
- const peg$e24 = peg$classExpectation(['"', "\n"], true, false, false);
305
- const peg$e25 = peg$classExpectation(["'"], false, false, false);
306
- const peg$e26 = peg$literalExpectation("\\'", false);
307
- const peg$e27 = peg$classExpectation(["'", "\n"], true, false, false);
308
- const peg$e28 = peg$classExpectation(["`"], false, false, false);
309
- const peg$e29 = peg$literalExpectation("\\`", false);
310
- const peg$e30 = peg$classExpectation(["`", "\n"], true, false, false);
311
- const peg$e31 = peg$literalExpectation('"""', false);
312
- const peg$e32 = peg$literalExpectation('\\"""', false);
313
- const peg$e33 = peg$literalExpectation("```", false);
314
- const peg$e34 = peg$literalExpectation("\\```", false);
315
- const peg$e35 = peg$anyExpectation();
298
+ const peg$e17 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false, false);
299
+ const peg$e18 = peg$classExpectation([" ", " ", "\n"], false, false, false);
300
+ const peg$e19 = peg$classExpectation(["-", "=", "*", "#"], false, false, false);
301
+ const peg$e20 = peg$classExpectation(["'", '"', "`"], false, false, false);
302
+ const peg$e21 = peg$classExpectation(["#", "\n"], true, false, false);
303
+ const peg$e22 = peg$classExpectation(["#", " ", "\n"], true, false, false);
304
+ const peg$e23 = peg$classExpectation(['"'], false, false, false);
305
+ const peg$e24 = peg$literalExpectation('\\"', false);
306
+ const peg$e25 = peg$classExpectation(['"', "\n"], true, false, false);
307
+ const peg$e26 = peg$classExpectation(["'"], false, false, false);
308
+ const peg$e27 = peg$literalExpectation("\\'", false);
309
+ const peg$e28 = peg$classExpectation(["'", "\n"], true, false, false);
310
+ const peg$e29 = peg$classExpectation(["`"], false, false, false);
311
+ const peg$e30 = peg$literalExpectation("\\`", false);
312
+ const peg$e31 = peg$classExpectation(["`", "\n"], true, false, false);
313
+ const peg$e32 = peg$literalExpectation('"""', false);
314
+ const peg$e33 = peg$literalExpectation('\\"""', false);
315
+ const peg$e34 = peg$literalExpectation("```", false);
316
+ const peg$e35 = peg$literalExpectation("\\```", false);
317
+ const peg$e36 = peg$anyExpectation();
316
318
  function peg$f0() {
317
- return new chunkKJP2NVDR_js.ParsedEnvSpecBlankLine({ _location: location() });
319
+ return new chunkEWY3F3XT_js.ParsedEnvSpecBlankLine({ _location: location() });
318
320
  }
319
- chunkKJP2NVDR_js.__name(peg$f0, "peg$f0");
321
+ chunkEWY3F3XT_js.__name(peg$f0, "peg$f0");
320
322
  function peg$f1(contents) {
321
- return new chunkKJP2NVDR_js.ParsedEnvSpecFile(contents);
323
+ return new chunkEWY3F3XT_js.ParsedEnvSpecFile(contents);
322
324
  }
323
- chunkKJP2NVDR_js.__name(peg$f1, "peg$f1");
325
+ chunkEWY3F3XT_js.__name(peg$f1, "peg$f1");
324
326
  function peg$f2(preComments, key, value, postComment) {
325
- return new chunkKJP2NVDR_js.ParsedEnvSpecConfigItem({
327
+ return new chunkEWY3F3XT_js.ParsedEnvSpecConfigItem({
326
328
  key,
327
329
  preComments,
328
330
  postComment,
@@ -330,135 +332,145 @@ function peg$parse(input, options) {
330
332
  _location: location()
331
333
  });
332
334
  }
333
- chunkKJP2NVDR_js.__name(peg$f2, "peg$f2");
335
+ chunkEWY3F3XT_js.__name(peg$f2, "peg$f2");
334
336
  function peg$f3(comments, end) {
335
- return new chunkKJP2NVDR_js.ParsedEnvSpecCommentBlock({
337
+ return new chunkEWY3F3XT_js.ParsedEnvSpecCommentBlock({
336
338
  comments,
337
- divider: end instanceof chunkKJP2NVDR_js.ParsedEnvSpecDivider ? end : void 0,
339
+ divider: end instanceof chunkEWY3F3XT_js.ParsedEnvSpecDivider ? end : void 0,
338
340
  _location: location()
339
341
  });
340
342
  }
341
- chunkKJP2NVDR_js.__name(peg$f3, "peg$f3");
343
+ chunkEWY3F3XT_js.__name(peg$f3, "peg$f3");
342
344
  function peg$f4(leadingSpace, contents) {
343
- return new chunkKJP2NVDR_js.ParsedEnvSpecComment({
345
+ return new chunkEWY3F3XT_js.ParsedEnvSpecComment({
344
346
  contents,
345
347
  leadingSpace,
346
348
  _location: location()
347
349
  });
348
350
  }
349
- chunkKJP2NVDR_js.__name(peg$f4, "peg$f4");
350
- function peg$f5(leadingSpace, contents) {
351
- return new chunkKJP2NVDR_js.ParsedEnvSpecComment({ contents, leadingSpace, _location: location() });
352
- }
353
- chunkKJP2NVDR_js.__name(peg$f5, "peg$f5");
354
- function peg$f6(leadingSpace, first, rest, postComment) {
355
- return new chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment({
356
- decorators: [first, ...rest],
351
+ chunkEWY3F3XT_js.__name(peg$f4, "peg$f4");
352
+ function peg$f5(leadingSpace, first, rest, postComment) {
353
+ const allDecorators = [first];
354
+ let lastDecorator = first;
355
+ for (const item of rest) {
356
+ if (item instanceof chunkEWY3F3XT_js.ParsedEnvSpecDecorator) {
357
+ allDecorators.push(item);
358
+ lastDecorator = item;
359
+ } else {
360
+ lastDecorator.data.strayText = item;
361
+ }
362
+ }
363
+ return new chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment({
364
+ decorators: allDecorators,
357
365
  leadingSpace,
358
366
  postComment,
359
367
  _location: location()
360
368
  });
361
369
  }
362
- chunkKJP2NVDR_js.__name(peg$f6, "peg$f6");
370
+ chunkEWY3F3XT_js.__name(peg$f5, "peg$f5");
371
+ function peg$f6(first, rest) {
372
+ return [first, ...rest].join(" ");
373
+ }
374
+ chunkEWY3F3XT_js.__name(peg$f6, "peg$f6");
363
375
  function peg$f7(name, val) {
364
- return new chunkKJP2NVDR_js.ParsedEnvSpecDecorator({
376
+ return new chunkEWY3F3XT_js.ParsedEnvSpecDecorator({
365
377
  name,
366
378
  value: Array.isArray(val) ? val[1] : val,
367
379
  isBareFnCall: val && !Array.isArray(val),
368
380
  _location: location()
369
381
  });
370
382
  }
371
- chunkKJP2NVDR_js.__name(peg$f7, "peg$f7");
383
+ chunkEWY3F3XT_js.__name(peg$f7, "peg$f7");
372
384
  function peg$f8(name, args) {
373
- return new chunkKJP2NVDR_js.ParsedEnvSpecFunctionCall({
385
+ return new chunkEWY3F3XT_js.ParsedEnvSpecFunctionCall({
374
386
  name,
375
387
  args,
376
388
  _location: location()
377
389
  });
378
390
  }
379
- chunkKJP2NVDR_js.__name(peg$f8, "peg$f8");
391
+ chunkEWY3F3XT_js.__name(peg$f8, "peg$f8");
380
392
  function peg$f9(key, val) {
381
- return new chunkKJP2NVDR_js.ParsedEnvSpecKeyValuePair({ key, val });
393
+ return new chunkEWY3F3XT_js.ParsedEnvSpecKeyValuePair({ key, val });
382
394
  }
383
- chunkKJP2NVDR_js.__name(peg$f9, "peg$f9");
395
+ chunkEWY3F3XT_js.__name(peg$f9, "peg$f9");
384
396
  function peg$f10(values) {
385
- return new chunkKJP2NVDR_js.ParsedEnvSpecFunctionArgs({
397
+ return new chunkEWY3F3XT_js.ParsedEnvSpecFunctionArgs({
386
398
  values: values || [],
387
399
  _location: location()
388
400
  });
389
401
  }
390
- chunkKJP2NVDR_js.__name(peg$f10, "peg$f10");
402
+ chunkEWY3F3XT_js.__name(peg$f10, "peg$f10");
391
403
  function peg$f11() {
392
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
404
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
393
405
  }
394
- chunkKJP2NVDR_js.__name(peg$f11, "peg$f11");
406
+ chunkEWY3F3XT_js.__name(peg$f11, "peg$f11");
395
407
  function peg$f12(name, args) {
396
- return new chunkKJP2NVDR_js.ParsedEnvSpecFunctionCall({
408
+ return new chunkEWY3F3XT_js.ParsedEnvSpecFunctionCall({
397
409
  name,
398
410
  args,
399
411
  _location: location()
400
412
  });
401
413
  }
402
- chunkKJP2NVDR_js.__name(peg$f12, "peg$f12");
414
+ chunkEWY3F3XT_js.__name(peg$f12, "peg$f12");
403
415
  function peg$f13(key, val) {
404
- return new chunkKJP2NVDR_js.ParsedEnvSpecKeyValuePair({ key, val });
416
+ return new chunkEWY3F3XT_js.ParsedEnvSpecKeyValuePair({ key, val });
405
417
  }
406
- chunkKJP2NVDR_js.__name(peg$f13, "peg$f13");
418
+ chunkEWY3F3XT_js.__name(peg$f13, "peg$f13");
407
419
  function peg$f14(values) {
408
- return new chunkKJP2NVDR_js.ParsedEnvSpecFunctionArgs({
420
+ return new chunkEWY3F3XT_js.ParsedEnvSpecFunctionArgs({
409
421
  values: values || [],
410
422
  _location: location()
411
423
  });
412
424
  }
413
- chunkKJP2NVDR_js.__name(peg$f14, "peg$f14");
425
+ chunkEWY3F3XT_js.__name(peg$f14, "peg$f14");
414
426
  function peg$f15() {
415
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
427
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
416
428
  }
417
- chunkKJP2NVDR_js.__name(peg$f15, "peg$f15");
429
+ chunkEWY3F3XT_js.__name(peg$f15, "peg$f15");
418
430
  function peg$f16(leadingSpace, contents) {
419
- return new chunkKJP2NVDR_js.ParsedEnvSpecDivider({
431
+ return new chunkEWY3F3XT_js.ParsedEnvSpecDivider({
420
432
  contents,
421
433
  leadingSpace,
422
434
  _location: location()
423
435
  });
424
436
  }
425
- chunkKJP2NVDR_js.__name(peg$f16, "peg$f16");
437
+ chunkEWY3F3XT_js.__name(peg$f16, "peg$f16");
426
438
  function peg$f17() {
427
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
439
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
428
440
  }
429
- chunkKJP2NVDR_js.__name(peg$f17, "peg$f17");
441
+ chunkEWY3F3XT_js.__name(peg$f17, "peg$f17");
430
442
  function peg$f18() {
431
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
443
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
432
444
  }
433
- chunkKJP2NVDR_js.__name(peg$f18, "peg$f18");
445
+ chunkEWY3F3XT_js.__name(peg$f18, "peg$f18");
434
446
  function peg$f19(quote) {
435
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
447
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
436
448
  }
437
- chunkKJP2NVDR_js.__name(peg$f19, "peg$f19");
449
+ chunkEWY3F3XT_js.__name(peg$f19, "peg$f19");
438
450
  function peg$f20(quote) {
439
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
451
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
440
452
  }
441
- chunkKJP2NVDR_js.__name(peg$f20, "peg$f20");
453
+ chunkEWY3F3XT_js.__name(peg$f20, "peg$f20");
442
454
  function peg$f21(quote) {
443
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
455
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
444
456
  }
445
- chunkKJP2NVDR_js.__name(peg$f21, "peg$f21");
457
+ chunkEWY3F3XT_js.__name(peg$f21, "peg$f21");
446
458
  function peg$f22(quote) {
447
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
459
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
448
460
  }
449
- chunkKJP2NVDR_js.__name(peg$f22, "peg$f22");
461
+ chunkEWY3F3XT_js.__name(peg$f22, "peg$f22");
450
462
  function peg$f23(quote) {
451
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
463
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
452
464
  }
453
- chunkKJP2NVDR_js.__name(peg$f23, "peg$f23");
465
+ chunkEWY3F3XT_js.__name(peg$f23, "peg$f23");
454
466
  function peg$f24(quote) {
455
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
467
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
456
468
  }
457
- chunkKJP2NVDR_js.__name(peg$f24, "peg$f24");
469
+ chunkEWY3F3XT_js.__name(peg$f24, "peg$f24");
458
470
  function peg$f25(quote) {
459
- return new chunkKJP2NVDR_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
471
+ return new chunkEWY3F3XT_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
460
472
  }
461
- chunkKJP2NVDR_js.__name(peg$f25, "peg$f25");
473
+ chunkEWY3F3XT_js.__name(peg$f25, "peg$f25");
462
474
  let peg$currPos = options.peg$currPos | 0;
463
475
  let peg$savedPos = peg$currPos;
464
476
  const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -475,11 +487,11 @@ function peg$parse(input, options) {
475
487
  function text() {
476
488
  return input.substring(peg$savedPos, peg$currPos);
477
489
  }
478
- chunkKJP2NVDR_js.__name(text, "text");
490
+ chunkEWY3F3XT_js.__name(text, "text");
479
491
  function offset() {
480
492
  return peg$savedPos;
481
493
  }
482
- chunkKJP2NVDR_js.__name(offset, "offset");
494
+ chunkEWY3F3XT_js.__name(offset, "offset");
483
495
  function range() {
484
496
  return {
485
497
  source: peg$source,
@@ -487,11 +499,11 @@ function peg$parse(input, options) {
487
499
  end: peg$currPos
488
500
  };
489
501
  }
490
- chunkKJP2NVDR_js.__name(range, "range");
502
+ chunkEWY3F3XT_js.__name(range, "range");
491
503
  function location() {
492
504
  return peg$computeLocation(peg$savedPos, peg$currPos);
493
505
  }
494
- chunkKJP2NVDR_js.__name(location, "location");
506
+ chunkEWY3F3XT_js.__name(location, "location");
495
507
  function expected(description, location2) {
496
508
  location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
497
509
  throw peg$buildStructuredError(
@@ -500,12 +512,12 @@ function peg$parse(input, options) {
500
512
  location2
501
513
  );
502
514
  }
503
- chunkKJP2NVDR_js.__name(expected, "expected");
515
+ chunkEWY3F3XT_js.__name(expected, "expected");
504
516
  function error(message, location2) {
505
517
  location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
506
518
  throw peg$buildSimpleError(message, location2);
507
519
  }
508
- chunkKJP2NVDR_js.__name(error, "error");
520
+ chunkEWY3F3XT_js.__name(error, "error");
509
521
  function peg$getUnicode(pos = peg$currPos) {
510
522
  const cp = input.codePointAt(pos);
511
523
  if (cp === void 0) {
@@ -513,27 +525,27 @@ function peg$parse(input, options) {
513
525
  }
514
526
  return String.fromCodePoint(cp);
515
527
  }
516
- chunkKJP2NVDR_js.__name(peg$getUnicode, "peg$getUnicode");
528
+ chunkEWY3F3XT_js.__name(peg$getUnicode, "peg$getUnicode");
517
529
  function peg$literalExpectation(text2, ignoreCase) {
518
530
  return { type: "literal", text: text2, ignoreCase };
519
531
  }
520
- chunkKJP2NVDR_js.__name(peg$literalExpectation, "peg$literalExpectation");
532
+ chunkEWY3F3XT_js.__name(peg$literalExpectation, "peg$literalExpectation");
521
533
  function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
522
534
  return { type: "class", parts, inverted, ignoreCase, unicode };
523
535
  }
524
- chunkKJP2NVDR_js.__name(peg$classExpectation, "peg$classExpectation");
536
+ chunkEWY3F3XT_js.__name(peg$classExpectation, "peg$classExpectation");
525
537
  function peg$anyExpectation() {
526
538
  return { type: "any" };
527
539
  }
528
- chunkKJP2NVDR_js.__name(peg$anyExpectation, "peg$anyExpectation");
540
+ chunkEWY3F3XT_js.__name(peg$anyExpectation, "peg$anyExpectation");
529
541
  function peg$endExpectation() {
530
542
  return { type: "end" };
531
543
  }
532
- chunkKJP2NVDR_js.__name(peg$endExpectation, "peg$endExpectation");
544
+ chunkEWY3F3XT_js.__name(peg$endExpectation, "peg$endExpectation");
533
545
  function peg$otherExpectation(description) {
534
546
  return { type: "other", description };
535
547
  }
536
- chunkKJP2NVDR_js.__name(peg$otherExpectation, "peg$otherExpectation");
548
+ chunkEWY3F3XT_js.__name(peg$otherExpectation, "peg$otherExpectation");
537
549
  function peg$computePosDetails(pos) {
538
550
  let details = peg$posDetailsCache[pos];
539
551
  let p;
@@ -565,7 +577,7 @@ function peg$parse(input, options) {
565
577
  return details;
566
578
  }
567
579
  }
568
- chunkKJP2NVDR_js.__name(peg$computePosDetails, "peg$computePosDetails");
580
+ chunkEWY3F3XT_js.__name(peg$computePosDetails, "peg$computePosDetails");
569
581
  function peg$computeLocation(startPos, endPos, offset2) {
570
582
  const startPosDetails = peg$computePosDetails(startPos);
571
583
  const endPosDetails = peg$computePosDetails(endPos);
@@ -588,7 +600,7 @@ function peg$parse(input, options) {
588
600
  }
589
601
  return res;
590
602
  }
591
- chunkKJP2NVDR_js.__name(peg$computeLocation, "peg$computeLocation");
603
+ chunkEWY3F3XT_js.__name(peg$computeLocation, "peg$computeLocation");
592
604
  function peg$fail(expected2) {
593
605
  if (peg$currPos < peg$maxFailPos) {
594
606
  return;
@@ -599,11 +611,11 @@ function peg$parse(input, options) {
599
611
  }
600
612
  peg$maxFailExpected.push(expected2);
601
613
  }
602
- chunkKJP2NVDR_js.__name(peg$fail, "peg$fail");
614
+ chunkEWY3F3XT_js.__name(peg$fail, "peg$fail");
603
615
  function peg$buildSimpleError(message, location2) {
604
616
  return new peg$SyntaxError(message, null, null, location2);
605
617
  }
606
- chunkKJP2NVDR_js.__name(peg$buildSimpleError, "peg$buildSimpleError");
618
+ chunkEWY3F3XT_js.__name(peg$buildSimpleError, "peg$buildSimpleError");
607
619
  function peg$buildStructuredError(expected2, found, location2) {
608
620
  return new peg$SyntaxError(
609
621
  peg$SyntaxError.buildMessage(expected2, found),
@@ -612,7 +624,7 @@ function peg$parse(input, options) {
612
624
  location2
613
625
  );
614
626
  }
615
- chunkKJP2NVDR_js.__name(peg$buildStructuredError, "peg$buildStructuredError");
627
+ chunkEWY3F3XT_js.__name(peg$buildStructuredError, "peg$buildStructuredError");
616
628
  function peg$parseEnvSpecFile() {
617
629
  let s0, s1, s2, s3;
618
630
  s0 = peg$currPos;
@@ -673,18 +685,15 @@ function peg$parse(input, options) {
673
685
  s0 = s1;
674
686
  return s0;
675
687
  }
676
- chunkKJP2NVDR_js.__name(peg$parseEnvSpecFile, "peg$parseEnvSpecFile");
688
+ chunkEWY3F3XT_js.__name(peg$parseEnvSpecFile, "peg$parseEnvSpecFile");
677
689
  function peg$parseConfigItem() {
678
690
  let s0, s1, s2, s3, s4, s5, s6, s7, s9, s10;
679
691
  s0 = peg$currPos;
680
692
  s1 = [];
681
693
  s2 = peg$currPos;
682
- s3 = peg$parseIgnoredDecoratorComment();
694
+ s3 = peg$parseDecoratorComment();
683
695
  if (s3 === peg$FAILED) {
684
- s3 = peg$parseDecoratorComment();
685
- if (s3 === peg$FAILED) {
686
- s3 = peg$parseComment();
687
- }
696
+ s3 = peg$parseComment();
688
697
  }
689
698
  if (s3 !== peg$FAILED) {
690
699
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -709,12 +718,9 @@ function peg$parse(input, options) {
709
718
  while (s2 !== peg$FAILED) {
710
719
  s1.push(s2);
711
720
  s2 = peg$currPos;
712
- s3 = peg$parseIgnoredDecoratorComment();
721
+ s3 = peg$parseDecoratorComment();
713
722
  if (s3 === peg$FAILED) {
714
- s3 = peg$parseDecoratorComment();
715
- if (s3 === peg$FAILED) {
716
- s3 = peg$parseComment();
717
- }
723
+ s3 = peg$parseComment();
718
724
  }
719
725
  if (s3 !== peg$FAILED) {
720
726
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -779,12 +785,9 @@ function peg$parse(input, options) {
779
785
  }
780
786
  peg$parse_();
781
787
  s9 = peg$currPos;
782
- s10 = peg$parseIgnoredDecoratorComment();
788
+ s10 = peg$parseDecoratorComment();
783
789
  if (s10 === peg$FAILED) {
784
- s10 = peg$parseDecoratorComment();
785
- if (s10 === peg$FAILED) {
786
- s10 = peg$parseComment();
787
- }
790
+ s10 = peg$parseComment();
788
791
  }
789
792
  if (s10 !== peg$FAILED) {
790
793
  s9 = s10;
@@ -813,7 +816,7 @@ function peg$parse(input, options) {
813
816
  }
814
817
  return s0;
815
818
  }
816
- chunkKJP2NVDR_js.__name(peg$parseConfigItem, "peg$parseConfigItem");
819
+ chunkEWY3F3XT_js.__name(peg$parseConfigItem, "peg$parseConfigItem");
817
820
  function peg$parseConfigItemKey() {
818
821
  let s0, s1, s2, s3, s4;
819
822
  s0 = peg$currPos;
@@ -863,7 +866,7 @@ function peg$parse(input, options) {
863
866
  }
864
867
  return s0;
865
868
  }
866
- chunkKJP2NVDR_js.__name(peg$parseConfigItemKey, "peg$parseConfigItemKey");
869
+ chunkEWY3F3XT_js.__name(peg$parseConfigItemKey, "peg$parseConfigItemKey");
867
870
  function peg$parseConfigItemValue() {
868
871
  let s0;
869
872
  s0 = peg$parseFunctionCall();
@@ -878,18 +881,15 @@ function peg$parse(input, options) {
878
881
  }
879
882
  return s0;
880
883
  }
881
- chunkKJP2NVDR_js.__name(peg$parseConfigItemValue, "peg$parseConfigItemValue");
884
+ chunkEWY3F3XT_js.__name(peg$parseConfigItemValue, "peg$parseConfigItemValue");
882
885
  function peg$parseCommentBlock() {
883
886
  let s0, s1, s2, s3, s4;
884
887
  s0 = peg$currPos;
885
888
  s1 = [];
886
889
  s2 = peg$currPos;
887
- s3 = peg$parseIgnoredDecoratorComment();
890
+ s3 = peg$parseDecoratorComment();
888
891
  if (s3 === peg$FAILED) {
889
- s3 = peg$parseDecoratorComment();
890
- if (s3 === peg$FAILED) {
891
- s3 = peg$parseComment();
892
- }
892
+ s3 = peg$parseComment();
893
893
  }
894
894
  if (s3 !== peg$FAILED) {
895
895
  s4 = peg$parse_n();
@@ -907,12 +907,9 @@ function peg$parse(input, options) {
907
907
  while (s2 !== peg$FAILED) {
908
908
  s1.push(s2);
909
909
  s2 = peg$currPos;
910
- s3 = peg$parseIgnoredDecoratorComment();
910
+ s3 = peg$parseDecoratorComment();
911
911
  if (s3 === peg$FAILED) {
912
- s3 = peg$parseDecoratorComment();
913
- if (s3 === peg$FAILED) {
914
- s3 = peg$parseComment();
915
- }
912
+ s3 = peg$parseComment();
916
913
  }
917
914
  if (s3 !== peg$FAILED) {
918
915
  s4 = peg$parse_n();
@@ -948,7 +945,7 @@ function peg$parse(input, options) {
948
945
  }
949
946
  return s0;
950
947
  }
951
- chunkKJP2NVDR_js.__name(peg$parseCommentBlock, "peg$parseCommentBlock");
948
+ chunkEWY3F3XT_js.__name(peg$parseCommentBlock, "peg$parseCommentBlock");
952
949
  function peg$parseComment() {
953
950
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
954
951
  s0 = peg$currPos;
@@ -1043,9 +1040,9 @@ function peg$parse(input, options) {
1043
1040
  }
1044
1041
  return s0;
1045
1042
  }
1046
- chunkKJP2NVDR_js.__name(peg$parseComment, "peg$parseComment");
1047
- function peg$parseIgnoredDecoratorComment() {
1048
- let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1043
+ chunkEWY3F3XT_js.__name(peg$parseComment, "peg$parseComment");
1044
+ function peg$parseDecoratorComment() {
1045
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1049
1046
  s0 = peg$currPos;
1050
1047
  if (input.charCodeAt(peg$currPos) === 35) {
1051
1048
  s1 = peg$c3;
@@ -1060,104 +1057,167 @@ function peg$parse(input, options) {
1060
1057
  s2 = peg$currPos;
1061
1058
  s3 = peg$parse_();
1062
1059
  s2 = input.substring(s2, peg$currPos);
1063
- s3 = peg$currPos;
1064
- s4 = peg$currPos;
1065
- if (input.charCodeAt(peg$currPos) === 64) {
1066
- s5 = peg$c4;
1067
- peg$currPos++;
1068
- } else {
1069
- s5 = peg$FAILED;
1070
- if (peg$silentFails === 0) {
1071
- peg$fail(peg$e6);
1072
- }
1073
- }
1074
- if (s5 !== peg$FAILED) {
1075
- s6 = [];
1076
- s7 = input.charAt(peg$currPos);
1077
- if (peg$r3.test(s7)) {
1078
- peg$currPos++;
1079
- } else {
1080
- s7 = peg$FAILED;
1081
- if (peg$silentFails === 0) {
1082
- peg$fail(peg$e8);
1060
+ s3 = peg$parseDecorator();
1061
+ if (s3 !== peg$FAILED) {
1062
+ s4 = [];
1063
+ s5 = peg$currPos;
1064
+ s6 = peg$parse__();
1065
+ if (s6 !== peg$FAILED) {
1066
+ s7 = peg$parseDecoratorOrText();
1067
+ if (s7 !== peg$FAILED) {
1068
+ s5 = s7;
1069
+ } else {
1070
+ peg$currPos = s5;
1071
+ s5 = peg$FAILED;
1083
1072
  }
1073
+ } else {
1074
+ peg$currPos = s5;
1075
+ s5 = peg$FAILED;
1084
1076
  }
1085
- if (s7 !== peg$FAILED) {
1086
- while (s7 !== peg$FAILED) {
1087
- s6.push(s7);
1088
- s7 = input.charAt(peg$currPos);
1089
- if (peg$r3.test(s7)) {
1090
- peg$currPos++;
1077
+ while (s5 !== peg$FAILED) {
1078
+ s4.push(s5);
1079
+ s5 = peg$currPos;
1080
+ s6 = peg$parse__();
1081
+ if (s6 !== peg$FAILED) {
1082
+ s7 = peg$parseDecoratorOrText();
1083
+ if (s7 !== peg$FAILED) {
1084
+ s5 = s7;
1091
1085
  } else {
1092
- s7 = peg$FAILED;
1093
- if (peg$silentFails === 0) {
1094
- peg$fail(peg$e8);
1095
- }
1086
+ peg$currPos = s5;
1087
+ s5 = peg$FAILED;
1096
1088
  }
1089
+ } else {
1090
+ peg$currPos = s5;
1091
+ s5 = peg$FAILED;
1097
1092
  }
1093
+ }
1094
+ s5 = peg$currPos;
1095
+ s6 = peg$parse_();
1096
+ s7 = peg$currPos;
1097
+ s8 = peg$currPos;
1098
+ if (input.charCodeAt(peg$currPos) === 35) {
1099
+ s9 = peg$c3;
1100
+ peg$currPos++;
1098
1101
  } else {
1099
- s6 = peg$FAILED;
1102
+ s9 = peg$FAILED;
1103
+ if (peg$silentFails === 0) {
1104
+ peg$fail(peg$e5);
1105
+ }
1100
1106
  }
1101
- if (s6 !== peg$FAILED) {
1102
- if (input.charCodeAt(peg$currPos) === 58) {
1103
- s7 = peg$c5;
1107
+ if (s9 !== peg$FAILED) {
1108
+ s10 = [];
1109
+ s11 = input.charAt(peg$currPos);
1110
+ if (peg$r2.test(s11)) {
1104
1111
  peg$currPos++;
1105
1112
  } else {
1106
- s7 = peg$FAILED;
1113
+ s11 = peg$FAILED;
1107
1114
  if (peg$silentFails === 0) {
1108
- peg$fail(peg$e9);
1115
+ peg$fail(peg$e7);
1109
1116
  }
1110
1117
  }
1111
- if (s7 !== peg$FAILED) {
1112
- s8 = [];
1113
- s9 = input.charAt(peg$currPos);
1114
- if (peg$r2.test(s9)) {
1118
+ while (s11 !== peg$FAILED) {
1119
+ s10.push(s11);
1120
+ s11 = input.charAt(peg$currPos);
1121
+ if (peg$r2.test(s11)) {
1115
1122
  peg$currPos++;
1116
1123
  } else {
1117
- s9 = peg$FAILED;
1124
+ s11 = peg$FAILED;
1118
1125
  if (peg$silentFails === 0) {
1119
1126
  peg$fail(peg$e7);
1120
1127
  }
1121
1128
  }
1122
- while (s9 !== peg$FAILED) {
1123
- s8.push(s9);
1124
- s9 = input.charAt(peg$currPos);
1125
- if (peg$r2.test(s9)) {
1126
- peg$currPos++;
1127
- } else {
1128
- s9 = peg$FAILED;
1129
- if (peg$silentFails === 0) {
1130
- peg$fail(peg$e7);
1131
- }
1132
- }
1133
- }
1134
- s5 = [s5, s6, s7, s8];
1135
- s4 = s5;
1136
- } else {
1137
- peg$currPos = s4;
1138
- s4 = peg$FAILED;
1139
1129
  }
1130
+ s9 = [s9, s10];
1131
+ s8 = s9;
1140
1132
  } else {
1141
- peg$currPos = s4;
1142
- s4 = peg$FAILED;
1133
+ peg$currPos = s8;
1134
+ s8 = peg$FAILED;
1143
1135
  }
1136
+ if (s8 !== peg$FAILED) {
1137
+ s7 = input.substring(s7, peg$currPos);
1138
+ } else {
1139
+ s7 = s8;
1140
+ }
1141
+ if (s7 !== peg$FAILED) {
1142
+ s5 = s7;
1143
+ } else {
1144
+ peg$currPos = s5;
1145
+ s5 = peg$FAILED;
1146
+ }
1147
+ if (s5 === peg$FAILED) {
1148
+ s5 = null;
1149
+ }
1150
+ s6 = peg$parse_();
1151
+ peg$savedPos = s0;
1152
+ s0 = peg$f5(s2, s3, s4, s5);
1144
1153
  } else {
1145
- peg$currPos = s4;
1146
- s4 = peg$FAILED;
1154
+ peg$currPos = s0;
1155
+ s0 = peg$FAILED;
1147
1156
  }
1148
- if (s4 === peg$FAILED) {
1149
- s4 = peg$currPos;
1150
- if (input.charCodeAt(peg$currPos) === 64) {
1151
- s5 = peg$c4;
1157
+ } else {
1158
+ peg$currPos = s0;
1159
+ s0 = peg$FAILED;
1160
+ }
1161
+ return s0;
1162
+ }
1163
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorComment, "peg$parseDecoratorComment");
1164
+ function peg$parseDecoratorOrText() {
1165
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
1166
+ s0 = peg$parseDecorator();
1167
+ if (s0 === peg$FAILED) {
1168
+ s0 = peg$currPos;
1169
+ s1 = peg$currPos;
1170
+ s2 = peg$currPos;
1171
+ s3 = input.charAt(peg$currPos);
1172
+ if (peg$r3.test(s3)) {
1173
+ peg$currPos++;
1174
+ } else {
1175
+ s3 = peg$FAILED;
1176
+ if (peg$silentFails === 0) {
1177
+ peg$fail(peg$e8);
1178
+ }
1179
+ }
1180
+ if (s3 !== peg$FAILED) {
1181
+ s4 = [];
1182
+ s5 = input.charAt(peg$currPos);
1183
+ if (peg$r4.test(s5)) {
1152
1184
  peg$currPos++;
1153
1185
  } else {
1154
1186
  s5 = peg$FAILED;
1155
1187
  if (peg$silentFails === 0) {
1156
- peg$fail(peg$e6);
1188
+ peg$fail(peg$e9);
1189
+ }
1190
+ }
1191
+ while (s5 !== peg$FAILED) {
1192
+ s4.push(s5);
1193
+ s5 = input.charAt(peg$currPos);
1194
+ if (peg$r4.test(s5)) {
1195
+ peg$currPos++;
1196
+ } else {
1197
+ s5 = peg$FAILED;
1198
+ if (peg$silentFails === 0) {
1199
+ peg$fail(peg$e9);
1200
+ }
1157
1201
  }
1158
1202
  }
1159
- if (s5 !== peg$FAILED) {
1160
- s6 = [];
1203
+ s3 = [s3, s4];
1204
+ s2 = s3;
1205
+ } else {
1206
+ peg$currPos = s2;
1207
+ s2 = peg$FAILED;
1208
+ }
1209
+ if (s2 !== peg$FAILED) {
1210
+ s1 = input.substring(s1, peg$currPos);
1211
+ } else {
1212
+ s1 = s2;
1213
+ }
1214
+ if (s1 !== peg$FAILED) {
1215
+ s2 = [];
1216
+ s3 = peg$currPos;
1217
+ s4 = peg$parse__();
1218
+ if (s4 !== peg$FAILED) {
1219
+ s5 = peg$currPos;
1220
+ s6 = peg$currPos;
1161
1221
  s7 = input.charAt(peg$currPos);
1162
1222
  if (peg$r3.test(s7)) {
1163
1223
  peg$currPos++;
@@ -1168,211 +1228,120 @@ function peg$parse(input, options) {
1168
1228
  }
1169
1229
  }
1170
1230
  if (s7 !== peg$FAILED) {
1171
- while (s7 !== peg$FAILED) {
1172
- s6.push(s7);
1173
- s7 = input.charAt(peg$currPos);
1174
- if (peg$r3.test(s7)) {
1175
- peg$currPos++;
1176
- } else {
1177
- s7 = peg$FAILED;
1178
- if (peg$silentFails === 0) {
1179
- peg$fail(peg$e8);
1180
- }
1231
+ s8 = [];
1232
+ s9 = input.charAt(peg$currPos);
1233
+ if (peg$r4.test(s9)) {
1234
+ peg$currPos++;
1235
+ } else {
1236
+ s9 = peg$FAILED;
1237
+ if (peg$silentFails === 0) {
1238
+ peg$fail(peg$e9);
1181
1239
  }
1182
1240
  }
1183
- } else {
1184
- s6 = peg$FAILED;
1185
- }
1186
- if (s6 !== peg$FAILED) {
1187
- s7 = peg$parse__();
1188
- if (s7 !== peg$FAILED) {
1189
- s8 = peg$currPos;
1190
- peg$silentFails++;
1241
+ while (s9 !== peg$FAILED) {
1242
+ s8.push(s9);
1191
1243
  s9 = input.charAt(peg$currPos);
1192
1244
  if (peg$r4.test(s9)) {
1193
1245
  peg$currPos++;
1194
1246
  } else {
1195
1247
  s9 = peg$FAILED;
1196
1248
  if (peg$silentFails === 0) {
1197
- peg$fail(peg$e10);
1249
+ peg$fail(peg$e9);
1198
1250
  }
1199
1251
  }
1200
- peg$silentFails--;
1201
- if (s9 === peg$FAILED) {
1202
- s8 = void 0;
1203
- } else {
1204
- peg$currPos = s8;
1205
- s8 = peg$FAILED;
1206
- }
1207
- if (s8 !== peg$FAILED) {
1208
- s9 = [];
1209
- s10 = input.charAt(peg$currPos);
1210
- if (peg$r2.test(s10)) {
1211
- peg$currPos++;
1212
- } else {
1213
- s10 = peg$FAILED;
1214
- if (peg$silentFails === 0) {
1215
- peg$fail(peg$e7);
1216
- }
1217
- }
1218
- while (s10 !== peg$FAILED) {
1219
- s9.push(s10);
1220
- s10 = input.charAt(peg$currPos);
1221
- if (peg$r2.test(s10)) {
1222
- peg$currPos++;
1223
- } else {
1224
- s10 = peg$FAILED;
1225
- if (peg$silentFails === 0) {
1226
- peg$fail(peg$e7);
1227
- }
1228
- }
1229
- }
1230
- s5 = [s5, s6, s7, s8, s9];
1231
- s4 = s5;
1232
- } else {
1233
- peg$currPos = s4;
1234
- s4 = peg$FAILED;
1235
- }
1236
- } else {
1237
- peg$currPos = s4;
1238
- s4 = peg$FAILED;
1239
1252
  }
1253
+ s7 = [s7, s8];
1254
+ s6 = s7;
1240
1255
  } else {
1241
- peg$currPos = s4;
1242
- s4 = peg$FAILED;
1243
- }
1244
- } else {
1245
- peg$currPos = s4;
1246
- s4 = peg$FAILED;
1247
- }
1248
- }
1249
- if (s4 !== peg$FAILED) {
1250
- s3 = input.substring(s3, peg$currPos);
1251
- } else {
1252
- s3 = s4;
1253
- }
1254
- if (s3 !== peg$FAILED) {
1255
- peg$savedPos = s0;
1256
- s0 = peg$f5(s2, s3);
1257
- } else {
1258
- peg$currPos = s0;
1259
- s0 = peg$FAILED;
1260
- }
1261
- } else {
1262
- peg$currPos = s0;
1263
- s0 = peg$FAILED;
1264
- }
1265
- return s0;
1266
- }
1267
- chunkKJP2NVDR_js.__name(peg$parseIgnoredDecoratorComment, "peg$parseIgnoredDecoratorComment");
1268
- function peg$parseDecoratorComment() {
1269
- let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1270
- s0 = peg$currPos;
1271
- if (input.charCodeAt(peg$currPos) === 35) {
1272
- s1 = peg$c3;
1273
- peg$currPos++;
1274
- } else {
1275
- s1 = peg$FAILED;
1276
- if (peg$silentFails === 0) {
1277
- peg$fail(peg$e5);
1278
- }
1279
- }
1280
- if (s1 !== peg$FAILED) {
1281
- s2 = peg$currPos;
1282
- s3 = peg$parse_();
1283
- s2 = input.substring(s2, peg$currPos);
1284
- s3 = peg$parseDecorator();
1285
- if (s3 !== peg$FAILED) {
1286
- s4 = [];
1287
- s5 = peg$currPos;
1288
- s6 = peg$parse__();
1289
- if (s6 !== peg$FAILED) {
1290
- s7 = peg$parseDecorator();
1291
- if (s7 !== peg$FAILED) {
1292
- s5 = s7;
1293
- } else {
1294
- peg$currPos = s5;
1295
- s5 = peg$FAILED;
1256
+ peg$currPos = s6;
1257
+ s6 = peg$FAILED;
1296
1258
  }
1297
- } else {
1298
- peg$currPos = s5;
1299
- s5 = peg$FAILED;
1300
- }
1301
- while (s5 !== peg$FAILED) {
1302
- s4.push(s5);
1303
- s5 = peg$currPos;
1304
- s6 = peg$parse__();
1305
1259
  if (s6 !== peg$FAILED) {
1306
- s7 = peg$parseDecorator();
1307
- if (s7 !== peg$FAILED) {
1308
- s5 = s7;
1309
- } else {
1310
- peg$currPos = s5;
1311
- s5 = peg$FAILED;
1312
- }
1260
+ s5 = input.substring(s5, peg$currPos);
1313
1261
  } else {
1314
- peg$currPos = s5;
1315
- s5 = peg$FAILED;
1316
- }
1317
- }
1318
- s5 = peg$parse_();
1319
- s6 = peg$currPos;
1320
- s7 = peg$currPos;
1321
- if (input.charCodeAt(peg$currPos) === 35) {
1322
- s8 = peg$c3;
1323
- peg$currPos++;
1324
- } else {
1325
- s8 = peg$FAILED;
1326
- if (peg$silentFails === 0) {
1327
- peg$fail(peg$e5);
1262
+ s5 = s6;
1328
1263
  }
1329
- }
1330
- if (s8 !== peg$FAILED) {
1331
- s9 = [];
1332
- s10 = input.charAt(peg$currPos);
1333
- if (peg$r2.test(s10)) {
1334
- peg$currPos++;
1335
- } else {
1336
- s10 = peg$FAILED;
1337
- if (peg$silentFails === 0) {
1338
- peg$fail(peg$e7);
1339
- }
1264
+ if (s5 !== peg$FAILED) {
1265
+ s3 = s5;
1266
+ } else {
1267
+ peg$currPos = s3;
1268
+ s3 = peg$FAILED;
1340
1269
  }
1341
- while (s10 !== peg$FAILED) {
1342
- s9.push(s10);
1343
- s10 = input.charAt(peg$currPos);
1344
- if (peg$r2.test(s10)) {
1270
+ } else {
1271
+ peg$currPos = s3;
1272
+ s3 = peg$FAILED;
1273
+ }
1274
+ while (s3 !== peg$FAILED) {
1275
+ s2.push(s3);
1276
+ s3 = peg$currPos;
1277
+ s4 = peg$parse__();
1278
+ if (s4 !== peg$FAILED) {
1279
+ s5 = peg$currPos;
1280
+ s6 = peg$currPos;
1281
+ s7 = input.charAt(peg$currPos);
1282
+ if (peg$r3.test(s7)) {
1345
1283
  peg$currPos++;
1346
1284
  } else {
1347
- s10 = peg$FAILED;
1285
+ s7 = peg$FAILED;
1348
1286
  if (peg$silentFails === 0) {
1349
- peg$fail(peg$e7);
1287
+ peg$fail(peg$e8);
1288
+ }
1289
+ }
1290
+ if (s7 !== peg$FAILED) {
1291
+ s8 = [];
1292
+ s9 = input.charAt(peg$currPos);
1293
+ if (peg$r4.test(s9)) {
1294
+ peg$currPos++;
1295
+ } else {
1296
+ s9 = peg$FAILED;
1297
+ if (peg$silentFails === 0) {
1298
+ peg$fail(peg$e9);
1299
+ }
1300
+ }
1301
+ while (s9 !== peg$FAILED) {
1302
+ s8.push(s9);
1303
+ s9 = input.charAt(peg$currPos);
1304
+ if (peg$r4.test(s9)) {
1305
+ peg$currPos++;
1306
+ } else {
1307
+ s9 = peg$FAILED;
1308
+ if (peg$silentFails === 0) {
1309
+ peg$fail(peg$e9);
1310
+ }
1311
+ }
1350
1312
  }
1313
+ s7 = [s7, s8];
1314
+ s6 = s7;
1315
+ } else {
1316
+ peg$currPos = s6;
1317
+ s6 = peg$FAILED;
1318
+ }
1319
+ if (s6 !== peg$FAILED) {
1320
+ s5 = input.substring(s5, peg$currPos);
1321
+ } else {
1322
+ s5 = s6;
1351
1323
  }
1324
+ if (s5 !== peg$FAILED) {
1325
+ s3 = s5;
1326
+ } else {
1327
+ peg$currPos = s3;
1328
+ s3 = peg$FAILED;
1329
+ }
1330
+ } else {
1331
+ peg$currPos = s3;
1332
+ s3 = peg$FAILED;
1352
1333
  }
1353
- s8 = [s8, s9];
1354
- s7 = s8;
1355
- } else {
1356
- peg$currPos = s7;
1357
- s7 = peg$FAILED;
1358
1334
  }
1359
- if (s7 === peg$FAILED) {
1360
- s7 = null;
1361
- }
1362
- s6 = input.substring(s6, peg$currPos);
1363
1335
  peg$savedPos = s0;
1364
- s0 = peg$f6(s2, s3, s4, s6);
1336
+ s0 = peg$f6(s1, s2);
1365
1337
  } else {
1366
1338
  peg$currPos = s0;
1367
1339
  s0 = peg$FAILED;
1368
1340
  }
1369
- } else {
1370
- peg$currPos = s0;
1371
- s0 = peg$FAILED;
1372
1341
  }
1373
1342
  return s0;
1374
1343
  }
1375
- chunkKJP2NVDR_js.__name(peg$parseDecoratorComment, "peg$parseDecoratorComment");
1344
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorOrText, "peg$parseDecoratorOrText");
1376
1345
  function peg$parseDecorator() {
1377
1346
  let s0, s1, s2, s3, s4, s5;
1378
1347
  s0 = peg$currPos;
@@ -1429,24 +1398,24 @@ function peg$parse(input, options) {
1429
1398
  }
1430
1399
  return s0;
1431
1400
  }
1432
- chunkKJP2NVDR_js.__name(peg$parseDecorator, "peg$parseDecorator");
1401
+ chunkEWY3F3XT_js.__name(peg$parseDecorator, "peg$parseDecorator");
1433
1402
  function peg$parseDecoratorName() {
1434
1403
  let s0, s1, s2, s3, s4;
1435
1404
  s0 = peg$currPos;
1436
1405
  s1 = peg$currPos;
1437
1406
  s2 = input.charAt(peg$currPos);
1438
- if (peg$r3.test(s2)) {
1407
+ if (peg$r5.test(s2)) {
1439
1408
  peg$currPos++;
1440
1409
  } else {
1441
1410
  s2 = peg$FAILED;
1442
1411
  if (peg$silentFails === 0) {
1443
- peg$fail(peg$e8);
1412
+ peg$fail(peg$e10);
1444
1413
  }
1445
1414
  }
1446
1415
  if (s2 !== peg$FAILED) {
1447
1416
  s3 = [];
1448
1417
  s4 = input.charAt(peg$currPos);
1449
- if (peg$r5.test(s4)) {
1418
+ if (peg$r6.test(s4)) {
1450
1419
  peg$currPos++;
1451
1420
  } else {
1452
1421
  s4 = peg$FAILED;
@@ -1457,7 +1426,7 @@ function peg$parse(input, options) {
1457
1426
  while (s4 !== peg$FAILED) {
1458
1427
  s3.push(s4);
1459
1428
  s4 = input.charAt(peg$currPos);
1460
- if (peg$r5.test(s4)) {
1429
+ if (peg$r6.test(s4)) {
1461
1430
  peg$currPos++;
1462
1431
  } else {
1463
1432
  s4 = peg$FAILED;
@@ -1479,7 +1448,7 @@ function peg$parse(input, options) {
1479
1448
  }
1480
1449
  return s0;
1481
1450
  }
1482
- chunkKJP2NVDR_js.__name(peg$parseDecoratorName, "peg$parseDecoratorName");
1451
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorName, "peg$parseDecoratorName");
1483
1452
  function peg$parseDecoratorValue() {
1484
1453
  let s0;
1485
1454
  s0 = peg$parseDecoratorFunctionCall();
@@ -1491,7 +1460,7 @@ function peg$parse(input, options) {
1491
1460
  }
1492
1461
  return s0;
1493
1462
  }
1494
- chunkKJP2NVDR_js.__name(peg$parseDecoratorValue, "peg$parseDecoratorValue");
1463
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorValue, "peg$parseDecoratorValue");
1495
1464
  function peg$parseDecoratorFunctionCall() {
1496
1465
  let s0, s1, s2;
1497
1466
  s0 = peg$currPos;
@@ -1511,12 +1480,12 @@ function peg$parse(input, options) {
1511
1480
  }
1512
1481
  return s0;
1513
1482
  }
1514
- chunkKJP2NVDR_js.__name(peg$parseDecoratorFunctionCall, "peg$parseDecoratorFunctionCall");
1483
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorFunctionCall, "peg$parseDecoratorFunctionCall");
1515
1484
  function peg$parseDecoratorFunctionArgs() {
1516
1485
  let s0, s1, s3, s4, s5, s6, s7, s8, s9;
1517
1486
  s0 = peg$currPos;
1518
1487
  if (input.charCodeAt(peg$currPos) === 40) {
1519
- s1 = peg$c6;
1488
+ s1 = peg$c5;
1520
1489
  peg$currPos++;
1521
1490
  } else {
1522
1491
  s1 = peg$FAILED;
@@ -1566,7 +1535,7 @@ function peg$parse(input, options) {
1566
1535
  s6 = peg$currPos;
1567
1536
  s7 = peg$parse_decWs();
1568
1537
  if (input.charCodeAt(peg$currPos) === 44) {
1569
- s8 = peg$c7;
1538
+ s8 = peg$c6;
1570
1539
  peg$currPos++;
1571
1540
  } else {
1572
1541
  s8 = peg$FAILED;
@@ -1637,7 +1606,7 @@ function peg$parse(input, options) {
1637
1606
  s4 = peg$currPos;
1638
1607
  s5 = peg$parse_decWs();
1639
1608
  if (input.charCodeAt(peg$currPos) === 44) {
1640
- s6 = peg$c7;
1609
+ s6 = peg$c6;
1641
1610
  peg$currPos++;
1642
1611
  } else {
1643
1612
  s6 = peg$FAILED;
@@ -1657,7 +1626,7 @@ function peg$parse(input, options) {
1657
1626
  }
1658
1627
  s5 = peg$parse_decWs();
1659
1628
  if (input.charCodeAt(peg$currPos) === 41) {
1660
- s6 = peg$c8;
1629
+ s6 = peg$c7;
1661
1630
  peg$currPos++;
1662
1631
  } else {
1663
1632
  s6 = peg$FAILED;
@@ -1678,7 +1647,7 @@ function peg$parse(input, options) {
1678
1647
  }
1679
1648
  return s0;
1680
1649
  }
1681
- chunkKJP2NVDR_js.__name(peg$parseDecoratorFunctionArgs, "peg$parseDecoratorFunctionArgs");
1650
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorFunctionArgs, "peg$parseDecoratorFunctionArgs");
1682
1651
  function peg$parseDecoratorFunctionArgValue() {
1683
1652
  let s0, s1, s2, s3;
1684
1653
  s0 = peg$parseDecoratorFunctionCall();
@@ -1689,7 +1658,7 @@ function peg$parse(input, options) {
1689
1658
  s1 = peg$currPos;
1690
1659
  s2 = [];
1691
1660
  s3 = input.charAt(peg$currPos);
1692
- if (peg$r6.test(s3)) {
1661
+ if (peg$r7.test(s3)) {
1693
1662
  peg$currPos++;
1694
1663
  } else {
1695
1664
  s3 = peg$FAILED;
@@ -1701,7 +1670,7 @@ function peg$parse(input, options) {
1701
1670
  while (s3 !== peg$FAILED) {
1702
1671
  s2.push(s3);
1703
1672
  s3 = input.charAt(peg$currPos);
1704
- if (peg$r6.test(s3)) {
1673
+ if (peg$r7.test(s3)) {
1705
1674
  peg$currPos++;
1706
1675
  } else {
1707
1676
  s3 = peg$FAILED;
@@ -1727,12 +1696,12 @@ function peg$parse(input, options) {
1727
1696
  }
1728
1697
  return s0;
1729
1698
  }
1730
- chunkKJP2NVDR_js.__name(peg$parseDecoratorFunctionArgValue, "peg$parseDecoratorFunctionArgValue");
1699
+ chunkEWY3F3XT_js.__name(peg$parseDecoratorFunctionArgValue, "peg$parseDecoratorFunctionArgValue");
1731
1700
  function peg$parse_decWs() {
1732
1701
  let s0, s1, s2, s3, s4, s5, s6;
1733
1702
  s0 = [];
1734
1703
  s1 = input.charAt(peg$currPos);
1735
- if (peg$r7.test(s1)) {
1704
+ if (peg$r8.test(s1)) {
1736
1705
  peg$currPos++;
1737
1706
  } else {
1738
1707
  s1 = peg$FAILED;
@@ -1754,7 +1723,7 @@ function peg$parse(input, options) {
1754
1723
  if (s2 !== peg$FAILED) {
1755
1724
  s3 = [];
1756
1725
  s4 = input.charAt(peg$currPos);
1757
- if (peg$r7.test(s4)) {
1726
+ if (peg$r8.test(s4)) {
1758
1727
  peg$currPos++;
1759
1728
  } else {
1760
1729
  s4 = peg$FAILED;
@@ -1765,7 +1734,7 @@ function peg$parse(input, options) {
1765
1734
  while (s4 !== peg$FAILED) {
1766
1735
  s3.push(s4);
1767
1736
  s4 = input.charAt(peg$currPos);
1768
- if (peg$r7.test(s4)) {
1737
+ if (peg$r8.test(s4)) {
1769
1738
  peg$currPos++;
1770
1739
  } else {
1771
1740
  s4 = peg$FAILED;
@@ -1786,7 +1755,7 @@ function peg$parse(input, options) {
1786
1755
  if (s4 !== peg$FAILED) {
1787
1756
  s5 = [];
1788
1757
  s6 = input.charAt(peg$currPos);
1789
- if (peg$r7.test(s6)) {
1758
+ if (peg$r8.test(s6)) {
1790
1759
  peg$currPos++;
1791
1760
  } else {
1792
1761
  s6 = peg$FAILED;
@@ -1797,7 +1766,7 @@ function peg$parse(input, options) {
1797
1766
  while (s6 !== peg$FAILED) {
1798
1767
  s5.push(s6);
1799
1768
  s6 = input.charAt(peg$currPos);
1800
- if (peg$r7.test(s6)) {
1769
+ if (peg$r8.test(s6)) {
1801
1770
  peg$currPos++;
1802
1771
  } else {
1803
1772
  s6 = peg$FAILED;
@@ -1820,7 +1789,7 @@ function peg$parse(input, options) {
1820
1789
  while (s1 !== peg$FAILED) {
1821
1790
  s0.push(s1);
1822
1791
  s1 = input.charAt(peg$currPos);
1823
- if (peg$r7.test(s1)) {
1792
+ if (peg$r8.test(s1)) {
1824
1793
  peg$currPos++;
1825
1794
  } else {
1826
1795
  s1 = peg$FAILED;
@@ -1842,7 +1811,7 @@ function peg$parse(input, options) {
1842
1811
  if (s2 !== peg$FAILED) {
1843
1812
  s3 = [];
1844
1813
  s4 = input.charAt(peg$currPos);
1845
- if (peg$r7.test(s4)) {
1814
+ if (peg$r8.test(s4)) {
1846
1815
  peg$currPos++;
1847
1816
  } else {
1848
1817
  s4 = peg$FAILED;
@@ -1853,7 +1822,7 @@ function peg$parse(input, options) {
1853
1822
  while (s4 !== peg$FAILED) {
1854
1823
  s3.push(s4);
1855
1824
  s4 = input.charAt(peg$currPos);
1856
- if (peg$r7.test(s4)) {
1825
+ if (peg$r8.test(s4)) {
1857
1826
  peg$currPos++;
1858
1827
  } else {
1859
1828
  s4 = peg$FAILED;
@@ -1874,7 +1843,7 @@ function peg$parse(input, options) {
1874
1843
  if (s4 !== peg$FAILED) {
1875
1844
  s5 = [];
1876
1845
  s6 = input.charAt(peg$currPos);
1877
- if (peg$r7.test(s6)) {
1846
+ if (peg$r8.test(s6)) {
1878
1847
  peg$currPos++;
1879
1848
  } else {
1880
1849
  s6 = peg$FAILED;
@@ -1885,7 +1854,7 @@ function peg$parse(input, options) {
1885
1854
  while (s6 !== peg$FAILED) {
1886
1855
  s5.push(s6);
1887
1856
  s6 = input.charAt(peg$currPos);
1888
- if (peg$r7.test(s6)) {
1857
+ if (peg$r8.test(s6)) {
1889
1858
  peg$currPos++;
1890
1859
  } else {
1891
1860
  s6 = peg$FAILED;
@@ -1908,7 +1877,7 @@ function peg$parse(input, options) {
1908
1877
  }
1909
1878
  return s0;
1910
1879
  }
1911
- chunkKJP2NVDR_js.__name(peg$parse_decWs, "peg$parse_decWs");
1880
+ chunkEWY3F3XT_js.__name(peg$parse_decWs, "peg$parse_decWs");
1912
1881
  function peg$parseFunctionCall() {
1913
1882
  let s0, s1, s2;
1914
1883
  s0 = peg$currPos;
@@ -1928,40 +1897,40 @@ function peg$parse(input, options) {
1928
1897
  }
1929
1898
  return s0;
1930
1899
  }
1931
- chunkKJP2NVDR_js.__name(peg$parseFunctionCall, "peg$parseFunctionCall");
1900
+ chunkEWY3F3XT_js.__name(peg$parseFunctionCall, "peg$parseFunctionCall");
1932
1901
  function peg$parseFunctionName() {
1933
1902
  let s0, s1, s2, s3, s4;
1934
1903
  s0 = peg$currPos;
1935
1904
  s1 = peg$currPos;
1936
1905
  s2 = input.charAt(peg$currPos);
1937
- if (peg$r3.test(s2)) {
1906
+ if (peg$r5.test(s2)) {
1938
1907
  peg$currPos++;
1939
1908
  } else {
1940
1909
  s2 = peg$FAILED;
1941
1910
  if (peg$silentFails === 0) {
1942
- peg$fail(peg$e8);
1911
+ peg$fail(peg$e10);
1943
1912
  }
1944
1913
  }
1945
1914
  if (s2 !== peg$FAILED) {
1946
1915
  s3 = [];
1947
1916
  s4 = input.charAt(peg$currPos);
1948
- if (peg$r5.test(s4)) {
1917
+ if (peg$r9.test(s4)) {
1949
1918
  peg$currPos++;
1950
1919
  } else {
1951
1920
  s4 = peg$FAILED;
1952
1921
  if (peg$silentFails === 0) {
1953
- peg$fail(peg$e11);
1922
+ peg$fail(peg$e17);
1954
1923
  }
1955
1924
  }
1956
1925
  while (s4 !== peg$FAILED) {
1957
1926
  s3.push(s4);
1958
1927
  s4 = input.charAt(peg$currPos);
1959
- if (peg$r5.test(s4)) {
1928
+ if (peg$r9.test(s4)) {
1960
1929
  peg$currPos++;
1961
1930
  } else {
1962
1931
  s4 = peg$FAILED;
1963
1932
  if (peg$silentFails === 0) {
1964
- peg$fail(peg$e11);
1933
+ peg$fail(peg$e17);
1965
1934
  }
1966
1935
  }
1967
1936
  }
@@ -1978,12 +1947,12 @@ function peg$parse(input, options) {
1978
1947
  }
1979
1948
  return s0;
1980
1949
  }
1981
- chunkKJP2NVDR_js.__name(peg$parseFunctionName, "peg$parseFunctionName");
1950
+ chunkEWY3F3XT_js.__name(peg$parseFunctionName, "peg$parseFunctionName");
1982
1951
  function peg$parseFunctionArgs() {
1983
1952
  let s0, s1, s3, s4, s5, s6, s7, s8, s9;
1984
1953
  s0 = peg$currPos;
1985
1954
  if (input.charCodeAt(peg$currPos) === 40) {
1986
- s1 = peg$c6;
1955
+ s1 = peg$c5;
1987
1956
  peg$currPos++;
1988
1957
  } else {
1989
1958
  s1 = peg$FAILED;
@@ -2033,7 +2002,7 @@ function peg$parse(input, options) {
2033
2002
  s6 = peg$currPos;
2034
2003
  s7 = peg$parse_valWs();
2035
2004
  if (input.charCodeAt(peg$currPos) === 44) {
2036
- s8 = peg$c7;
2005
+ s8 = peg$c6;
2037
2006
  peg$currPos++;
2038
2007
  } else {
2039
2008
  s8 = peg$FAILED;
@@ -2104,7 +2073,7 @@ function peg$parse(input, options) {
2104
2073
  s4 = peg$currPos;
2105
2074
  s5 = peg$parse_valWs();
2106
2075
  if (input.charCodeAt(peg$currPos) === 44) {
2107
- s6 = peg$c7;
2076
+ s6 = peg$c6;
2108
2077
  peg$currPos++;
2109
2078
  } else {
2110
2079
  s6 = peg$FAILED;
@@ -2124,7 +2093,7 @@ function peg$parse(input, options) {
2124
2093
  }
2125
2094
  s5 = peg$parse_valWs();
2126
2095
  if (input.charCodeAt(peg$currPos) === 41) {
2127
- s6 = peg$c8;
2096
+ s6 = peg$c7;
2128
2097
  peg$currPos++;
2129
2098
  } else {
2130
2099
  s6 = peg$FAILED;
@@ -2145,40 +2114,40 @@ function peg$parse(input, options) {
2145
2114
  }
2146
2115
  return s0;
2147
2116
  }
2148
- chunkKJP2NVDR_js.__name(peg$parseFunctionArgs, "peg$parseFunctionArgs");
2117
+ chunkEWY3F3XT_js.__name(peg$parseFunctionArgs, "peg$parseFunctionArgs");
2149
2118
  function peg$parseFunctionArgKeyName() {
2150
2119
  let s0, s1, s2, s3, s4;
2151
2120
  s0 = peg$currPos;
2152
2121
  s1 = peg$currPos;
2153
2122
  s2 = input.charAt(peg$currPos);
2154
- if (peg$r3.test(s2)) {
2123
+ if (peg$r5.test(s2)) {
2155
2124
  peg$currPos++;
2156
2125
  } else {
2157
2126
  s2 = peg$FAILED;
2158
2127
  if (peg$silentFails === 0) {
2159
- peg$fail(peg$e8);
2128
+ peg$fail(peg$e10);
2160
2129
  }
2161
2130
  }
2162
2131
  if (s2 !== peg$FAILED) {
2163
2132
  s3 = [];
2164
2133
  s4 = input.charAt(peg$currPos);
2165
- if (peg$r5.test(s4)) {
2134
+ if (peg$r9.test(s4)) {
2166
2135
  peg$currPos++;
2167
2136
  } else {
2168
2137
  s4 = peg$FAILED;
2169
2138
  if (peg$silentFails === 0) {
2170
- peg$fail(peg$e11);
2139
+ peg$fail(peg$e17);
2171
2140
  }
2172
2141
  }
2173
2142
  while (s4 !== peg$FAILED) {
2174
2143
  s3.push(s4);
2175
2144
  s4 = input.charAt(peg$currPos);
2176
- if (peg$r5.test(s4)) {
2145
+ if (peg$r9.test(s4)) {
2177
2146
  peg$currPos++;
2178
2147
  } else {
2179
2148
  s4 = peg$FAILED;
2180
2149
  if (peg$silentFails === 0) {
2181
- peg$fail(peg$e11);
2150
+ peg$fail(peg$e17);
2182
2151
  }
2183
2152
  }
2184
2153
  }
@@ -2195,7 +2164,7 @@ function peg$parse(input, options) {
2195
2164
  }
2196
2165
  return s0;
2197
2166
  }
2198
- chunkKJP2NVDR_js.__name(peg$parseFunctionArgKeyName, "peg$parseFunctionArgKeyName");
2167
+ chunkEWY3F3XT_js.__name(peg$parseFunctionArgKeyName, "peg$parseFunctionArgKeyName");
2199
2168
  function peg$parseFunctionArgValue() {
2200
2169
  let s0, s1, s2, s3;
2201
2170
  s0 = peg$parseFunctionCall();
@@ -2206,7 +2175,7 @@ function peg$parse(input, options) {
2206
2175
  s1 = peg$currPos;
2207
2176
  s2 = [];
2208
2177
  s3 = input.charAt(peg$currPos);
2209
- if (peg$r6.test(s3)) {
2178
+ if (peg$r7.test(s3)) {
2210
2179
  peg$currPos++;
2211
2180
  } else {
2212
2181
  s3 = peg$FAILED;
@@ -2218,7 +2187,7 @@ function peg$parse(input, options) {
2218
2187
  while (s3 !== peg$FAILED) {
2219
2188
  s2.push(s3);
2220
2189
  s3 = input.charAt(peg$currPos);
2221
- if (peg$r6.test(s3)) {
2190
+ if (peg$r7.test(s3)) {
2222
2191
  peg$currPos++;
2223
2192
  } else {
2224
2193
  s3 = peg$FAILED;
@@ -2244,34 +2213,34 @@ function peg$parse(input, options) {
2244
2213
  }
2245
2214
  return s0;
2246
2215
  }
2247
- chunkKJP2NVDR_js.__name(peg$parseFunctionArgValue, "peg$parseFunctionArgValue");
2216
+ chunkEWY3F3XT_js.__name(peg$parseFunctionArgValue, "peg$parseFunctionArgValue");
2248
2217
  function peg$parse_valWs() {
2249
2218
  let s0, s1;
2250
2219
  s0 = [];
2251
2220
  s1 = input.charAt(peg$currPos);
2252
- if (peg$r8.test(s1)) {
2221
+ if (peg$r10.test(s1)) {
2253
2222
  peg$currPos++;
2254
2223
  } else {
2255
2224
  s1 = peg$FAILED;
2256
2225
  if (peg$silentFails === 0) {
2257
- peg$fail(peg$e17);
2226
+ peg$fail(peg$e18);
2258
2227
  }
2259
2228
  }
2260
2229
  while (s1 !== peg$FAILED) {
2261
2230
  s0.push(s1);
2262
2231
  s1 = input.charAt(peg$currPos);
2263
- if (peg$r8.test(s1)) {
2232
+ if (peg$r10.test(s1)) {
2264
2233
  peg$currPos++;
2265
2234
  } else {
2266
2235
  s1 = peg$FAILED;
2267
2236
  if (peg$silentFails === 0) {
2268
- peg$fail(peg$e17);
2237
+ peg$fail(peg$e18);
2269
2238
  }
2270
2239
  }
2271
2240
  }
2272
2241
  return s0;
2273
2242
  }
2274
- chunkKJP2NVDR_js.__name(peg$parse_valWs, "peg$parse_valWs");
2243
+ chunkEWY3F3XT_js.__name(peg$parse_valWs, "peg$parse_valWs");
2275
2244
  function peg$parseDivider() {
2276
2245
  let s0, s1, s2, s3, s4, s5, s6, s7;
2277
2246
  s0 = peg$currPos;
@@ -2293,23 +2262,23 @@ function peg$parse(input, options) {
2293
2262
  s5 = peg$currPos;
2294
2263
  s6 = [];
2295
2264
  s7 = input.charAt(peg$currPos);
2296
- if (peg$r9.test(s7)) {
2265
+ if (peg$r11.test(s7)) {
2297
2266
  peg$currPos++;
2298
2267
  } else {
2299
2268
  s7 = peg$FAILED;
2300
2269
  if (peg$silentFails === 0) {
2301
- peg$fail(peg$e18);
2270
+ peg$fail(peg$e19);
2302
2271
  }
2303
2272
  }
2304
2273
  while (s7 !== peg$FAILED) {
2305
2274
  s6.push(s7);
2306
2275
  s7 = input.charAt(peg$currPos);
2307
- if (peg$r9.test(s7)) {
2276
+ if (peg$r11.test(s7)) {
2308
2277
  peg$currPos++;
2309
2278
  } else {
2310
2279
  s7 = peg$FAILED;
2311
2280
  if (peg$silentFails === 0) {
2312
- peg$fail(peg$e18);
2281
+ peg$fail(peg$e19);
2313
2282
  }
2314
2283
  }
2315
2284
  }
@@ -2372,7 +2341,7 @@ function peg$parse(input, options) {
2372
2341
  }
2373
2342
  return s0;
2374
2343
  }
2375
- chunkKJP2NVDR_js.__name(peg$parseDivider, "peg$parseDivider");
2344
+ chunkEWY3F3XT_js.__name(peg$parseDivider, "peg$parseDivider");
2376
2345
  function peg$parseunquotedString() {
2377
2346
  let s0, s1, s2, s3, s4, s5, s6;
2378
2347
  s0 = peg$currPos;
@@ -2382,12 +2351,12 @@ function peg$parse(input, options) {
2382
2351
  s4 = peg$currPos;
2383
2352
  peg$silentFails++;
2384
2353
  s5 = input.charAt(peg$currPos);
2385
- if (peg$r10.test(s5)) {
2354
+ if (peg$r12.test(s5)) {
2386
2355
  peg$currPos++;
2387
2356
  } else {
2388
2357
  s5 = peg$FAILED;
2389
2358
  if (peg$silentFails === 0) {
2390
- peg$fail(peg$e19);
2359
+ peg$fail(peg$e20);
2391
2360
  }
2392
2361
  }
2393
2362
  peg$silentFails--;
@@ -2400,24 +2369,24 @@ function peg$parse(input, options) {
2400
2369
  if (s4 !== peg$FAILED) {
2401
2370
  s5 = [];
2402
2371
  s6 = input.charAt(peg$currPos);
2403
- if (peg$r11.test(s6)) {
2372
+ if (peg$r13.test(s6)) {
2404
2373
  peg$currPos++;
2405
2374
  } else {
2406
2375
  s6 = peg$FAILED;
2407
2376
  if (peg$silentFails === 0) {
2408
- peg$fail(peg$e20);
2377
+ peg$fail(peg$e21);
2409
2378
  }
2410
2379
  }
2411
2380
  if (s6 !== peg$FAILED) {
2412
2381
  while (s6 !== peg$FAILED) {
2413
2382
  s5.push(s6);
2414
2383
  s6 = input.charAt(peg$currPos);
2415
- if (peg$r11.test(s6)) {
2384
+ if (peg$r13.test(s6)) {
2416
2385
  peg$currPos++;
2417
2386
  } else {
2418
2387
  s6 = peg$FAILED;
2419
2388
  if (peg$silentFails === 0) {
2420
- peg$fail(peg$e20);
2389
+ peg$fail(peg$e21);
2421
2390
  }
2422
2391
  }
2423
2392
  }
@@ -2447,7 +2416,7 @@ function peg$parse(input, options) {
2447
2416
  s0 = s1;
2448
2417
  return s0;
2449
2418
  }
2450
- chunkKJP2NVDR_js.__name(peg$parseunquotedString, "peg$parseunquotedString");
2419
+ chunkEWY3F3XT_js.__name(peg$parseunquotedString, "peg$parseunquotedString");
2451
2420
  function peg$parseunquotedStringWithoutSpaces() {
2452
2421
  let s0, s1, s2, s3, s4, s5;
2453
2422
  s0 = peg$currPos;
@@ -2456,12 +2425,12 @@ function peg$parse(input, options) {
2456
2425
  s3 = peg$currPos;
2457
2426
  peg$silentFails++;
2458
2427
  s4 = input.charAt(peg$currPos);
2459
- if (peg$r10.test(s4)) {
2428
+ if (peg$r12.test(s4)) {
2460
2429
  peg$currPos++;
2461
2430
  } else {
2462
2431
  s4 = peg$FAILED;
2463
2432
  if (peg$silentFails === 0) {
2464
- peg$fail(peg$e19);
2433
+ peg$fail(peg$e20);
2465
2434
  }
2466
2435
  }
2467
2436
  peg$silentFails--;
@@ -2474,24 +2443,24 @@ function peg$parse(input, options) {
2474
2443
  if (s3 !== peg$FAILED) {
2475
2444
  s4 = [];
2476
2445
  s5 = input.charAt(peg$currPos);
2477
- if (peg$r12.test(s5)) {
2446
+ if (peg$r14.test(s5)) {
2478
2447
  peg$currPos++;
2479
2448
  } else {
2480
2449
  s5 = peg$FAILED;
2481
2450
  if (peg$silentFails === 0) {
2482
- peg$fail(peg$e21);
2451
+ peg$fail(peg$e22);
2483
2452
  }
2484
2453
  }
2485
2454
  if (s5 !== peg$FAILED) {
2486
2455
  while (s5 !== peg$FAILED) {
2487
2456
  s4.push(s5);
2488
2457
  s5 = input.charAt(peg$currPos);
2489
- if (peg$r12.test(s5)) {
2458
+ if (peg$r14.test(s5)) {
2490
2459
  peg$currPos++;
2491
2460
  } else {
2492
2461
  s5 = peg$FAILED;
2493
2462
  if (peg$silentFails === 0) {
2494
- peg$fail(peg$e21);
2463
+ peg$fail(peg$e22);
2495
2464
  }
2496
2465
  }
2497
2466
  }
@@ -2521,7 +2490,7 @@ function peg$parse(input, options) {
2521
2490
  s0 = s1;
2522
2491
  return s0;
2523
2492
  }
2524
- chunkKJP2NVDR_js.__name(peg$parseunquotedStringWithoutSpaces, "peg$parseunquotedStringWithoutSpaces");
2493
+ chunkEWY3F3XT_js.__name(peg$parseunquotedStringWithoutSpaces, "peg$parseunquotedStringWithoutSpaces");
2525
2494
  function peg$parsequotedString() {
2526
2495
  let s0;
2527
2496
  s0 = peg$parseDQuotedString();
@@ -2533,71 +2502,71 @@ function peg$parse(input, options) {
2533
2502
  }
2534
2503
  return s0;
2535
2504
  }
2536
- chunkKJP2NVDR_js.__name(peg$parsequotedString, "peg$parsequotedString");
2505
+ chunkEWY3F3XT_js.__name(peg$parsequotedString, "peg$parsequotedString");
2537
2506
  function peg$parseDQuotedString() {
2538
2507
  let s0, s1, s2, s3;
2539
2508
  s0 = peg$currPos;
2540
2509
  s1 = input.charAt(peg$currPos);
2541
- if (peg$r13.test(s1)) {
2510
+ if (peg$r15.test(s1)) {
2542
2511
  peg$currPos++;
2543
2512
  } else {
2544
2513
  s1 = peg$FAILED;
2545
2514
  if (peg$silentFails === 0) {
2546
- peg$fail(peg$e22);
2515
+ peg$fail(peg$e23);
2547
2516
  }
2548
2517
  }
2549
2518
  if (s1 !== peg$FAILED) {
2550
2519
  s2 = [];
2551
- if (input.substr(peg$currPos, 2) === peg$c9) {
2552
- s3 = peg$c9;
2520
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2521
+ s3 = peg$c8;
2553
2522
  peg$currPos += 2;
2554
2523
  } else {
2555
2524
  s3 = peg$FAILED;
2556
2525
  if (peg$silentFails === 0) {
2557
- peg$fail(peg$e23);
2526
+ peg$fail(peg$e24);
2558
2527
  }
2559
2528
  }
2560
2529
  if (s3 === peg$FAILED) {
2561
2530
  s3 = input.charAt(peg$currPos);
2562
- if (peg$r14.test(s3)) {
2531
+ if (peg$r16.test(s3)) {
2563
2532
  peg$currPos++;
2564
2533
  } else {
2565
2534
  s3 = peg$FAILED;
2566
2535
  if (peg$silentFails === 0) {
2567
- peg$fail(peg$e24);
2536
+ peg$fail(peg$e25);
2568
2537
  }
2569
2538
  }
2570
2539
  }
2571
2540
  while (s3 !== peg$FAILED) {
2572
2541
  s2.push(s3);
2573
- if (input.substr(peg$currPos, 2) === peg$c9) {
2574
- s3 = peg$c9;
2542
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2543
+ s3 = peg$c8;
2575
2544
  peg$currPos += 2;
2576
2545
  } else {
2577
2546
  s3 = peg$FAILED;
2578
2547
  if (peg$silentFails === 0) {
2579
- peg$fail(peg$e23);
2548
+ peg$fail(peg$e24);
2580
2549
  }
2581
2550
  }
2582
2551
  if (s3 === peg$FAILED) {
2583
2552
  s3 = input.charAt(peg$currPos);
2584
- if (peg$r14.test(s3)) {
2553
+ if (peg$r16.test(s3)) {
2585
2554
  peg$currPos++;
2586
2555
  } else {
2587
2556
  s3 = peg$FAILED;
2588
2557
  if (peg$silentFails === 0) {
2589
- peg$fail(peg$e24);
2558
+ peg$fail(peg$e25);
2590
2559
  }
2591
2560
  }
2592
2561
  }
2593
2562
  }
2594
2563
  s3 = input.charAt(peg$currPos);
2595
- if (peg$r13.test(s3)) {
2564
+ if (peg$r15.test(s3)) {
2596
2565
  peg$currPos++;
2597
2566
  } else {
2598
2567
  s3 = peg$FAILED;
2599
2568
  if (peg$silentFails === 0) {
2600
- peg$fail(peg$e22);
2569
+ peg$fail(peg$e23);
2601
2570
  }
2602
2571
  }
2603
2572
  if (s3 !== peg$FAILED) {
@@ -2613,71 +2582,71 @@ function peg$parse(input, options) {
2613
2582
  }
2614
2583
  return s0;
2615
2584
  }
2616
- chunkKJP2NVDR_js.__name(peg$parseDQuotedString, "peg$parseDQuotedString");
2585
+ chunkEWY3F3XT_js.__name(peg$parseDQuotedString, "peg$parseDQuotedString");
2617
2586
  function peg$parseSQuotedString() {
2618
2587
  let s0, s1, s2, s3;
2619
2588
  s0 = peg$currPos;
2620
2589
  s1 = input.charAt(peg$currPos);
2621
- if (peg$r15.test(s1)) {
2590
+ if (peg$r17.test(s1)) {
2622
2591
  peg$currPos++;
2623
2592
  } else {
2624
2593
  s1 = peg$FAILED;
2625
2594
  if (peg$silentFails === 0) {
2626
- peg$fail(peg$e25);
2595
+ peg$fail(peg$e26);
2627
2596
  }
2628
2597
  }
2629
2598
  if (s1 !== peg$FAILED) {
2630
2599
  s2 = [];
2631
- if (input.substr(peg$currPos, 2) === peg$c10) {
2632
- s3 = peg$c10;
2600
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2601
+ s3 = peg$c9;
2633
2602
  peg$currPos += 2;
2634
2603
  } else {
2635
2604
  s3 = peg$FAILED;
2636
2605
  if (peg$silentFails === 0) {
2637
- peg$fail(peg$e26);
2606
+ peg$fail(peg$e27);
2638
2607
  }
2639
2608
  }
2640
2609
  if (s3 === peg$FAILED) {
2641
2610
  s3 = input.charAt(peg$currPos);
2642
- if (peg$r16.test(s3)) {
2611
+ if (peg$r18.test(s3)) {
2643
2612
  peg$currPos++;
2644
2613
  } else {
2645
2614
  s3 = peg$FAILED;
2646
2615
  if (peg$silentFails === 0) {
2647
- peg$fail(peg$e27);
2616
+ peg$fail(peg$e28);
2648
2617
  }
2649
2618
  }
2650
2619
  }
2651
2620
  while (s3 !== peg$FAILED) {
2652
2621
  s2.push(s3);
2653
- if (input.substr(peg$currPos, 2) === peg$c10) {
2654
- s3 = peg$c10;
2622
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2623
+ s3 = peg$c9;
2655
2624
  peg$currPos += 2;
2656
2625
  } else {
2657
2626
  s3 = peg$FAILED;
2658
2627
  if (peg$silentFails === 0) {
2659
- peg$fail(peg$e26);
2628
+ peg$fail(peg$e27);
2660
2629
  }
2661
2630
  }
2662
2631
  if (s3 === peg$FAILED) {
2663
2632
  s3 = input.charAt(peg$currPos);
2664
- if (peg$r16.test(s3)) {
2633
+ if (peg$r18.test(s3)) {
2665
2634
  peg$currPos++;
2666
2635
  } else {
2667
2636
  s3 = peg$FAILED;
2668
2637
  if (peg$silentFails === 0) {
2669
- peg$fail(peg$e27);
2638
+ peg$fail(peg$e28);
2670
2639
  }
2671
2640
  }
2672
2641
  }
2673
2642
  }
2674
2643
  s3 = input.charAt(peg$currPos);
2675
- if (peg$r15.test(s3)) {
2644
+ if (peg$r17.test(s3)) {
2676
2645
  peg$currPos++;
2677
2646
  } else {
2678
2647
  s3 = peg$FAILED;
2679
2648
  if (peg$silentFails === 0) {
2680
- peg$fail(peg$e25);
2649
+ peg$fail(peg$e26);
2681
2650
  }
2682
2651
  }
2683
2652
  if (s3 !== peg$FAILED) {
@@ -2693,71 +2662,71 @@ function peg$parse(input, options) {
2693
2662
  }
2694
2663
  return s0;
2695
2664
  }
2696
- chunkKJP2NVDR_js.__name(peg$parseSQuotedString, "peg$parseSQuotedString");
2665
+ chunkEWY3F3XT_js.__name(peg$parseSQuotedString, "peg$parseSQuotedString");
2697
2666
  function peg$parseBQuotedString() {
2698
2667
  let s0, s1, s2, s3;
2699
2668
  s0 = peg$currPos;
2700
2669
  s1 = input.charAt(peg$currPos);
2701
- if (peg$r17.test(s1)) {
2670
+ if (peg$r19.test(s1)) {
2702
2671
  peg$currPos++;
2703
2672
  } else {
2704
2673
  s1 = peg$FAILED;
2705
2674
  if (peg$silentFails === 0) {
2706
- peg$fail(peg$e28);
2675
+ peg$fail(peg$e29);
2707
2676
  }
2708
2677
  }
2709
2678
  if (s1 !== peg$FAILED) {
2710
2679
  s2 = [];
2711
- if (input.substr(peg$currPos, 2) === peg$c11) {
2712
- s3 = peg$c11;
2680
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2681
+ s3 = peg$c10;
2713
2682
  peg$currPos += 2;
2714
2683
  } else {
2715
2684
  s3 = peg$FAILED;
2716
2685
  if (peg$silentFails === 0) {
2717
- peg$fail(peg$e29);
2686
+ peg$fail(peg$e30);
2718
2687
  }
2719
2688
  }
2720
2689
  if (s3 === peg$FAILED) {
2721
2690
  s3 = input.charAt(peg$currPos);
2722
- if (peg$r18.test(s3)) {
2691
+ if (peg$r20.test(s3)) {
2723
2692
  peg$currPos++;
2724
2693
  } else {
2725
2694
  s3 = peg$FAILED;
2726
2695
  if (peg$silentFails === 0) {
2727
- peg$fail(peg$e30);
2696
+ peg$fail(peg$e31);
2728
2697
  }
2729
2698
  }
2730
2699
  }
2731
2700
  while (s3 !== peg$FAILED) {
2732
2701
  s2.push(s3);
2733
- if (input.substr(peg$currPos, 2) === peg$c11) {
2734
- s3 = peg$c11;
2702
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2703
+ s3 = peg$c10;
2735
2704
  peg$currPos += 2;
2736
2705
  } else {
2737
2706
  s3 = peg$FAILED;
2738
2707
  if (peg$silentFails === 0) {
2739
- peg$fail(peg$e29);
2708
+ peg$fail(peg$e30);
2740
2709
  }
2741
2710
  }
2742
2711
  if (s3 === peg$FAILED) {
2743
2712
  s3 = input.charAt(peg$currPos);
2744
- if (peg$r18.test(s3)) {
2713
+ if (peg$r20.test(s3)) {
2745
2714
  peg$currPos++;
2746
2715
  } else {
2747
2716
  s3 = peg$FAILED;
2748
2717
  if (peg$silentFails === 0) {
2749
- peg$fail(peg$e30);
2718
+ peg$fail(peg$e31);
2750
2719
  }
2751
2720
  }
2752
2721
  }
2753
2722
  }
2754
2723
  s3 = input.charAt(peg$currPos);
2755
- if (peg$r17.test(s3)) {
2724
+ if (peg$r19.test(s3)) {
2756
2725
  peg$currPos++;
2757
2726
  } else {
2758
2727
  s3 = peg$FAILED;
2759
2728
  if (peg$silentFails === 0) {
2760
- peg$fail(peg$e28);
2729
+ peg$fail(peg$e29);
2761
2730
  }
2762
2731
  }
2763
2732
  if (s3 !== peg$FAILED) {
@@ -2773,7 +2742,7 @@ function peg$parse(input, options) {
2773
2742
  }
2774
2743
  return s0;
2775
2744
  }
2776
- chunkKJP2NVDR_js.__name(peg$parseBQuotedString, "peg$parseBQuotedString");
2745
+ chunkEWY3F3XT_js.__name(peg$parseBQuotedString, "peg$parseBQuotedString");
2777
2746
  function peg$parsemultiLineString() {
2778
2747
  let s0;
2779
2748
  s0 = peg$parsesingleSQuotedMultiLineString();
@@ -2788,62 +2757,62 @@ function peg$parse(input, options) {
2788
2757
  }
2789
2758
  return s0;
2790
2759
  }
2791
- chunkKJP2NVDR_js.__name(peg$parsemultiLineString, "peg$parsemultiLineString");
2760
+ chunkEWY3F3XT_js.__name(peg$parsemultiLineString, "peg$parsemultiLineString");
2792
2761
  function peg$parsesingleSQuotedMultiLineString() {
2793
2762
  let s0, s1, s2, s3, s4, s5;
2794
2763
  s0 = peg$currPos;
2795
2764
  s1 = input.charAt(peg$currPos);
2796
- if (peg$r15.test(s1)) {
2765
+ if (peg$r17.test(s1)) {
2797
2766
  peg$currPos++;
2798
2767
  } else {
2799
2768
  s1 = peg$FAILED;
2800
2769
  if (peg$silentFails === 0) {
2801
- peg$fail(peg$e25);
2770
+ peg$fail(peg$e26);
2802
2771
  }
2803
2772
  }
2804
2773
  if (s1 !== peg$FAILED) {
2805
2774
  s2 = [];
2806
2775
  s3 = peg$currPos;
2807
2776
  s4 = [];
2808
- if (input.substr(peg$currPos, 2) === peg$c10) {
2809
- s5 = peg$c10;
2777
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2778
+ s5 = peg$c9;
2810
2779
  peg$currPos += 2;
2811
2780
  } else {
2812
2781
  s5 = peg$FAILED;
2813
2782
  if (peg$silentFails === 0) {
2814
- peg$fail(peg$e26);
2783
+ peg$fail(peg$e27);
2815
2784
  }
2816
2785
  }
2817
2786
  if (s5 === peg$FAILED) {
2818
2787
  s5 = input.charAt(peg$currPos);
2819
- if (peg$r16.test(s5)) {
2788
+ if (peg$r18.test(s5)) {
2820
2789
  peg$currPos++;
2821
2790
  } else {
2822
2791
  s5 = peg$FAILED;
2823
2792
  if (peg$silentFails === 0) {
2824
- peg$fail(peg$e27);
2793
+ peg$fail(peg$e28);
2825
2794
  }
2826
2795
  }
2827
2796
  }
2828
2797
  while (s5 !== peg$FAILED) {
2829
2798
  s4.push(s5);
2830
- if (input.substr(peg$currPos, 2) === peg$c10) {
2831
- s5 = peg$c10;
2799
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2800
+ s5 = peg$c9;
2832
2801
  peg$currPos += 2;
2833
2802
  } else {
2834
2803
  s5 = peg$FAILED;
2835
2804
  if (peg$silentFails === 0) {
2836
- peg$fail(peg$e26);
2805
+ peg$fail(peg$e27);
2837
2806
  }
2838
2807
  }
2839
2808
  if (s5 === peg$FAILED) {
2840
2809
  s5 = input.charAt(peg$currPos);
2841
- if (peg$r16.test(s5)) {
2810
+ if (peg$r18.test(s5)) {
2842
2811
  peg$currPos++;
2843
2812
  } else {
2844
2813
  s5 = peg$FAILED;
2845
2814
  if (peg$silentFails === 0) {
2846
- peg$fail(peg$e27);
2815
+ peg$fail(peg$e28);
2847
2816
  }
2848
2817
  }
2849
2818
  }
@@ -2869,45 +2838,45 @@ function peg$parse(input, options) {
2869
2838
  s2.push(s3);
2870
2839
  s3 = peg$currPos;
2871
2840
  s4 = [];
2872
- if (input.substr(peg$currPos, 2) === peg$c10) {
2873
- s5 = peg$c10;
2841
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2842
+ s5 = peg$c9;
2874
2843
  peg$currPos += 2;
2875
2844
  } else {
2876
2845
  s5 = peg$FAILED;
2877
2846
  if (peg$silentFails === 0) {
2878
- peg$fail(peg$e26);
2847
+ peg$fail(peg$e27);
2879
2848
  }
2880
2849
  }
2881
2850
  if (s5 === peg$FAILED) {
2882
2851
  s5 = input.charAt(peg$currPos);
2883
- if (peg$r16.test(s5)) {
2852
+ if (peg$r18.test(s5)) {
2884
2853
  peg$currPos++;
2885
2854
  } else {
2886
2855
  s5 = peg$FAILED;
2887
2856
  if (peg$silentFails === 0) {
2888
- peg$fail(peg$e27);
2857
+ peg$fail(peg$e28);
2889
2858
  }
2890
2859
  }
2891
2860
  }
2892
2861
  while (s5 !== peg$FAILED) {
2893
2862
  s4.push(s5);
2894
- if (input.substr(peg$currPos, 2) === peg$c10) {
2895
- s5 = peg$c10;
2863
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2864
+ s5 = peg$c9;
2896
2865
  peg$currPos += 2;
2897
2866
  } else {
2898
2867
  s5 = peg$FAILED;
2899
2868
  if (peg$silentFails === 0) {
2900
- peg$fail(peg$e26);
2869
+ peg$fail(peg$e27);
2901
2870
  }
2902
2871
  }
2903
2872
  if (s5 === peg$FAILED) {
2904
2873
  s5 = input.charAt(peg$currPos);
2905
- if (peg$r16.test(s5)) {
2874
+ if (peg$r18.test(s5)) {
2906
2875
  peg$currPos++;
2907
2876
  } else {
2908
2877
  s5 = peg$FAILED;
2909
2878
  if (peg$silentFails === 0) {
2910
- peg$fail(peg$e27);
2879
+ peg$fail(peg$e28);
2911
2880
  }
2912
2881
  }
2913
2882
  }
@@ -2934,56 +2903,56 @@ function peg$parse(input, options) {
2934
2903
  }
2935
2904
  if (s2 !== peg$FAILED) {
2936
2905
  s3 = [];
2937
- if (input.substr(peg$currPos, 2) === peg$c10) {
2938
- s4 = peg$c10;
2906
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2907
+ s4 = peg$c9;
2939
2908
  peg$currPos += 2;
2940
2909
  } else {
2941
2910
  s4 = peg$FAILED;
2942
2911
  if (peg$silentFails === 0) {
2943
- peg$fail(peg$e26);
2912
+ peg$fail(peg$e27);
2944
2913
  }
2945
2914
  }
2946
2915
  if (s4 === peg$FAILED) {
2947
2916
  s4 = input.charAt(peg$currPos);
2948
- if (peg$r16.test(s4)) {
2917
+ if (peg$r18.test(s4)) {
2949
2918
  peg$currPos++;
2950
2919
  } else {
2951
2920
  s4 = peg$FAILED;
2952
2921
  if (peg$silentFails === 0) {
2953
- peg$fail(peg$e27);
2922
+ peg$fail(peg$e28);
2954
2923
  }
2955
2924
  }
2956
2925
  }
2957
2926
  while (s4 !== peg$FAILED) {
2958
2927
  s3.push(s4);
2959
- if (input.substr(peg$currPos, 2) === peg$c10) {
2960
- s4 = peg$c10;
2928
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2929
+ s4 = peg$c9;
2961
2930
  peg$currPos += 2;
2962
2931
  } else {
2963
2932
  s4 = peg$FAILED;
2964
2933
  if (peg$silentFails === 0) {
2965
- peg$fail(peg$e26);
2934
+ peg$fail(peg$e27);
2966
2935
  }
2967
2936
  }
2968
2937
  if (s4 === peg$FAILED) {
2969
2938
  s4 = input.charAt(peg$currPos);
2970
- if (peg$r16.test(s4)) {
2939
+ if (peg$r18.test(s4)) {
2971
2940
  peg$currPos++;
2972
2941
  } else {
2973
2942
  s4 = peg$FAILED;
2974
2943
  if (peg$silentFails === 0) {
2975
- peg$fail(peg$e27);
2944
+ peg$fail(peg$e28);
2976
2945
  }
2977
2946
  }
2978
2947
  }
2979
2948
  }
2980
2949
  s4 = input.charAt(peg$currPos);
2981
- if (peg$r15.test(s4)) {
2950
+ if (peg$r17.test(s4)) {
2982
2951
  peg$currPos++;
2983
2952
  } else {
2984
2953
  s4 = peg$FAILED;
2985
2954
  if (peg$silentFails === 0) {
2986
- peg$fail(peg$e25);
2955
+ peg$fail(peg$e26);
2987
2956
  }
2988
2957
  }
2989
2958
  if (s4 !== peg$FAILED) {
@@ -3003,62 +2972,62 @@ function peg$parse(input, options) {
3003
2972
  }
3004
2973
  return s0;
3005
2974
  }
3006
- chunkKJP2NVDR_js.__name(peg$parsesingleSQuotedMultiLineString, "peg$parsesingleSQuotedMultiLineString");
2975
+ chunkEWY3F3XT_js.__name(peg$parsesingleSQuotedMultiLineString, "peg$parsesingleSQuotedMultiLineString");
3007
2976
  function peg$parsesingleDQuotedMultiLineString() {
3008
2977
  let s0, s1, s2, s3, s4, s5;
3009
2978
  s0 = peg$currPos;
3010
2979
  s1 = input.charAt(peg$currPos);
3011
- if (peg$r13.test(s1)) {
2980
+ if (peg$r15.test(s1)) {
3012
2981
  peg$currPos++;
3013
2982
  } else {
3014
2983
  s1 = peg$FAILED;
3015
2984
  if (peg$silentFails === 0) {
3016
- peg$fail(peg$e22);
2985
+ peg$fail(peg$e23);
3017
2986
  }
3018
2987
  }
3019
2988
  if (s1 !== peg$FAILED) {
3020
2989
  s2 = [];
3021
2990
  s3 = peg$currPos;
3022
2991
  s4 = [];
3023
- if (input.substr(peg$currPos, 2) === peg$c9) {
3024
- s5 = peg$c9;
2992
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2993
+ s5 = peg$c8;
3025
2994
  peg$currPos += 2;
3026
2995
  } else {
3027
2996
  s5 = peg$FAILED;
3028
2997
  if (peg$silentFails === 0) {
3029
- peg$fail(peg$e23);
2998
+ peg$fail(peg$e24);
3030
2999
  }
3031
3000
  }
3032
3001
  if (s5 === peg$FAILED) {
3033
3002
  s5 = input.charAt(peg$currPos);
3034
- if (peg$r14.test(s5)) {
3003
+ if (peg$r16.test(s5)) {
3035
3004
  peg$currPos++;
3036
3005
  } else {
3037
3006
  s5 = peg$FAILED;
3038
3007
  if (peg$silentFails === 0) {
3039
- peg$fail(peg$e24);
3008
+ peg$fail(peg$e25);
3040
3009
  }
3041
3010
  }
3042
3011
  }
3043
3012
  while (s5 !== peg$FAILED) {
3044
3013
  s4.push(s5);
3045
- if (input.substr(peg$currPos, 2) === peg$c9) {
3046
- s5 = peg$c9;
3014
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3015
+ s5 = peg$c8;
3047
3016
  peg$currPos += 2;
3048
3017
  } else {
3049
3018
  s5 = peg$FAILED;
3050
3019
  if (peg$silentFails === 0) {
3051
- peg$fail(peg$e23);
3020
+ peg$fail(peg$e24);
3052
3021
  }
3053
3022
  }
3054
3023
  if (s5 === peg$FAILED) {
3055
3024
  s5 = input.charAt(peg$currPos);
3056
- if (peg$r14.test(s5)) {
3025
+ if (peg$r16.test(s5)) {
3057
3026
  peg$currPos++;
3058
3027
  } else {
3059
3028
  s5 = peg$FAILED;
3060
3029
  if (peg$silentFails === 0) {
3061
- peg$fail(peg$e24);
3030
+ peg$fail(peg$e25);
3062
3031
  }
3063
3032
  }
3064
3033
  }
@@ -3084,45 +3053,45 @@ function peg$parse(input, options) {
3084
3053
  s2.push(s3);
3085
3054
  s3 = peg$currPos;
3086
3055
  s4 = [];
3087
- if (input.substr(peg$currPos, 2) === peg$c9) {
3088
- s5 = peg$c9;
3056
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3057
+ s5 = peg$c8;
3089
3058
  peg$currPos += 2;
3090
3059
  } else {
3091
3060
  s5 = peg$FAILED;
3092
3061
  if (peg$silentFails === 0) {
3093
- peg$fail(peg$e23);
3062
+ peg$fail(peg$e24);
3094
3063
  }
3095
3064
  }
3096
3065
  if (s5 === peg$FAILED) {
3097
3066
  s5 = input.charAt(peg$currPos);
3098
- if (peg$r14.test(s5)) {
3067
+ if (peg$r16.test(s5)) {
3099
3068
  peg$currPos++;
3100
3069
  } else {
3101
3070
  s5 = peg$FAILED;
3102
3071
  if (peg$silentFails === 0) {
3103
- peg$fail(peg$e24);
3072
+ peg$fail(peg$e25);
3104
3073
  }
3105
3074
  }
3106
3075
  }
3107
3076
  while (s5 !== peg$FAILED) {
3108
3077
  s4.push(s5);
3109
- if (input.substr(peg$currPos, 2) === peg$c9) {
3110
- s5 = peg$c9;
3078
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3079
+ s5 = peg$c8;
3111
3080
  peg$currPos += 2;
3112
3081
  } else {
3113
3082
  s5 = peg$FAILED;
3114
3083
  if (peg$silentFails === 0) {
3115
- peg$fail(peg$e23);
3084
+ peg$fail(peg$e24);
3116
3085
  }
3117
3086
  }
3118
3087
  if (s5 === peg$FAILED) {
3119
3088
  s5 = input.charAt(peg$currPos);
3120
- if (peg$r14.test(s5)) {
3089
+ if (peg$r16.test(s5)) {
3121
3090
  peg$currPos++;
3122
3091
  } else {
3123
3092
  s5 = peg$FAILED;
3124
3093
  if (peg$silentFails === 0) {
3125
- peg$fail(peg$e24);
3094
+ peg$fail(peg$e25);
3126
3095
  }
3127
3096
  }
3128
3097
  }
@@ -3149,56 +3118,56 @@ function peg$parse(input, options) {
3149
3118
  }
3150
3119
  if (s2 !== peg$FAILED) {
3151
3120
  s3 = [];
3152
- if (input.substr(peg$currPos, 2) === peg$c9) {
3153
- s4 = peg$c9;
3121
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3122
+ s4 = peg$c8;
3154
3123
  peg$currPos += 2;
3155
3124
  } else {
3156
3125
  s4 = peg$FAILED;
3157
3126
  if (peg$silentFails === 0) {
3158
- peg$fail(peg$e23);
3127
+ peg$fail(peg$e24);
3159
3128
  }
3160
3129
  }
3161
3130
  if (s4 === peg$FAILED) {
3162
3131
  s4 = input.charAt(peg$currPos);
3163
- if (peg$r14.test(s4)) {
3132
+ if (peg$r16.test(s4)) {
3164
3133
  peg$currPos++;
3165
3134
  } else {
3166
3135
  s4 = peg$FAILED;
3167
3136
  if (peg$silentFails === 0) {
3168
- peg$fail(peg$e24);
3137
+ peg$fail(peg$e25);
3169
3138
  }
3170
3139
  }
3171
3140
  }
3172
3141
  while (s4 !== peg$FAILED) {
3173
3142
  s3.push(s4);
3174
- if (input.substr(peg$currPos, 2) === peg$c9) {
3175
- s4 = peg$c9;
3143
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3144
+ s4 = peg$c8;
3176
3145
  peg$currPos += 2;
3177
3146
  } else {
3178
3147
  s4 = peg$FAILED;
3179
3148
  if (peg$silentFails === 0) {
3180
- peg$fail(peg$e23);
3149
+ peg$fail(peg$e24);
3181
3150
  }
3182
3151
  }
3183
3152
  if (s4 === peg$FAILED) {
3184
3153
  s4 = input.charAt(peg$currPos);
3185
- if (peg$r14.test(s4)) {
3154
+ if (peg$r16.test(s4)) {
3186
3155
  peg$currPos++;
3187
3156
  } else {
3188
3157
  s4 = peg$FAILED;
3189
3158
  if (peg$silentFails === 0) {
3190
- peg$fail(peg$e24);
3159
+ peg$fail(peg$e25);
3191
3160
  }
3192
3161
  }
3193
3162
  }
3194
3163
  }
3195
3164
  s4 = input.charAt(peg$currPos);
3196
- if (peg$r13.test(s4)) {
3165
+ if (peg$r15.test(s4)) {
3197
3166
  peg$currPos++;
3198
3167
  } else {
3199
3168
  s4 = peg$FAILED;
3200
3169
  if (peg$silentFails === 0) {
3201
- peg$fail(peg$e22);
3170
+ peg$fail(peg$e23);
3202
3171
  }
3203
3172
  }
3204
3173
  if (s4 !== peg$FAILED) {
@@ -3218,43 +3187,43 @@ function peg$parse(input, options) {
3218
3187
  }
3219
3188
  return s0;
3220
3189
  }
3221
- chunkKJP2NVDR_js.__name(peg$parsesingleDQuotedMultiLineString, "peg$parsesingleDQuotedMultiLineString");
3190
+ chunkEWY3F3XT_js.__name(peg$parsesingleDQuotedMultiLineString, "peg$parsesingleDQuotedMultiLineString");
3222
3191
  function peg$parsetripleDQuotedMultiLineString() {
3223
3192
  let s0, s1, s2, s3, s4, s5, s6, s7;
3224
3193
  s0 = peg$currPos;
3225
- if (input.substr(peg$currPos, 3) === peg$c12) {
3226
- s1 = peg$c12;
3194
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3195
+ s1 = peg$c11;
3227
3196
  peg$currPos += 3;
3228
3197
  } else {
3229
3198
  s1 = peg$FAILED;
3230
3199
  if (peg$silentFails === 0) {
3231
- peg$fail(peg$e31);
3200
+ peg$fail(peg$e32);
3232
3201
  }
3233
3202
  }
3234
3203
  if (s1 !== peg$FAILED) {
3235
3204
  s2 = [];
3236
3205
  s3 = peg$currPos;
3237
3206
  s4 = [];
3238
- if (input.substr(peg$currPos, 4) === peg$c13) {
3239
- s5 = peg$c13;
3207
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3208
+ s5 = peg$c12;
3240
3209
  peg$currPos += 4;
3241
3210
  } else {
3242
3211
  s5 = peg$FAILED;
3243
3212
  if (peg$silentFails === 0) {
3244
- peg$fail(peg$e32);
3213
+ peg$fail(peg$e33);
3245
3214
  }
3246
3215
  }
3247
3216
  if (s5 === peg$FAILED) {
3248
3217
  s5 = peg$currPos;
3249
3218
  s6 = peg$currPos;
3250
3219
  peg$silentFails++;
3251
- if (input.substr(peg$currPos, 3) === peg$c12) {
3252
- s7 = peg$c12;
3220
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3221
+ s7 = peg$c11;
3253
3222
  peg$currPos += 3;
3254
3223
  } else {
3255
3224
  s7 = peg$FAILED;
3256
3225
  if (peg$silentFails === 0) {
3257
- peg$fail(peg$e31);
3226
+ peg$fail(peg$e32);
3258
3227
  }
3259
3228
  }
3260
3229
  peg$silentFails--;
@@ -3288,26 +3257,26 @@ function peg$parse(input, options) {
3288
3257
  }
3289
3258
  while (s5 !== peg$FAILED) {
3290
3259
  s4.push(s5);
3291
- if (input.substr(peg$currPos, 4) === peg$c13) {
3292
- s5 = peg$c13;
3260
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3261
+ s5 = peg$c12;
3293
3262
  peg$currPos += 4;
3294
3263
  } else {
3295
3264
  s5 = peg$FAILED;
3296
3265
  if (peg$silentFails === 0) {
3297
- peg$fail(peg$e32);
3266
+ peg$fail(peg$e33);
3298
3267
  }
3299
3268
  }
3300
3269
  if (s5 === peg$FAILED) {
3301
3270
  s5 = peg$currPos;
3302
3271
  s6 = peg$currPos;
3303
3272
  peg$silentFails++;
3304
- if (input.substr(peg$currPos, 3) === peg$c12) {
3305
- s7 = peg$c12;
3273
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3274
+ s7 = peg$c11;
3306
3275
  peg$currPos += 3;
3307
3276
  } else {
3308
3277
  s7 = peg$FAILED;
3309
3278
  if (peg$silentFails === 0) {
3310
- peg$fail(peg$e31);
3279
+ peg$fail(peg$e32);
3311
3280
  }
3312
3281
  }
3313
3282
  peg$silentFails--;
@@ -3361,26 +3330,26 @@ function peg$parse(input, options) {
3361
3330
  s2.push(s3);
3362
3331
  s3 = peg$currPos;
3363
3332
  s4 = [];
3364
- if (input.substr(peg$currPos, 4) === peg$c13) {
3365
- s5 = peg$c13;
3333
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3334
+ s5 = peg$c12;
3366
3335
  peg$currPos += 4;
3367
3336
  } else {
3368
3337
  s5 = peg$FAILED;
3369
3338
  if (peg$silentFails === 0) {
3370
- peg$fail(peg$e32);
3339
+ peg$fail(peg$e33);
3371
3340
  }
3372
3341
  }
3373
3342
  if (s5 === peg$FAILED) {
3374
3343
  s5 = peg$currPos;
3375
3344
  s6 = peg$currPos;
3376
3345
  peg$silentFails++;
3377
- if (input.substr(peg$currPos, 3) === peg$c12) {
3378
- s7 = peg$c12;
3346
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3347
+ s7 = peg$c11;
3379
3348
  peg$currPos += 3;
3380
3349
  } else {
3381
3350
  s7 = peg$FAILED;
3382
3351
  if (peg$silentFails === 0) {
3383
- peg$fail(peg$e31);
3352
+ peg$fail(peg$e32);
3384
3353
  }
3385
3354
  }
3386
3355
  peg$silentFails--;
@@ -3414,26 +3383,26 @@ function peg$parse(input, options) {
3414
3383
  }
3415
3384
  while (s5 !== peg$FAILED) {
3416
3385
  s4.push(s5);
3417
- if (input.substr(peg$currPos, 4) === peg$c13) {
3418
- s5 = peg$c13;
3386
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3387
+ s5 = peg$c12;
3419
3388
  peg$currPos += 4;
3420
3389
  } else {
3421
3390
  s5 = peg$FAILED;
3422
3391
  if (peg$silentFails === 0) {
3423
- peg$fail(peg$e32);
3392
+ peg$fail(peg$e33);
3424
3393
  }
3425
3394
  }
3426
3395
  if (s5 === peg$FAILED) {
3427
3396
  s5 = peg$currPos;
3428
3397
  s6 = peg$currPos;
3429
3398
  peg$silentFails++;
3430
- if (input.substr(peg$currPos, 3) === peg$c12) {
3431
- s7 = peg$c12;
3399
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3400
+ s7 = peg$c11;
3432
3401
  peg$currPos += 3;
3433
3402
  } else {
3434
3403
  s7 = peg$FAILED;
3435
3404
  if (peg$silentFails === 0) {
3436
- peg$fail(peg$e31);
3405
+ peg$fail(peg$e32);
3437
3406
  }
3438
3407
  }
3439
3408
  peg$silentFails--;
@@ -3488,26 +3457,26 @@ function peg$parse(input, options) {
3488
3457
  }
3489
3458
  if (s2 !== peg$FAILED) {
3490
3459
  s3 = [];
3491
- if (input.substr(peg$currPos, 4) === peg$c13) {
3492
- s4 = peg$c13;
3460
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3461
+ s4 = peg$c12;
3493
3462
  peg$currPos += 4;
3494
3463
  } else {
3495
3464
  s4 = peg$FAILED;
3496
3465
  if (peg$silentFails === 0) {
3497
- peg$fail(peg$e32);
3466
+ peg$fail(peg$e33);
3498
3467
  }
3499
3468
  }
3500
3469
  if (s4 === peg$FAILED) {
3501
3470
  s4 = peg$currPos;
3502
3471
  s5 = peg$currPos;
3503
3472
  peg$silentFails++;
3504
- if (input.substr(peg$currPos, 3) === peg$c12) {
3505
- s6 = peg$c12;
3473
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3474
+ s6 = peg$c11;
3506
3475
  peg$currPos += 3;
3507
3476
  } else {
3508
3477
  s6 = peg$FAILED;
3509
3478
  if (peg$silentFails === 0) {
3510
- peg$fail(peg$e31);
3479
+ peg$fail(peg$e32);
3511
3480
  }
3512
3481
  }
3513
3482
  peg$silentFails--;
@@ -3541,26 +3510,26 @@ function peg$parse(input, options) {
3541
3510
  }
3542
3511
  while (s4 !== peg$FAILED) {
3543
3512
  s3.push(s4);
3544
- if (input.substr(peg$currPos, 4) === peg$c13) {
3545
- s4 = peg$c13;
3513
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3514
+ s4 = peg$c12;
3546
3515
  peg$currPos += 4;
3547
3516
  } else {
3548
3517
  s4 = peg$FAILED;
3549
3518
  if (peg$silentFails === 0) {
3550
- peg$fail(peg$e32);
3519
+ peg$fail(peg$e33);
3551
3520
  }
3552
3521
  }
3553
3522
  if (s4 === peg$FAILED) {
3554
3523
  s4 = peg$currPos;
3555
3524
  s5 = peg$currPos;
3556
3525
  peg$silentFails++;
3557
- if (input.substr(peg$currPos, 3) === peg$c12) {
3558
- s6 = peg$c12;
3526
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3527
+ s6 = peg$c11;
3559
3528
  peg$currPos += 3;
3560
3529
  } else {
3561
3530
  s6 = peg$FAILED;
3562
3531
  if (peg$silentFails === 0) {
3563
- peg$fail(peg$e31);
3532
+ peg$fail(peg$e32);
3564
3533
  }
3565
3534
  }
3566
3535
  peg$silentFails--;
@@ -3593,13 +3562,13 @@ function peg$parse(input, options) {
3593
3562
  }
3594
3563
  }
3595
3564
  }
3596
- if (input.substr(peg$currPos, 3) === peg$c12) {
3597
- s4 = peg$c12;
3565
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3566
+ s4 = peg$c11;
3598
3567
  peg$currPos += 3;
3599
3568
  } else {
3600
3569
  s4 = peg$FAILED;
3601
3570
  if (peg$silentFails === 0) {
3602
- peg$fail(peg$e31);
3571
+ peg$fail(peg$e32);
3603
3572
  }
3604
3573
  }
3605
3574
  if (s4 !== peg$FAILED) {
@@ -3619,43 +3588,43 @@ function peg$parse(input, options) {
3619
3588
  }
3620
3589
  return s0;
3621
3590
  }
3622
- chunkKJP2NVDR_js.__name(peg$parsetripleDQuotedMultiLineString, "peg$parsetripleDQuotedMultiLineString");
3591
+ chunkEWY3F3XT_js.__name(peg$parsetripleDQuotedMultiLineString, "peg$parsetripleDQuotedMultiLineString");
3623
3592
  function peg$parsetripleBQuotedMultiLineString() {
3624
3593
  let s0, s1, s2, s3, s4, s5, s6, s7;
3625
3594
  s0 = peg$currPos;
3626
- if (input.substr(peg$currPos, 3) === peg$c14) {
3627
- s1 = peg$c14;
3595
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3596
+ s1 = peg$c13;
3628
3597
  peg$currPos += 3;
3629
3598
  } else {
3630
3599
  s1 = peg$FAILED;
3631
3600
  if (peg$silentFails === 0) {
3632
- peg$fail(peg$e33);
3601
+ peg$fail(peg$e34);
3633
3602
  }
3634
3603
  }
3635
3604
  if (s1 !== peg$FAILED) {
3636
3605
  s2 = [];
3637
3606
  s3 = peg$currPos;
3638
3607
  s4 = [];
3639
- if (input.substr(peg$currPos, 4) === peg$c15) {
3640
- s5 = peg$c15;
3608
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3609
+ s5 = peg$c14;
3641
3610
  peg$currPos += 4;
3642
3611
  } else {
3643
3612
  s5 = peg$FAILED;
3644
3613
  if (peg$silentFails === 0) {
3645
- peg$fail(peg$e34);
3614
+ peg$fail(peg$e35);
3646
3615
  }
3647
3616
  }
3648
3617
  if (s5 === peg$FAILED) {
3649
3618
  s5 = peg$currPos;
3650
3619
  s6 = peg$currPos;
3651
3620
  peg$silentFails++;
3652
- if (input.substr(peg$currPos, 3) === peg$c14) {
3653
- s7 = peg$c14;
3621
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3622
+ s7 = peg$c13;
3654
3623
  peg$currPos += 3;
3655
3624
  } else {
3656
3625
  s7 = peg$FAILED;
3657
3626
  if (peg$silentFails === 0) {
3658
- peg$fail(peg$e33);
3627
+ peg$fail(peg$e34);
3659
3628
  }
3660
3629
  }
3661
3630
  peg$silentFails--;
@@ -3689,26 +3658,26 @@ function peg$parse(input, options) {
3689
3658
  }
3690
3659
  while (s5 !== peg$FAILED) {
3691
3660
  s4.push(s5);
3692
- if (input.substr(peg$currPos, 4) === peg$c15) {
3693
- s5 = peg$c15;
3661
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3662
+ s5 = peg$c14;
3694
3663
  peg$currPos += 4;
3695
3664
  } else {
3696
3665
  s5 = peg$FAILED;
3697
3666
  if (peg$silentFails === 0) {
3698
- peg$fail(peg$e34);
3667
+ peg$fail(peg$e35);
3699
3668
  }
3700
3669
  }
3701
3670
  if (s5 === peg$FAILED) {
3702
3671
  s5 = peg$currPos;
3703
3672
  s6 = peg$currPos;
3704
3673
  peg$silentFails++;
3705
- if (input.substr(peg$currPos, 3) === peg$c14) {
3706
- s7 = peg$c14;
3674
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3675
+ s7 = peg$c13;
3707
3676
  peg$currPos += 3;
3708
3677
  } else {
3709
3678
  s7 = peg$FAILED;
3710
3679
  if (peg$silentFails === 0) {
3711
- peg$fail(peg$e33);
3680
+ peg$fail(peg$e34);
3712
3681
  }
3713
3682
  }
3714
3683
  peg$silentFails--;
@@ -3762,26 +3731,26 @@ function peg$parse(input, options) {
3762
3731
  s2.push(s3);
3763
3732
  s3 = peg$currPos;
3764
3733
  s4 = [];
3765
- if (input.substr(peg$currPos, 4) === peg$c15) {
3766
- s5 = peg$c15;
3734
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3735
+ s5 = peg$c14;
3767
3736
  peg$currPos += 4;
3768
3737
  } else {
3769
3738
  s5 = peg$FAILED;
3770
3739
  if (peg$silentFails === 0) {
3771
- peg$fail(peg$e34);
3740
+ peg$fail(peg$e35);
3772
3741
  }
3773
3742
  }
3774
3743
  if (s5 === peg$FAILED) {
3775
3744
  s5 = peg$currPos;
3776
3745
  s6 = peg$currPos;
3777
3746
  peg$silentFails++;
3778
- if (input.substr(peg$currPos, 3) === peg$c14) {
3779
- s7 = peg$c14;
3747
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3748
+ s7 = peg$c13;
3780
3749
  peg$currPos += 3;
3781
3750
  } else {
3782
3751
  s7 = peg$FAILED;
3783
3752
  if (peg$silentFails === 0) {
3784
- peg$fail(peg$e33);
3753
+ peg$fail(peg$e34);
3785
3754
  }
3786
3755
  }
3787
3756
  peg$silentFails--;
@@ -3815,26 +3784,26 @@ function peg$parse(input, options) {
3815
3784
  }
3816
3785
  while (s5 !== peg$FAILED) {
3817
3786
  s4.push(s5);
3818
- if (input.substr(peg$currPos, 4) === peg$c15) {
3819
- s5 = peg$c15;
3787
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3788
+ s5 = peg$c14;
3820
3789
  peg$currPos += 4;
3821
3790
  } else {
3822
3791
  s5 = peg$FAILED;
3823
3792
  if (peg$silentFails === 0) {
3824
- peg$fail(peg$e34);
3793
+ peg$fail(peg$e35);
3825
3794
  }
3826
3795
  }
3827
3796
  if (s5 === peg$FAILED) {
3828
3797
  s5 = peg$currPos;
3829
3798
  s6 = peg$currPos;
3830
3799
  peg$silentFails++;
3831
- if (input.substr(peg$currPos, 3) === peg$c14) {
3832
- s7 = peg$c14;
3800
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3801
+ s7 = peg$c13;
3833
3802
  peg$currPos += 3;
3834
3803
  } else {
3835
3804
  s7 = peg$FAILED;
3836
3805
  if (peg$silentFails === 0) {
3837
- peg$fail(peg$e33);
3806
+ peg$fail(peg$e34);
3838
3807
  }
3839
3808
  }
3840
3809
  peg$silentFails--;
@@ -3889,26 +3858,26 @@ function peg$parse(input, options) {
3889
3858
  }
3890
3859
  if (s2 !== peg$FAILED) {
3891
3860
  s3 = [];
3892
- if (input.substr(peg$currPos, 4) === peg$c15) {
3893
- s4 = peg$c15;
3861
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3862
+ s4 = peg$c14;
3894
3863
  peg$currPos += 4;
3895
3864
  } else {
3896
3865
  s4 = peg$FAILED;
3897
3866
  if (peg$silentFails === 0) {
3898
- peg$fail(peg$e34);
3867
+ peg$fail(peg$e35);
3899
3868
  }
3900
3869
  }
3901
3870
  if (s4 === peg$FAILED) {
3902
3871
  s4 = peg$currPos;
3903
3872
  s5 = peg$currPos;
3904
3873
  peg$silentFails++;
3905
- if (input.substr(peg$currPos, 3) === peg$c14) {
3906
- s6 = peg$c14;
3874
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3875
+ s6 = peg$c13;
3907
3876
  peg$currPos += 3;
3908
3877
  } else {
3909
3878
  s6 = peg$FAILED;
3910
3879
  if (peg$silentFails === 0) {
3911
- peg$fail(peg$e33);
3880
+ peg$fail(peg$e34);
3912
3881
  }
3913
3882
  }
3914
3883
  peg$silentFails--;
@@ -3942,26 +3911,26 @@ function peg$parse(input, options) {
3942
3911
  }
3943
3912
  while (s4 !== peg$FAILED) {
3944
3913
  s3.push(s4);
3945
- if (input.substr(peg$currPos, 4) === peg$c15) {
3946
- s4 = peg$c15;
3914
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3915
+ s4 = peg$c14;
3947
3916
  peg$currPos += 4;
3948
3917
  } else {
3949
3918
  s4 = peg$FAILED;
3950
3919
  if (peg$silentFails === 0) {
3951
- peg$fail(peg$e34);
3920
+ peg$fail(peg$e35);
3952
3921
  }
3953
3922
  }
3954
3923
  if (s4 === peg$FAILED) {
3955
3924
  s4 = peg$currPos;
3956
3925
  s5 = peg$currPos;
3957
3926
  peg$silentFails++;
3958
- if (input.substr(peg$currPos, 3) === peg$c14) {
3959
- s6 = peg$c14;
3927
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3928
+ s6 = peg$c13;
3960
3929
  peg$currPos += 3;
3961
3930
  } else {
3962
3931
  s6 = peg$FAILED;
3963
3932
  if (peg$silentFails === 0) {
3964
- peg$fail(peg$e33);
3933
+ peg$fail(peg$e34);
3965
3934
  }
3966
3935
  }
3967
3936
  peg$silentFails--;
@@ -3994,13 +3963,13 @@ function peg$parse(input, options) {
3994
3963
  }
3995
3964
  }
3996
3965
  }
3997
- if (input.substr(peg$currPos, 3) === peg$c14) {
3998
- s4 = peg$c14;
3966
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3967
+ s4 = peg$c13;
3999
3968
  peg$currPos += 3;
4000
3969
  } else {
4001
3970
  s4 = peg$FAILED;
4002
3971
  if (peg$silentFails === 0) {
4003
- peg$fail(peg$e33);
3972
+ peg$fail(peg$e34);
4004
3973
  }
4005
3974
  }
4006
3975
  if (s4 !== peg$FAILED) {
@@ -4020,7 +3989,7 @@ function peg$parse(input, options) {
4020
3989
  }
4021
3990
  return s0;
4022
3991
  }
4023
- chunkKJP2NVDR_js.__name(peg$parsetripleBQuotedMultiLineString, "peg$parsetripleBQuotedMultiLineString");
3992
+ chunkEWY3F3XT_js.__name(peg$parsetripleBQuotedMultiLineString, "peg$parsetripleBQuotedMultiLineString");
4024
3993
  function peg$parse_n() {
4025
3994
  let s0, s1;
4026
3995
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -4041,7 +4010,7 @@ function peg$parse(input, options) {
4041
4010
  } else {
4042
4011
  s1 = peg$FAILED;
4043
4012
  if (peg$silentFails === 0) {
4044
- peg$fail(peg$e35);
4013
+ peg$fail(peg$e36);
4045
4014
  }
4046
4015
  }
4047
4016
  peg$silentFails--;
@@ -4054,12 +4023,12 @@ function peg$parse(input, options) {
4054
4023
  }
4055
4024
  return s0;
4056
4025
  }
4057
- chunkKJP2NVDR_js.__name(peg$parse_n, "peg$parse_n");
4026
+ chunkEWY3F3XT_js.__name(peg$parse_n, "peg$parse_n");
4058
4027
  function peg$parse_() {
4059
4028
  let s0, s1;
4060
4029
  s0 = [];
4061
4030
  s1 = input.charAt(peg$currPos);
4062
- if (peg$r7.test(s1)) {
4031
+ if (peg$r8.test(s1)) {
4063
4032
  peg$currPos++;
4064
4033
  } else {
4065
4034
  s1 = peg$FAILED;
@@ -4070,7 +4039,7 @@ function peg$parse(input, options) {
4070
4039
  while (s1 !== peg$FAILED) {
4071
4040
  s0.push(s1);
4072
4041
  s1 = input.charAt(peg$currPos);
4073
- if (peg$r7.test(s1)) {
4042
+ if (peg$r8.test(s1)) {
4074
4043
  peg$currPos++;
4075
4044
  } else {
4076
4045
  s1 = peg$FAILED;
@@ -4081,12 +4050,12 @@ function peg$parse(input, options) {
4081
4050
  }
4082
4051
  return s0;
4083
4052
  }
4084
- chunkKJP2NVDR_js.__name(peg$parse_, "peg$parse_");
4053
+ chunkEWY3F3XT_js.__name(peg$parse_, "peg$parse_");
4085
4054
  function peg$parse__() {
4086
4055
  let s0, s1;
4087
4056
  s0 = [];
4088
4057
  s1 = input.charAt(peg$currPos);
4089
- if (peg$r7.test(s1)) {
4058
+ if (peg$r8.test(s1)) {
4090
4059
  peg$currPos++;
4091
4060
  } else {
4092
4061
  s1 = peg$FAILED;
@@ -4098,7 +4067,7 @@ function peg$parse(input, options) {
4098
4067
  while (s1 !== peg$FAILED) {
4099
4068
  s0.push(s1);
4100
4069
  s1 = input.charAt(peg$currPos);
4101
- if (peg$r7.test(s1)) {
4070
+ if (peg$r8.test(s1)) {
4102
4071
  peg$currPos++;
4103
4072
  } else {
4104
4073
  s1 = peg$FAILED;
@@ -4112,7 +4081,7 @@ function peg$parse(input, options) {
4112
4081
  }
4113
4082
  return s0;
4114
4083
  }
4115
- chunkKJP2NVDR_js.__name(peg$parse__, "peg$parse__");
4084
+ chunkEWY3F3XT_js.__name(peg$parse__, "peg$parse__");
4116
4085
  peg$result = peg$startRuleFunction();
4117
4086
  const peg$success = peg$result !== peg$FAILED && peg$currPos === input.length;
4118
4087
  function peg$throw() {
@@ -4125,7 +4094,7 @@ function peg$parse(input, options) {
4125
4094
  peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
4126
4095
  );
4127
4096
  }
4128
- chunkKJP2NVDR_js.__name(peg$throw, "peg$throw");
4097
+ chunkEWY3F3XT_js.__name(peg$throw, "peg$throw");
4129
4098
  if (options.peg$library) {
4130
4099
  return (
4131
4100
  /** @type {any} */
@@ -4146,65 +4115,65 @@ function peg$parse(input, options) {
4146
4115
  peg$throw();
4147
4116
  }
4148
4117
  }
4149
- chunkKJP2NVDR_js.__name(peg$parse, "peg$parse");
4118
+ chunkEWY3F3XT_js.__name(peg$parse, "peg$parse");
4150
4119
 
4151
4120
  // src/index.ts
4152
4121
  function parseEnvSpecDotEnvFile(source) {
4153
4122
  return peg$parse(source.replaceAll("\r\n", "\n"));
4154
4123
  }
4155
- chunkKJP2NVDR_js.__name(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
4124
+ chunkEWY3F3XT_js.__name(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
4156
4125
 
4157
4126
  Object.defineProperty(exports, "ParsedEnvSpecBlankLine", {
4158
4127
  enumerable: true,
4159
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecBlankLine; }
4128
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecBlankLine; }
4160
4129
  });
4161
4130
  Object.defineProperty(exports, "ParsedEnvSpecComment", {
4162
4131
  enumerable: true,
4163
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecComment; }
4132
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecComment; }
4164
4133
  });
4165
4134
  Object.defineProperty(exports, "ParsedEnvSpecCommentBlock", {
4166
4135
  enumerable: true,
4167
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecCommentBlock; }
4136
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecCommentBlock; }
4168
4137
  });
4169
4138
  Object.defineProperty(exports, "ParsedEnvSpecConfigItem", {
4170
4139
  enumerable: true,
4171
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecConfigItem; }
4140
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecConfigItem; }
4172
4141
  });
4173
4142
  Object.defineProperty(exports, "ParsedEnvSpecDecorator", {
4174
4143
  enumerable: true,
4175
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecDecorator; }
4144
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecDecorator; }
4176
4145
  });
4177
4146
  Object.defineProperty(exports, "ParsedEnvSpecDecoratorComment", {
4178
4147
  enumerable: true,
4179
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecDecoratorComment; }
4148
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecDecoratorComment; }
4180
4149
  });
4181
4150
  Object.defineProperty(exports, "ParsedEnvSpecDivider", {
4182
4151
  enumerable: true,
4183
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecDivider; }
4152
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecDivider; }
4184
4153
  });
4185
4154
  Object.defineProperty(exports, "ParsedEnvSpecFile", {
4186
4155
  enumerable: true,
4187
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecFile; }
4156
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecFile; }
4188
4157
  });
4189
4158
  Object.defineProperty(exports, "ParsedEnvSpecFunctionArgs", {
4190
4159
  enumerable: true,
4191
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecFunctionArgs; }
4160
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecFunctionArgs; }
4192
4161
  });
4193
4162
  Object.defineProperty(exports, "ParsedEnvSpecFunctionCall", {
4194
4163
  enumerable: true,
4195
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecFunctionCall; }
4164
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecFunctionCall; }
4196
4165
  });
4197
4166
  Object.defineProperty(exports, "ParsedEnvSpecKeyValuePair", {
4198
4167
  enumerable: true,
4199
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecKeyValuePair; }
4168
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecKeyValuePair; }
4200
4169
  });
4201
4170
  Object.defineProperty(exports, "ParsedEnvSpecStaticValue", {
4202
4171
  enumerable: true,
4203
- get: function () { return chunkKJP2NVDR_js.ParsedEnvSpecStaticValue; }
4172
+ get: function () { return chunkEWY3F3XT_js.ParsedEnvSpecStaticValue; }
4204
4173
  });
4205
4174
  Object.defineProperty(exports, "expand", {
4206
4175
  enumerable: true,
4207
- get: function () { return chunkKJP2NVDR_js.expand; }
4176
+ get: function () { return chunkEWY3F3XT_js.expand; }
4208
4177
  });
4209
4178
  exports.envSpecUpdater = envSpecUpdater;
4210
4179
  exports.parseEnvSpecDotEnvFile = parseEnvSpecDotEnvFile;