@env-spec/parser 0.3.0 → 0.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (21) hide show
  1. package/dist/{chunk-RRVAHNIY.mjs → chunk-N4D6RSUR.mjs} +19 -40
  2. package/dist/chunk-N4D6RSUR.mjs.map +1 -0
  3. package/dist/{chunk-CHM43IJO.js → chunk-X4PJ2KLO.js} +18 -40
  4. package/dist/chunk-X4PJ2KLO.js.map +1 -0
  5. package/dist/{classes-CgmCxTZQ.d.mts → classes-BhsV2JNw.d.mts} +18 -31
  6. package/dist/{classes-CgmCxTZQ.d.ts → classes-BhsV2JNw.d.ts} +18 -31
  7. package/dist/index.d.mts +4 -4
  8. package/dist/index.d.ts +4 -4
  9. package/dist/index.js +677 -989
  10. package/dist/index.js.map +1 -1
  11. package/dist/index.mjs +555 -863
  12. package/dist/index.mjs.map +1 -1
  13. package/dist/simple-resolver.d.mts +1 -1
  14. package/dist/simple-resolver.d.ts +1 -1
  15. package/dist/simple-resolver.js +11 -12
  16. package/dist/simple-resolver.js.map +1 -1
  17. package/dist/simple-resolver.mjs +1 -2
  18. package/dist/simple-resolver.mjs.map +1 -1
  19. package/package.json +2 -4
  20. package/dist/chunk-CHM43IJO.js.map +0 -1
  21. package/dist/chunk-RRVAHNIY.mjs.map +0 -1
package/dist/index.js CHANGED
@@ -1,6 +1,6 @@
1
1
  'use strict';
2
2
 
3
- var chunkCHM43IJO_js = require('./chunk-CHM43IJO.js');
3
+ var chunkX4PJ2KLO_js = require('./chunk-X4PJ2KLO.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 chunkCHM43IJO_js.ParsedEnvSpecCommentBlock({
11
+ new chunkX4PJ2KLO_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 chunkCHM43IJO_js.ParsedEnvSpecComment({ contents: line, leadingSpace: " " })),
14
- divider: new chunkCHM43IJO_js.ParsedEnvSpecDivider({ contents: "----------", leadingSpace: " " })
13
+ comments: newHeaderContents.split("\n").map((line) => new chunkX4PJ2KLO_js.ParsedEnvSpecComment({ contents: line, leadingSpace: " " })),
14
+ divider: new chunkX4PJ2KLO_js.ParsedEnvSpecDivider({ contents: "----------", leadingSpace: " " })
15
15
  }),
16
- new chunkCHM43IJO_js.ParsedEnvSpecBlankLine({})
16
+ new chunkX4PJ2KLO_js.ParsedEnvSpecBlankLine({})
17
17
  // add extra blank line after header
18
18
  );
19
19
  }
20
20
  }
21
- chunkCHM43IJO_js.__name(ensureHeader, "ensureHeader");
21
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(createDummyDecoratorNode, "createDummyDecoratorNode");
34
+ chunkX4PJ2KLO_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 chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
45
+ if (lastComment instanceof chunkX4PJ2KLO_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
46
46
  decCommentLine = lastComment;
47
47
  } else {
48
- decCommentLine = new chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment({
48
+ decCommentLine = new chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(setRootDecorator, "setRootDecorator");
58
+ chunkX4PJ2KLO_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 chunkCHM43IJO_js.ParsedEnvSpecConfigItem({
62
+ item = new chunkX4PJ2KLO_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 chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
77
+ if (lastComment instanceof chunkX4PJ2KLO_js.ParsedEnvSpecDecoratorComment && lastComment.toString().length < 40) {
78
78
  decCommentLine = lastComment;
79
79
  } else {
80
- decCommentLine = new chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment({
80
+ decCommentLine = new chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(setItemDecorator, "setItemDecorator");
89
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(injectFromStr, "injectFromStr");
110
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(deleteItem, "deleteItem");
117
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(this, "peg$SyntaxError");
129
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(hex, "hex");
166
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(unicodeEscape, "unicodeEscape");
174
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(literalEscape, "literalEscape");
178
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(classEscape, "classEscape");
182
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(describeExpectation, "describeExpectation");
206
+ chunkX4PJ2KLO_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
- chunkCHM43IJO_js.__name(describeExpected, "describeExpected");
229
+ chunkX4PJ2KLO_js.__name(describeExpected, "describeExpected");
230
230
  function describeFound(found2) {
231
231
  return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
232
232
  }
233
- chunkCHM43IJO_js.__name(describeFound, "describeFound");
233
+ chunkX4PJ2KLO_js.__name(describeFound, "describeFound");
234
234
  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
235
235
  }
236
236
  };
@@ -247,40 +247,35 @@ 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 = '\\"""';
261
- const peg$c16 = "```";
262
- const peg$c17 = "\\```";
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 = "\\```";
263
260
  const peg$r0 = /^[a-zA-Z_]/;
264
261
  const peg$r1 = /^[a-zA-Z0-9_.\-]/;
265
262
  const peg$r2 = /^[^\n]/;
266
263
  const peg$r3 = /^[a-zA-Z]/;
267
- const peg$r4 = /^[@#]/;
268
- const peg$r5 = /^[a-zA-Z0-9_]/;
269
- const peg$r6 = /^[^ \n,)]/;
270
- const peg$r7 = /^[ \t]/;
264
+ const peg$r4 = /^[^ \t\n=()#@]/;
265
+ const peg$r5 = /^[^ \n,)]/;
266
+ const peg$r6 = /^[ \t]/;
267
+ const peg$r7 = /^[a-zA-Z0-9_]/;
271
268
  const peg$r8 = /^[ \t\n]/;
272
269
  const peg$r9 = /^[\-=*#]/;
273
- const peg$r10 = /^[^\/\n]/;
274
- const peg$r11 = /^[gimsuy]/;
275
- const peg$r12 = /^['"`]/;
276
- const peg$r13 = /^[^#\n]/;
277
- const peg$r14 = /^[^# \n]/;
278
- const peg$r15 = /^["]/;
279
- const peg$r16 = /^[^"\n]/;
280
- const peg$r17 = /^[']/;
281
- const peg$r18 = /^[^'\n]/;
282
- const peg$r19 = /^[`]/;
283
- const peg$r20 = /^[^`\n]/;
270
+ const peg$r10 = /^['"`]/;
271
+ const peg$r11 = /^[^#\n]/;
272
+ const peg$r12 = /^[^# \n]/;
273
+ const peg$r13 = /^["]/;
274
+ const peg$r14 = /^[^"\n]/;
275
+ const peg$r15 = /^[']/;
276
+ const peg$r16 = /^[^'\n]/;
277
+ const peg$r17 = /^[`]/;
278
+ const peg$r18 = /^[^`\n]/;
284
279
  const peg$e0 = peg$literalExpectation("\n", false);
285
280
  const peg$e1 = peg$literalExpectation("export ", false);
286
281
  const peg$e2 = peg$literalExpectation("=", false);
@@ -290,47 +285,42 @@ function peg$parse(input, options) {
290
285
  const peg$e6 = peg$literalExpectation("@", false);
291
286
  const peg$e7 = peg$classExpectation(["\n"], true, false, false);
292
287
  const peg$e8 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false, false);
293
- const peg$e9 = peg$literalExpectation(":", false);
294
- const peg$e10 = peg$classExpectation(["@", "#"], false, false, false);
295
- const peg$e11 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false, false);
296
- const peg$e12 = peg$literalExpectation("(", false);
297
- const peg$e13 = peg$literalExpectation(",", false);
298
- const peg$e14 = peg$literalExpectation(")", false);
299
- const peg$e15 = peg$classExpectation([" ", "\n", ",", ")"], true, false, false);
300
- const peg$e16 = peg$classExpectation([" ", " "], false, false, false);
301
- const peg$e17 = peg$classExpectation([" ", " ", "\n"], false, false, false);
302
- const peg$e18 = peg$classExpectation(["-", "=", "*", "#"], false, false, false);
303
- const peg$e19 = peg$literalExpectation("/", false);
304
- const peg$e20 = peg$literalExpectation("\\/", false);
305
- const peg$e21 = peg$classExpectation(["/", "\n"], true, false, false);
306
- const peg$e22 = peg$classExpectation(["g", "i", "m", "s", "u", "y"], false, false, false);
307
- const peg$e23 = peg$classExpectation(["'", '"', "`"], false, false, false);
308
- const peg$e24 = peg$classExpectation(["#", "\n"], true, false, false);
309
- const peg$e25 = peg$classExpectation(["#", " ", "\n"], true, false, false);
310
- const peg$e26 = peg$classExpectation(['"'], false, false, false);
311
- const peg$e27 = peg$literalExpectation('\\"', false);
312
- const peg$e28 = peg$classExpectation(['"', "\n"], true, false, false);
313
- const peg$e29 = peg$classExpectation(["'"], false, false, false);
314
- const peg$e30 = peg$literalExpectation("\\'", false);
315
- const peg$e31 = peg$classExpectation(["'", "\n"], true, false, false);
316
- const peg$e32 = peg$classExpectation(["`"], false, false, false);
317
- const peg$e33 = peg$literalExpectation("\\`", false);
318
- const peg$e34 = peg$classExpectation(["`", "\n"], true, false, false);
319
- const peg$e35 = peg$literalExpectation('"""', false);
320
- const peg$e36 = peg$literalExpectation('\\"""', false);
321
- const peg$e37 = peg$literalExpectation("```", false);
322
- const peg$e38 = peg$literalExpectation("\\```", false);
323
- const peg$e39 = peg$anyExpectation();
288
+ const peg$e9 = peg$classExpectation([" ", " ", "\n", "=", "(", ")", "#", "@"], true, false, false);
289
+ const peg$e10 = peg$literalExpectation("(", false);
290
+ const peg$e11 = peg$literalExpectation(",", false);
291
+ const peg$e12 = peg$literalExpectation(")", false);
292
+ const peg$e13 = peg$classExpectation([" ", "\n", ",", ")"], true, false, false);
293
+ const peg$e14 = peg$classExpectation([" ", " "], false, false, false);
294
+ const peg$e15 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false, false);
295
+ const peg$e16 = peg$classExpectation([" ", " ", "\n"], false, false, false);
296
+ const peg$e17 = peg$classExpectation(["-", "=", "*", "#"], false, false, false);
297
+ const peg$e18 = peg$classExpectation(["'", '"', "`"], false, false, false);
298
+ const peg$e19 = peg$classExpectation(["#", "\n"], true, false, false);
299
+ const peg$e20 = peg$classExpectation(["#", " ", "\n"], true, false, false);
300
+ const peg$e21 = peg$classExpectation(['"'], false, false, false);
301
+ const peg$e22 = peg$literalExpectation('\\"', false);
302
+ const peg$e23 = peg$classExpectation(['"', "\n"], true, false, false);
303
+ const peg$e24 = peg$classExpectation(["'"], false, false, false);
304
+ const peg$e25 = peg$literalExpectation("\\'", false);
305
+ const peg$e26 = peg$classExpectation(["'", "\n"], true, false, false);
306
+ const peg$e27 = peg$classExpectation(["`"], false, false, false);
307
+ const peg$e28 = peg$literalExpectation("\\`", false);
308
+ const peg$e29 = peg$classExpectation(["`", "\n"], true, false, false);
309
+ const peg$e30 = peg$literalExpectation('"""', false);
310
+ const peg$e31 = peg$literalExpectation('\\"""', false);
311
+ const peg$e32 = peg$literalExpectation("```", false);
312
+ const peg$e33 = peg$literalExpectation("\\```", false);
313
+ const peg$e34 = peg$anyExpectation();
324
314
  function peg$f0() {
325
- return new chunkCHM43IJO_js.ParsedEnvSpecBlankLine({ _location: location() });
315
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecBlankLine({ _location: location() });
326
316
  }
327
- chunkCHM43IJO_js.__name(peg$f0, "peg$f0");
317
+ chunkX4PJ2KLO_js.__name(peg$f0, "peg$f0");
328
318
  function peg$f1(contents) {
329
- return new chunkCHM43IJO_js.ParsedEnvSpecFile(contents);
319
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecFile(contents);
330
320
  }
331
- chunkCHM43IJO_js.__name(peg$f1, "peg$f1");
321
+ chunkX4PJ2KLO_js.__name(peg$f1, "peg$f1");
332
322
  function peg$f2(preComments, key, value, postComment) {
333
- return new chunkCHM43IJO_js.ParsedEnvSpecConfigItem({
323
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecConfigItem({
334
324
  key,
335
325
  preComments,
336
326
  postComment,
@@ -338,144 +328,142 @@ function peg$parse(input, options) {
338
328
  _location: location()
339
329
  });
340
330
  }
341
- chunkCHM43IJO_js.__name(peg$f2, "peg$f2");
331
+ chunkX4PJ2KLO_js.__name(peg$f2, "peg$f2");
342
332
  function peg$f3(comments, end) {
343
- return new chunkCHM43IJO_js.ParsedEnvSpecCommentBlock({
333
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecCommentBlock({
344
334
  comments,
345
- divider: end instanceof chunkCHM43IJO_js.ParsedEnvSpecDivider ? end : void 0,
335
+ divider: end instanceof chunkX4PJ2KLO_js.ParsedEnvSpecDivider ? end : void 0,
346
336
  _location: location()
347
337
  });
348
338
  }
349
- chunkCHM43IJO_js.__name(peg$f3, "peg$f3");
339
+ chunkX4PJ2KLO_js.__name(peg$f3, "peg$f3");
350
340
  function peg$f4(leadingSpace, contents) {
351
- return new chunkCHM43IJO_js.ParsedEnvSpecComment({
341
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecComment({
352
342
  contents,
353
343
  leadingSpace,
354
344
  _location: location()
355
345
  });
356
346
  }
357
- chunkCHM43IJO_js.__name(peg$f4, "peg$f4");
358
- function peg$f5(leadingSpace, contents) {
359
- return new chunkCHM43IJO_js.ParsedEnvSpecComment({ contents, leadingSpace, _location: location() });
360
- }
361
- chunkCHM43IJO_js.__name(peg$f5, "peg$f5");
362
- function peg$f6(leadingSpace, first, rest, postComment) {
363
- return new chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment({
364
- decorators: [first, ...rest],
347
+ chunkX4PJ2KLO_js.__name(peg$f4, "peg$f4");
348
+ function peg$f5(leadingSpace, first, rest, trailingText) {
349
+ const allDecorators = [first, ...rest];
350
+ let postComment;
351
+ if (trailingText) {
352
+ if (trailingText.startsWith("#")) {
353
+ postComment = trailingText;
354
+ } else {
355
+ const lastDec = allDecorators[allDecorators.length - 1];
356
+ lastDec.data.warning = `Unexpected trailing text after @${lastDec.name}`;
357
+ postComment = trailingText;
358
+ }
359
+ }
360
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecDecoratorComment({
361
+ decorators: allDecorators,
365
362
  leadingSpace,
366
363
  postComment,
367
364
  _location: location()
368
365
  });
369
366
  }
370
- chunkCHM43IJO_js.__name(peg$f6, "peg$f6");
371
- function peg$f7(name, val) {
372
- return new chunkCHM43IJO_js.ParsedEnvSpecDecorator({
367
+ chunkX4PJ2KLO_js.__name(peg$f5, "peg$f5");
368
+ function peg$f6(name, val) {
369
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecDecorator({
373
370
  name,
374
371
  value: Array.isArray(val) ? val[1] : val,
375
372
  isBareFnCall: val && !Array.isArray(val),
376
373
  _location: location()
377
374
  });
378
375
  }
379
- chunkCHM43IJO_js.__name(peg$f7, "peg$f7");
380
- function peg$f8(name, args) {
381
- return new chunkCHM43IJO_js.ParsedEnvSpecFunctionCall({
376
+ chunkX4PJ2KLO_js.__name(peg$f6, "peg$f6");
377
+ function peg$f7(name, args) {
378
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecFunctionCall({
382
379
  name,
383
380
  args,
384
381
  _location: location()
385
382
  });
386
383
  }
387
- chunkCHM43IJO_js.__name(peg$f8, "peg$f8");
388
- function peg$f9(key, val) {
389
- return new chunkCHM43IJO_js.ParsedEnvSpecKeyValuePair({ key, val });
384
+ chunkX4PJ2KLO_js.__name(peg$f7, "peg$f7");
385
+ function peg$f8(key, val) {
386
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecKeyValuePair({ key, val });
390
387
  }
391
- chunkCHM43IJO_js.__name(peg$f9, "peg$f9");
392
- function peg$f10(values) {
393
- return new chunkCHM43IJO_js.ParsedEnvSpecFunctionArgs({
388
+ chunkX4PJ2KLO_js.__name(peg$f8, "peg$f8");
389
+ function peg$f9(values) {
390
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecFunctionArgs({
394
391
  values: values || [],
395
392
  _location: location()
396
393
  });
397
394
  }
398
- chunkCHM43IJO_js.__name(peg$f10, "peg$f10");
399
- function peg$f11() {
400
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
395
+ chunkX4PJ2KLO_js.__name(peg$f9, "peg$f9");
396
+ function peg$f10() {
397
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
401
398
  }
402
- chunkCHM43IJO_js.__name(peg$f11, "peg$f11");
403
- function peg$f12(name, args) {
404
- return new chunkCHM43IJO_js.ParsedEnvSpecFunctionCall({
399
+ chunkX4PJ2KLO_js.__name(peg$f10, "peg$f10");
400
+ function peg$f11(name, args) {
401
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecFunctionCall({
405
402
  name,
406
403
  args,
407
404
  _location: location()
408
405
  });
409
406
  }
410
- chunkCHM43IJO_js.__name(peg$f12, "peg$f12");
411
- function peg$f13(key, val) {
412
- return new chunkCHM43IJO_js.ParsedEnvSpecKeyValuePair({ key, val });
407
+ chunkX4PJ2KLO_js.__name(peg$f11, "peg$f11");
408
+ function peg$f12(key, val) {
409
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecKeyValuePair({ key, val });
413
410
  }
414
- chunkCHM43IJO_js.__name(peg$f13, "peg$f13");
415
- function peg$f14(values) {
416
- return new chunkCHM43IJO_js.ParsedEnvSpecFunctionArgs({
411
+ chunkX4PJ2KLO_js.__name(peg$f12, "peg$f12");
412
+ function peg$f13(values) {
413
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecFunctionArgs({
417
414
  values: values || [],
418
415
  _location: location()
419
416
  });
420
417
  }
421
- chunkCHM43IJO_js.__name(peg$f14, "peg$f14");
422
- function peg$f15() {
423
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
418
+ chunkX4PJ2KLO_js.__name(peg$f13, "peg$f13");
419
+ function peg$f14() {
420
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
424
421
  }
425
- chunkCHM43IJO_js.__name(peg$f15, "peg$f15");
426
- function peg$f16(leadingSpace, contents) {
427
- return new chunkCHM43IJO_js.ParsedEnvSpecDivider({
422
+ chunkX4PJ2KLO_js.__name(peg$f14, "peg$f14");
423
+ function peg$f15(leadingSpace, contents) {
424
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecDivider({
428
425
  contents,
429
426
  leadingSpace,
430
427
  _location: location()
431
428
  });
432
429
  }
433
- chunkCHM43IJO_js.__name(peg$f16, "peg$f16");
434
- function peg$f17(pattern, flags) {
435
- return new chunkCHM43IJO_js.ParsedEnvSpecRegexLiteral({
436
- rawValue: text(),
437
- pattern: pattern.replaceAll("\\/", "/"),
438
- flags,
439
- _location: location()
440
- });
430
+ chunkX4PJ2KLO_js.__name(peg$f15, "peg$f15");
431
+ function peg$f16() {
432
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
441
433
  }
442
- chunkCHM43IJO_js.__name(peg$f17, "peg$f17");
443
- function peg$f18() {
444
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
434
+ chunkX4PJ2KLO_js.__name(peg$f16, "peg$f16");
435
+ function peg$f17() {
436
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
445
437
  }
446
- chunkCHM43IJO_js.__name(peg$f18, "peg$f18");
447
- function peg$f19() {
448
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
438
+ chunkX4PJ2KLO_js.__name(peg$f17, "peg$f17");
439
+ function peg$f18(quote) {
440
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
449
441
  }
450
- chunkCHM43IJO_js.__name(peg$f19, "peg$f19");
442
+ chunkX4PJ2KLO_js.__name(peg$f18, "peg$f18");
443
+ function peg$f19(quote) {
444
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
445
+ }
446
+ chunkX4PJ2KLO_js.__name(peg$f19, "peg$f19");
451
447
  function peg$f20(quote) {
452
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
448
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
453
449
  }
454
- chunkCHM43IJO_js.__name(peg$f20, "peg$f20");
450
+ chunkX4PJ2KLO_js.__name(peg$f20, "peg$f20");
455
451
  function peg$f21(quote) {
456
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
452
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
457
453
  }
458
- chunkCHM43IJO_js.__name(peg$f21, "peg$f21");
454
+ chunkX4PJ2KLO_js.__name(peg$f21, "peg$f21");
459
455
  function peg$f22(quote) {
460
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
456
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
461
457
  }
462
- chunkCHM43IJO_js.__name(peg$f22, "peg$f22");
458
+ chunkX4PJ2KLO_js.__name(peg$f22, "peg$f22");
463
459
  function peg$f23(quote) {
464
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
460
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
465
461
  }
466
- chunkCHM43IJO_js.__name(peg$f23, "peg$f23");
462
+ chunkX4PJ2KLO_js.__name(peg$f23, "peg$f23");
467
463
  function peg$f24(quote) {
468
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
469
- }
470
- chunkCHM43IJO_js.__name(peg$f24, "peg$f24");
471
- function peg$f25(quote) {
472
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
473
- }
474
- chunkCHM43IJO_js.__name(peg$f25, "peg$f25");
475
- function peg$f26(quote) {
476
- return new chunkCHM43IJO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
464
+ return new chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
477
465
  }
478
- chunkCHM43IJO_js.__name(peg$f26, "peg$f26");
466
+ chunkX4PJ2KLO_js.__name(peg$f24, "peg$f24");
479
467
  let peg$currPos = options.peg$currPos | 0;
480
468
  let peg$savedPos = peg$currPos;
481
469
  const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -492,11 +480,11 @@ function peg$parse(input, options) {
492
480
  function text() {
493
481
  return input.substring(peg$savedPos, peg$currPos);
494
482
  }
495
- chunkCHM43IJO_js.__name(text, "text");
483
+ chunkX4PJ2KLO_js.__name(text, "text");
496
484
  function offset() {
497
485
  return peg$savedPos;
498
486
  }
499
- chunkCHM43IJO_js.__name(offset, "offset");
487
+ chunkX4PJ2KLO_js.__name(offset, "offset");
500
488
  function range() {
501
489
  return {
502
490
  source: peg$source,
@@ -504,11 +492,11 @@ function peg$parse(input, options) {
504
492
  end: peg$currPos
505
493
  };
506
494
  }
507
- chunkCHM43IJO_js.__name(range, "range");
495
+ chunkX4PJ2KLO_js.__name(range, "range");
508
496
  function location() {
509
497
  return peg$computeLocation(peg$savedPos, peg$currPos);
510
498
  }
511
- chunkCHM43IJO_js.__name(location, "location");
499
+ chunkX4PJ2KLO_js.__name(location, "location");
512
500
  function expected(description, location2) {
513
501
  location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
514
502
  throw peg$buildStructuredError(
@@ -517,12 +505,12 @@ function peg$parse(input, options) {
517
505
  location2
518
506
  );
519
507
  }
520
- chunkCHM43IJO_js.__name(expected, "expected");
508
+ chunkX4PJ2KLO_js.__name(expected, "expected");
521
509
  function error(message, location2) {
522
510
  location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
523
511
  throw peg$buildSimpleError(message, location2);
524
512
  }
525
- chunkCHM43IJO_js.__name(error, "error");
513
+ chunkX4PJ2KLO_js.__name(error, "error");
526
514
  function peg$getUnicode(pos = peg$currPos) {
527
515
  const cp = input.codePointAt(pos);
528
516
  if (cp === void 0) {
@@ -530,27 +518,27 @@ function peg$parse(input, options) {
530
518
  }
531
519
  return String.fromCodePoint(cp);
532
520
  }
533
- chunkCHM43IJO_js.__name(peg$getUnicode, "peg$getUnicode");
521
+ chunkX4PJ2KLO_js.__name(peg$getUnicode, "peg$getUnicode");
534
522
  function peg$literalExpectation(text2, ignoreCase) {
535
523
  return { type: "literal", text: text2, ignoreCase };
536
524
  }
537
- chunkCHM43IJO_js.__name(peg$literalExpectation, "peg$literalExpectation");
525
+ chunkX4PJ2KLO_js.__name(peg$literalExpectation, "peg$literalExpectation");
538
526
  function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
539
527
  return { type: "class", parts, inverted, ignoreCase, unicode };
540
528
  }
541
- chunkCHM43IJO_js.__name(peg$classExpectation, "peg$classExpectation");
529
+ chunkX4PJ2KLO_js.__name(peg$classExpectation, "peg$classExpectation");
542
530
  function peg$anyExpectation() {
543
531
  return { type: "any" };
544
532
  }
545
- chunkCHM43IJO_js.__name(peg$anyExpectation, "peg$anyExpectation");
533
+ chunkX4PJ2KLO_js.__name(peg$anyExpectation, "peg$anyExpectation");
546
534
  function peg$endExpectation() {
547
535
  return { type: "end" };
548
536
  }
549
- chunkCHM43IJO_js.__name(peg$endExpectation, "peg$endExpectation");
537
+ chunkX4PJ2KLO_js.__name(peg$endExpectation, "peg$endExpectation");
550
538
  function peg$otherExpectation(description) {
551
539
  return { type: "other", description };
552
540
  }
553
- chunkCHM43IJO_js.__name(peg$otherExpectation, "peg$otherExpectation");
541
+ chunkX4PJ2KLO_js.__name(peg$otherExpectation, "peg$otherExpectation");
554
542
  function peg$computePosDetails(pos) {
555
543
  let details = peg$posDetailsCache[pos];
556
544
  let p;
@@ -582,7 +570,7 @@ function peg$parse(input, options) {
582
570
  return details;
583
571
  }
584
572
  }
585
- chunkCHM43IJO_js.__name(peg$computePosDetails, "peg$computePosDetails");
573
+ chunkX4PJ2KLO_js.__name(peg$computePosDetails, "peg$computePosDetails");
586
574
  function peg$computeLocation(startPos, endPos, offset2) {
587
575
  const startPosDetails = peg$computePosDetails(startPos);
588
576
  const endPosDetails = peg$computePosDetails(endPos);
@@ -605,7 +593,7 @@ function peg$parse(input, options) {
605
593
  }
606
594
  return res;
607
595
  }
608
- chunkCHM43IJO_js.__name(peg$computeLocation, "peg$computeLocation");
596
+ chunkX4PJ2KLO_js.__name(peg$computeLocation, "peg$computeLocation");
609
597
  function peg$fail(expected2) {
610
598
  if (peg$currPos < peg$maxFailPos) {
611
599
  return;
@@ -616,11 +604,11 @@ function peg$parse(input, options) {
616
604
  }
617
605
  peg$maxFailExpected.push(expected2);
618
606
  }
619
- chunkCHM43IJO_js.__name(peg$fail, "peg$fail");
607
+ chunkX4PJ2KLO_js.__name(peg$fail, "peg$fail");
620
608
  function peg$buildSimpleError(message, location2) {
621
609
  return new peg$SyntaxError(message, null, null, location2);
622
610
  }
623
- chunkCHM43IJO_js.__name(peg$buildSimpleError, "peg$buildSimpleError");
611
+ chunkX4PJ2KLO_js.__name(peg$buildSimpleError, "peg$buildSimpleError");
624
612
  function peg$buildStructuredError(expected2, found, location2) {
625
613
  return new peg$SyntaxError(
626
614
  peg$SyntaxError.buildMessage(expected2, found),
@@ -629,7 +617,7 @@ function peg$parse(input, options) {
629
617
  location2
630
618
  );
631
619
  }
632
- chunkCHM43IJO_js.__name(peg$buildStructuredError, "peg$buildStructuredError");
620
+ chunkX4PJ2KLO_js.__name(peg$buildStructuredError, "peg$buildStructuredError");
633
621
  function peg$parseEnvSpecFile() {
634
622
  let s0, s1, s2, s3;
635
623
  s0 = peg$currPos;
@@ -690,18 +678,15 @@ function peg$parse(input, options) {
690
678
  s0 = s1;
691
679
  return s0;
692
680
  }
693
- chunkCHM43IJO_js.__name(peg$parseEnvSpecFile, "peg$parseEnvSpecFile");
681
+ chunkX4PJ2KLO_js.__name(peg$parseEnvSpecFile, "peg$parseEnvSpecFile");
694
682
  function peg$parseConfigItem() {
695
683
  let s0, s1, s2, s3, s4, s5, s6, s7, s9, s10;
696
684
  s0 = peg$currPos;
697
685
  s1 = [];
698
686
  s2 = peg$currPos;
699
- s3 = peg$parseIgnoredDecoratorComment();
687
+ s3 = peg$parseDecoratorComment();
700
688
  if (s3 === peg$FAILED) {
701
- s3 = peg$parseDecoratorComment();
702
- if (s3 === peg$FAILED) {
703
- s3 = peg$parseComment();
704
- }
689
+ s3 = peg$parseComment();
705
690
  }
706
691
  if (s3 !== peg$FAILED) {
707
692
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -726,12 +711,9 @@ function peg$parse(input, options) {
726
711
  while (s2 !== peg$FAILED) {
727
712
  s1.push(s2);
728
713
  s2 = peg$currPos;
729
- s3 = peg$parseIgnoredDecoratorComment();
714
+ s3 = peg$parseDecoratorComment();
730
715
  if (s3 === peg$FAILED) {
731
- s3 = peg$parseDecoratorComment();
732
- if (s3 === peg$FAILED) {
733
- s3 = peg$parseComment();
734
- }
716
+ s3 = peg$parseComment();
735
717
  }
736
718
  if (s3 !== peg$FAILED) {
737
719
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -796,12 +778,9 @@ function peg$parse(input, options) {
796
778
  }
797
779
  peg$parse_();
798
780
  s9 = peg$currPos;
799
- s10 = peg$parseIgnoredDecoratorComment();
781
+ s10 = peg$parseDecoratorComment();
800
782
  if (s10 === peg$FAILED) {
801
- s10 = peg$parseDecoratorComment();
802
- if (s10 === peg$FAILED) {
803
- s10 = peg$parseComment();
804
- }
783
+ s10 = peg$parseComment();
805
784
  }
806
785
  if (s10 !== peg$FAILED) {
807
786
  s9 = s10;
@@ -830,7 +809,7 @@ function peg$parse(input, options) {
830
809
  }
831
810
  return s0;
832
811
  }
833
- chunkCHM43IJO_js.__name(peg$parseConfigItem, "peg$parseConfigItem");
812
+ chunkX4PJ2KLO_js.__name(peg$parseConfigItem, "peg$parseConfigItem");
834
813
  function peg$parseConfigItemKey() {
835
814
  let s0, s1, s2, s3, s4;
836
815
  s0 = peg$currPos;
@@ -880,36 +859,30 @@ function peg$parse(input, options) {
880
859
  }
881
860
  return s0;
882
861
  }
883
- chunkCHM43IJO_js.__name(peg$parseConfigItemKey, "peg$parseConfigItemKey");
862
+ chunkX4PJ2KLO_js.__name(peg$parseConfigItemKey, "peg$parseConfigItemKey");
884
863
  function peg$parseConfigItemValue() {
885
864
  let s0;
886
865
  s0 = peg$parseFunctionCall();
887
866
  if (s0 === peg$FAILED) {
888
- s0 = peg$parseRegexLiteral();
867
+ s0 = peg$parsemultiLineString();
889
868
  if (s0 === peg$FAILED) {
890
- s0 = peg$parsemultiLineString();
869
+ s0 = peg$parsequotedString();
891
870
  if (s0 === peg$FAILED) {
892
- s0 = peg$parsequotedString();
893
- if (s0 === peg$FAILED) {
894
- s0 = peg$parseunquotedString();
895
- }
871
+ s0 = peg$parseunquotedString();
896
872
  }
897
873
  }
898
874
  }
899
875
  return s0;
900
876
  }
901
- chunkCHM43IJO_js.__name(peg$parseConfigItemValue, "peg$parseConfigItemValue");
877
+ chunkX4PJ2KLO_js.__name(peg$parseConfigItemValue, "peg$parseConfigItemValue");
902
878
  function peg$parseCommentBlock() {
903
879
  let s0, s1, s2, s3, s4;
904
880
  s0 = peg$currPos;
905
881
  s1 = [];
906
882
  s2 = peg$currPos;
907
- s3 = peg$parseIgnoredDecoratorComment();
883
+ s3 = peg$parseDecoratorComment();
908
884
  if (s3 === peg$FAILED) {
909
- s3 = peg$parseDecoratorComment();
910
- if (s3 === peg$FAILED) {
911
- s3 = peg$parseComment();
912
- }
885
+ s3 = peg$parseComment();
913
886
  }
914
887
  if (s3 !== peg$FAILED) {
915
888
  s4 = peg$parse_n();
@@ -927,12 +900,9 @@ function peg$parse(input, options) {
927
900
  while (s2 !== peg$FAILED) {
928
901
  s1.push(s2);
929
902
  s2 = peg$currPos;
930
- s3 = peg$parseIgnoredDecoratorComment();
903
+ s3 = peg$parseDecoratorComment();
931
904
  if (s3 === peg$FAILED) {
932
- s3 = peg$parseDecoratorComment();
933
- if (s3 === peg$FAILED) {
934
- s3 = peg$parseComment();
935
- }
905
+ s3 = peg$parseComment();
936
906
  }
937
907
  if (s3 !== peg$FAILED) {
938
908
  s4 = peg$parse_n();
@@ -968,7 +938,7 @@ function peg$parse(input, options) {
968
938
  }
969
939
  return s0;
970
940
  }
971
- chunkCHM43IJO_js.__name(peg$parseCommentBlock, "peg$parseCommentBlock");
941
+ chunkX4PJ2KLO_js.__name(peg$parseCommentBlock, "peg$parseCommentBlock");
972
942
  function peg$parseComment() {
973
943
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
974
944
  s0 = peg$currPos;
@@ -1063,8 +1033,8 @@ function peg$parse(input, options) {
1063
1033
  }
1064
1034
  return s0;
1065
1035
  }
1066
- chunkCHM43IJO_js.__name(peg$parseComment, "peg$parseComment");
1067
- function peg$parseIgnoredDecoratorComment() {
1036
+ chunkX4PJ2KLO_js.__name(peg$parseComment, "peg$parseComment");
1037
+ function peg$parseDecoratorComment() {
1068
1038
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1069
1039
  s0 = peg$currPos;
1070
1040
  if (input.charCodeAt(peg$currPos) === 35) {
@@ -1080,65 +1050,55 @@ function peg$parse(input, options) {
1080
1050
  s2 = peg$currPos;
1081
1051
  s3 = peg$parse_();
1082
1052
  s2 = input.substring(s2, peg$currPos);
1083
- s3 = peg$currPos;
1084
- s4 = peg$currPos;
1085
- if (input.charCodeAt(peg$currPos) === 64) {
1086
- s5 = peg$c4;
1087
- peg$currPos++;
1088
- } else {
1089
- s5 = peg$FAILED;
1090
- if (peg$silentFails === 0) {
1091
- peg$fail(peg$e6);
1092
- }
1093
- }
1094
- if (s5 !== peg$FAILED) {
1095
- s6 = [];
1096
- s7 = input.charAt(peg$currPos);
1097
- if (peg$r3.test(s7)) {
1098
- peg$currPos++;
1099
- } else {
1100
- s7 = peg$FAILED;
1101
- if (peg$silentFails === 0) {
1102
- peg$fail(peg$e8);
1053
+ s3 = peg$parseDecorator();
1054
+ if (s3 !== peg$FAILED) {
1055
+ s4 = [];
1056
+ s5 = peg$currPos;
1057
+ s6 = peg$parse__();
1058
+ if (s6 !== peg$FAILED) {
1059
+ s7 = peg$parseDecorator();
1060
+ if (s7 !== peg$FAILED) {
1061
+ s5 = s7;
1062
+ } else {
1063
+ peg$currPos = s5;
1064
+ s5 = peg$FAILED;
1103
1065
  }
1066
+ } else {
1067
+ peg$currPos = s5;
1068
+ s5 = peg$FAILED;
1104
1069
  }
1105
- if (s7 !== peg$FAILED) {
1106
- while (s7 !== peg$FAILED) {
1107
- s6.push(s7);
1108
- s7 = input.charAt(peg$currPos);
1109
- if (peg$r3.test(s7)) {
1110
- peg$currPos++;
1070
+ while (s5 !== peg$FAILED) {
1071
+ s4.push(s5);
1072
+ s5 = peg$currPos;
1073
+ s6 = peg$parse__();
1074
+ if (s6 !== peg$FAILED) {
1075
+ s7 = peg$parseDecorator();
1076
+ if (s7 !== peg$FAILED) {
1077
+ s5 = s7;
1111
1078
  } else {
1112
- s7 = peg$FAILED;
1113
- if (peg$silentFails === 0) {
1114
- peg$fail(peg$e8);
1115
- }
1079
+ peg$currPos = s5;
1080
+ s5 = peg$FAILED;
1116
1081
  }
1082
+ } else {
1083
+ peg$currPos = s5;
1084
+ s5 = peg$FAILED;
1117
1085
  }
1118
- } else {
1119
- s6 = peg$FAILED;
1120
1086
  }
1087
+ s5 = peg$currPos;
1088
+ s6 = peg$parse__();
1121
1089
  if (s6 !== peg$FAILED) {
1122
- if (input.charCodeAt(peg$currPos) === 58) {
1123
- s7 = peg$c5;
1090
+ s7 = peg$currPos;
1091
+ s8 = [];
1092
+ s9 = input.charAt(peg$currPos);
1093
+ if (peg$r2.test(s9)) {
1124
1094
  peg$currPos++;
1125
1095
  } else {
1126
- s7 = peg$FAILED;
1096
+ s9 = peg$FAILED;
1127
1097
  if (peg$silentFails === 0) {
1128
- peg$fail(peg$e9);
1098
+ peg$fail(peg$e7);
1129
1099
  }
1130
1100
  }
1131
- if (s7 !== peg$FAILED) {
1132
- s8 = [];
1133
- s9 = input.charAt(peg$currPos);
1134
- if (peg$r2.test(s9)) {
1135
- peg$currPos++;
1136
- } else {
1137
- s9 = peg$FAILED;
1138
- if (peg$silentFails === 0) {
1139
- peg$fail(peg$e7);
1140
- }
1141
- }
1101
+ if (s9 !== peg$FAILED) {
1142
1102
  while (s9 !== peg$FAILED) {
1143
1103
  s8.push(s9);
1144
1104
  s9 = input.charAt(peg$currPos);
@@ -1151,163 +1111,14 @@ function peg$parse(input, options) {
1151
1111
  }
1152
1112
  }
1153
1113
  }
1154
- s5 = [s5, s6, s7, s8];
1155
- s4 = s5;
1156
1114
  } else {
1157
- peg$currPos = s4;
1158
- s4 = peg$FAILED;
1159
- }
1160
- } else {
1161
- peg$currPos = s4;
1162
- s4 = peg$FAILED;
1163
- }
1164
- } else {
1165
- peg$currPos = s4;
1166
- s4 = peg$FAILED;
1167
- }
1168
- if (s4 === peg$FAILED) {
1169
- s4 = peg$currPos;
1170
- if (input.charCodeAt(peg$currPos) === 64) {
1171
- s5 = peg$c4;
1172
- peg$currPos++;
1173
- } else {
1174
- s5 = peg$FAILED;
1175
- if (peg$silentFails === 0) {
1176
- peg$fail(peg$e6);
1115
+ s8 = peg$FAILED;
1177
1116
  }
1178
- }
1179
- if (s5 !== peg$FAILED) {
1180
- s6 = [];
1181
- s7 = input.charAt(peg$currPos);
1182
- if (peg$r3.test(s7)) {
1183
- peg$currPos++;
1117
+ if (s8 !== peg$FAILED) {
1118
+ s7 = input.substring(s7, peg$currPos);
1184
1119
  } else {
1185
- s7 = peg$FAILED;
1186
- if (peg$silentFails === 0) {
1187
- peg$fail(peg$e8);
1188
- }
1120
+ s7 = s8;
1189
1121
  }
1190
- if (s7 !== peg$FAILED) {
1191
- while (s7 !== peg$FAILED) {
1192
- s6.push(s7);
1193
- s7 = input.charAt(peg$currPos);
1194
- if (peg$r3.test(s7)) {
1195
- peg$currPos++;
1196
- } else {
1197
- s7 = peg$FAILED;
1198
- if (peg$silentFails === 0) {
1199
- peg$fail(peg$e8);
1200
- }
1201
- }
1202
- }
1203
- } else {
1204
- s6 = peg$FAILED;
1205
- }
1206
- if (s6 !== peg$FAILED) {
1207
- s7 = peg$parse__();
1208
- if (s7 !== peg$FAILED) {
1209
- s8 = peg$currPos;
1210
- peg$silentFails++;
1211
- s9 = input.charAt(peg$currPos);
1212
- if (peg$r4.test(s9)) {
1213
- peg$currPos++;
1214
- } else {
1215
- s9 = peg$FAILED;
1216
- if (peg$silentFails === 0) {
1217
- peg$fail(peg$e10);
1218
- }
1219
- }
1220
- peg$silentFails--;
1221
- if (s9 === peg$FAILED) {
1222
- s8 = void 0;
1223
- } else {
1224
- peg$currPos = s8;
1225
- s8 = peg$FAILED;
1226
- }
1227
- if (s8 !== peg$FAILED) {
1228
- s9 = [];
1229
- s10 = input.charAt(peg$currPos);
1230
- if (peg$r2.test(s10)) {
1231
- peg$currPos++;
1232
- } else {
1233
- s10 = peg$FAILED;
1234
- if (peg$silentFails === 0) {
1235
- peg$fail(peg$e7);
1236
- }
1237
- }
1238
- while (s10 !== peg$FAILED) {
1239
- s9.push(s10);
1240
- s10 = input.charAt(peg$currPos);
1241
- if (peg$r2.test(s10)) {
1242
- peg$currPos++;
1243
- } else {
1244
- s10 = peg$FAILED;
1245
- if (peg$silentFails === 0) {
1246
- peg$fail(peg$e7);
1247
- }
1248
- }
1249
- }
1250
- s5 = [s5, s6, s7, s8, s9];
1251
- s4 = s5;
1252
- } else {
1253
- peg$currPos = s4;
1254
- s4 = peg$FAILED;
1255
- }
1256
- } else {
1257
- peg$currPos = s4;
1258
- s4 = peg$FAILED;
1259
- }
1260
- } else {
1261
- peg$currPos = s4;
1262
- s4 = peg$FAILED;
1263
- }
1264
- } else {
1265
- peg$currPos = s4;
1266
- s4 = peg$FAILED;
1267
- }
1268
- }
1269
- if (s4 !== peg$FAILED) {
1270
- s3 = input.substring(s3, peg$currPos);
1271
- } else {
1272
- s3 = s4;
1273
- }
1274
- if (s3 !== peg$FAILED) {
1275
- peg$savedPos = s0;
1276
- s0 = peg$f5(s2, s3);
1277
- } else {
1278
- peg$currPos = s0;
1279
- s0 = peg$FAILED;
1280
- }
1281
- } else {
1282
- peg$currPos = s0;
1283
- s0 = peg$FAILED;
1284
- }
1285
- return s0;
1286
- }
1287
- chunkCHM43IJO_js.__name(peg$parseIgnoredDecoratorComment, "peg$parseIgnoredDecoratorComment");
1288
- function peg$parseDecoratorComment() {
1289
- let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1290
- s0 = peg$currPos;
1291
- if (input.charCodeAt(peg$currPos) === 35) {
1292
- s1 = peg$c3;
1293
- peg$currPos++;
1294
- } else {
1295
- s1 = peg$FAILED;
1296
- if (peg$silentFails === 0) {
1297
- peg$fail(peg$e5);
1298
- }
1299
- }
1300
- if (s1 !== peg$FAILED) {
1301
- s2 = peg$currPos;
1302
- s3 = peg$parse_();
1303
- s2 = input.substring(s2, peg$currPos);
1304
- s3 = peg$parseDecorator();
1305
- if (s3 !== peg$FAILED) {
1306
- s4 = [];
1307
- s5 = peg$currPos;
1308
- s6 = peg$parse__();
1309
- if (s6 !== peg$FAILED) {
1310
- s7 = peg$parseDecorator();
1311
1122
  if (s7 !== peg$FAILED) {
1312
1123
  s5 = s7;
1313
1124
  } else {
@@ -1318,48 +1129,21 @@ function peg$parse(input, options) {
1318
1129
  peg$currPos = s5;
1319
1130
  s5 = peg$FAILED;
1320
1131
  }
1321
- while (s5 !== peg$FAILED) {
1322
- s4.push(s5);
1132
+ if (s5 === peg$FAILED) {
1323
1133
  s5 = peg$currPos;
1324
- s6 = peg$parse__();
1325
- if (s6 !== peg$FAILED) {
1326
- s7 = peg$parseDecorator();
1327
- if (s7 !== peg$FAILED) {
1328
- s5 = s7;
1329
- } else {
1330
- peg$currPos = s5;
1331
- s5 = peg$FAILED;
1332
- }
1333
- } else {
1334
- peg$currPos = s5;
1335
- s5 = peg$FAILED;
1336
- }
1337
- }
1338
- s5 = peg$parse_();
1339
- s6 = peg$currPos;
1340
- s7 = peg$currPos;
1341
- if (input.charCodeAt(peg$currPos) === 35) {
1342
- s8 = peg$c3;
1343
- peg$currPos++;
1344
- } else {
1345
- s8 = peg$FAILED;
1346
- if (peg$silentFails === 0) {
1347
- peg$fail(peg$e5);
1348
- }
1349
- }
1350
- if (s8 !== peg$FAILED) {
1351
- s9 = [];
1352
- s10 = input.charAt(peg$currPos);
1353
- if (peg$r2.test(s10)) {
1134
+ s6 = peg$currPos;
1135
+ s7 = peg$currPos;
1136
+ if (input.charCodeAt(peg$currPos) === 35) {
1137
+ s8 = peg$c3;
1354
1138
  peg$currPos++;
1355
1139
  } else {
1356
- s10 = peg$FAILED;
1140
+ s8 = peg$FAILED;
1357
1141
  if (peg$silentFails === 0) {
1358
- peg$fail(peg$e7);
1142
+ peg$fail(peg$e5);
1359
1143
  }
1360
1144
  }
1361
- while (s10 !== peg$FAILED) {
1362
- s9.push(s10);
1145
+ if (s8 !== peg$FAILED) {
1146
+ s9 = [];
1363
1147
  s10 = input.charAt(peg$currPos);
1364
1148
  if (peg$r2.test(s10)) {
1365
1149
  peg$currPos++;
@@ -1369,19 +1153,42 @@ function peg$parse(input, options) {
1369
1153
  peg$fail(peg$e7);
1370
1154
  }
1371
1155
  }
1156
+ while (s10 !== peg$FAILED) {
1157
+ s9.push(s10);
1158
+ s10 = input.charAt(peg$currPos);
1159
+ if (peg$r2.test(s10)) {
1160
+ peg$currPos++;
1161
+ } else {
1162
+ s10 = peg$FAILED;
1163
+ if (peg$silentFails === 0) {
1164
+ peg$fail(peg$e7);
1165
+ }
1166
+ }
1167
+ }
1168
+ s8 = [s8, s9];
1169
+ s7 = s8;
1170
+ } else {
1171
+ peg$currPos = s7;
1172
+ s7 = peg$FAILED;
1173
+ }
1174
+ if (s7 !== peg$FAILED) {
1175
+ s6 = input.substring(s6, peg$currPos);
1176
+ } else {
1177
+ s6 = s7;
1178
+ }
1179
+ if (s6 !== peg$FAILED) {
1180
+ s5 = s6;
1181
+ } else {
1182
+ peg$currPos = s5;
1183
+ s5 = peg$FAILED;
1372
1184
  }
1373
- s8 = [s8, s9];
1374
- s7 = s8;
1375
- } else {
1376
- peg$currPos = s7;
1377
- s7 = peg$FAILED;
1378
1185
  }
1379
- if (s7 === peg$FAILED) {
1380
- s7 = null;
1186
+ if (s5 === peg$FAILED) {
1187
+ s5 = null;
1381
1188
  }
1382
- s6 = input.substring(s6, peg$currPos);
1189
+ s6 = peg$parse_();
1383
1190
  peg$savedPos = s0;
1384
- s0 = peg$f6(s2, s3, s4, s6);
1191
+ s0 = peg$f5(s2, s3, s4, s5);
1385
1192
  } else {
1386
1193
  peg$currPos = s0;
1387
1194
  s0 = peg$FAILED;
@@ -1392,7 +1199,7 @@ function peg$parse(input, options) {
1392
1199
  }
1393
1200
  return s0;
1394
1201
  }
1395
- chunkCHM43IJO_js.__name(peg$parseDecoratorComment, "peg$parseDecoratorComment");
1202
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorComment, "peg$parseDecoratorComment");
1396
1203
  function peg$parseDecorator() {
1397
1204
  let s0, s1, s2, s3, s4, s5;
1398
1205
  s0 = peg$currPos;
@@ -1438,7 +1245,7 @@ function peg$parse(input, options) {
1438
1245
  s3 = null;
1439
1246
  }
1440
1247
  peg$savedPos = s0;
1441
- s0 = peg$f7(s2, s3);
1248
+ s0 = peg$f6(s2, s3);
1442
1249
  } else {
1443
1250
  peg$currPos = s0;
1444
1251
  s0 = peg$FAILED;
@@ -1449,7 +1256,7 @@ function peg$parse(input, options) {
1449
1256
  }
1450
1257
  return s0;
1451
1258
  }
1452
- chunkCHM43IJO_js.__name(peg$parseDecorator, "peg$parseDecorator");
1259
+ chunkX4PJ2KLO_js.__name(peg$parseDecorator, "peg$parseDecorator");
1453
1260
  function peg$parseDecoratorName() {
1454
1261
  let s0, s1, s2, s3, s4;
1455
1262
  s0 = peg$currPos;
@@ -1466,23 +1273,23 @@ function peg$parse(input, options) {
1466
1273
  if (s2 !== peg$FAILED) {
1467
1274
  s3 = [];
1468
1275
  s4 = input.charAt(peg$currPos);
1469
- if (peg$r5.test(s4)) {
1276
+ if (peg$r4.test(s4)) {
1470
1277
  peg$currPos++;
1471
1278
  } else {
1472
1279
  s4 = peg$FAILED;
1473
1280
  if (peg$silentFails === 0) {
1474
- peg$fail(peg$e11);
1281
+ peg$fail(peg$e9);
1475
1282
  }
1476
1283
  }
1477
1284
  while (s4 !== peg$FAILED) {
1478
1285
  s3.push(s4);
1479
1286
  s4 = input.charAt(peg$currPos);
1480
- if (peg$r5.test(s4)) {
1287
+ if (peg$r4.test(s4)) {
1481
1288
  peg$currPos++;
1482
1289
  } else {
1483
1290
  s4 = peg$FAILED;
1484
1291
  if (peg$silentFails === 0) {
1485
- peg$fail(peg$e11);
1292
+ peg$fail(peg$e9);
1486
1293
  }
1487
1294
  }
1488
1295
  }
@@ -1499,22 +1306,19 @@ function peg$parse(input, options) {
1499
1306
  }
1500
1307
  return s0;
1501
1308
  }
1502
- chunkCHM43IJO_js.__name(peg$parseDecoratorName, "peg$parseDecoratorName");
1309
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorName, "peg$parseDecoratorName");
1503
1310
  function peg$parseDecoratorValue() {
1504
1311
  let s0;
1505
1312
  s0 = peg$parseDecoratorFunctionCall();
1506
1313
  if (s0 === peg$FAILED) {
1507
- s0 = peg$parseRegexLiteral();
1314
+ s0 = peg$parsequotedString();
1508
1315
  if (s0 === peg$FAILED) {
1509
- s0 = peg$parsequotedString();
1510
- if (s0 === peg$FAILED) {
1511
- s0 = peg$parseunquotedStringWithoutSpaces();
1512
- }
1316
+ s0 = peg$parseunquotedStringWithoutSpaces();
1513
1317
  }
1514
1318
  }
1515
1319
  return s0;
1516
1320
  }
1517
- chunkCHM43IJO_js.__name(peg$parseDecoratorValue, "peg$parseDecoratorValue");
1321
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorValue, "peg$parseDecoratorValue");
1518
1322
  function peg$parseDecoratorFunctionCall() {
1519
1323
  let s0, s1, s2;
1520
1324
  s0 = peg$currPos;
@@ -1523,7 +1327,7 @@ function peg$parse(input, options) {
1523
1327
  s2 = peg$parseDecoratorFunctionArgs();
1524
1328
  if (s2 !== peg$FAILED) {
1525
1329
  peg$savedPos = s0;
1526
- s0 = peg$f8(s1, s2);
1330
+ s0 = peg$f7(s1, s2);
1527
1331
  } else {
1528
1332
  peg$currPos = s0;
1529
1333
  s0 = peg$FAILED;
@@ -1534,17 +1338,17 @@ function peg$parse(input, options) {
1534
1338
  }
1535
1339
  return s0;
1536
1340
  }
1537
- chunkCHM43IJO_js.__name(peg$parseDecoratorFunctionCall, "peg$parseDecoratorFunctionCall");
1341
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorFunctionCall, "peg$parseDecoratorFunctionCall");
1538
1342
  function peg$parseDecoratorFunctionArgs() {
1539
1343
  let s0, s1, s3, s4, s5, s6, s7, s8, s9;
1540
1344
  s0 = peg$currPos;
1541
1345
  if (input.charCodeAt(peg$currPos) === 40) {
1542
- s1 = peg$c6;
1346
+ s1 = peg$c5;
1543
1347
  peg$currPos++;
1544
1348
  } else {
1545
1349
  s1 = peg$FAILED;
1546
1350
  if (peg$silentFails === 0) {
1547
- peg$fail(peg$e12);
1351
+ peg$fail(peg$e10);
1548
1352
  }
1549
1353
  }
1550
1354
  if (s1 !== peg$FAILED) {
@@ -1567,7 +1371,7 @@ function peg$parse(input, options) {
1567
1371
  s8 = peg$parseDecoratorFunctionArgValue();
1568
1372
  if (s8 !== peg$FAILED) {
1569
1373
  peg$savedPos = s5;
1570
- s5 = peg$f9(s6, s8);
1374
+ s5 = peg$f8(s6, s8);
1571
1375
  } else {
1572
1376
  peg$currPos = s5;
1573
1377
  s5 = peg$FAILED;
@@ -1589,12 +1393,12 @@ function peg$parse(input, options) {
1589
1393
  s6 = peg$currPos;
1590
1394
  s7 = peg$parse_decWs();
1591
1395
  if (input.charCodeAt(peg$currPos) === 44) {
1592
- s8 = peg$c7;
1396
+ s8 = peg$c6;
1593
1397
  peg$currPos++;
1594
1398
  } else {
1595
1399
  s8 = peg$FAILED;
1596
1400
  if (peg$silentFails === 0) {
1597
- peg$fail(peg$e13);
1401
+ peg$fail(peg$e11);
1598
1402
  }
1599
1403
  }
1600
1404
  if (s8 !== peg$FAILED) {
@@ -1622,7 +1426,7 @@ function peg$parse(input, options) {
1622
1426
  s9 = peg$parseDecoratorFunctionArgValue();
1623
1427
  if (s9 !== peg$FAILED) {
1624
1428
  peg$savedPos = s6;
1625
- s6 = peg$f9(s7, s9);
1429
+ s6 = peg$f8(s7, s9);
1626
1430
  } else {
1627
1431
  peg$currPos = s6;
1628
1432
  s6 = peg$FAILED;
@@ -1660,12 +1464,12 @@ function peg$parse(input, options) {
1660
1464
  s4 = peg$currPos;
1661
1465
  s5 = peg$parse_decWs();
1662
1466
  if (input.charCodeAt(peg$currPos) === 44) {
1663
- s6 = peg$c7;
1467
+ s6 = peg$c6;
1664
1468
  peg$currPos++;
1665
1469
  } else {
1666
1470
  s6 = peg$FAILED;
1667
1471
  if (peg$silentFails === 0) {
1668
- peg$fail(peg$e13);
1472
+ peg$fail(peg$e11);
1669
1473
  }
1670
1474
  }
1671
1475
  if (s6 !== peg$FAILED) {
@@ -1680,17 +1484,17 @@ function peg$parse(input, options) {
1680
1484
  }
1681
1485
  s5 = peg$parse_decWs();
1682
1486
  if (input.charCodeAt(peg$currPos) === 41) {
1683
- s6 = peg$c8;
1487
+ s6 = peg$c7;
1684
1488
  peg$currPos++;
1685
1489
  } else {
1686
1490
  s6 = peg$FAILED;
1687
1491
  if (peg$silentFails === 0) {
1688
- peg$fail(peg$e14);
1492
+ peg$fail(peg$e12);
1689
1493
  }
1690
1494
  }
1691
1495
  if (s6 !== peg$FAILED) {
1692
1496
  peg$savedPos = s0;
1693
- s0 = peg$f10(s3);
1497
+ s0 = peg$f9(s3);
1694
1498
  } else {
1695
1499
  peg$currPos = s0;
1696
1500
  s0 = peg$FAILED;
@@ -1701,69 +1505,66 @@ function peg$parse(input, options) {
1701
1505
  }
1702
1506
  return s0;
1703
1507
  }
1704
- chunkCHM43IJO_js.__name(peg$parseDecoratorFunctionArgs, "peg$parseDecoratorFunctionArgs");
1508
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorFunctionArgs, "peg$parseDecoratorFunctionArgs");
1705
1509
  function peg$parseDecoratorFunctionArgValue() {
1706
1510
  let s0, s1, s2, s3;
1707
1511
  s0 = peg$parseDecoratorFunctionCall();
1708
1512
  if (s0 === peg$FAILED) {
1709
- s0 = peg$parseRegexLiteral();
1513
+ s0 = peg$parsequotedString();
1710
1514
  if (s0 === peg$FAILED) {
1711
- s0 = peg$parsequotedString();
1712
- if (s0 === peg$FAILED) {
1713
- s0 = peg$currPos;
1714
- s1 = peg$currPos;
1715
- s2 = [];
1716
- s3 = input.charAt(peg$currPos);
1717
- if (peg$r6.test(s3)) {
1718
- peg$currPos++;
1719
- } else {
1720
- s3 = peg$FAILED;
1721
- if (peg$silentFails === 0) {
1722
- peg$fail(peg$e15);
1723
- }
1515
+ s0 = peg$currPos;
1516
+ s1 = peg$currPos;
1517
+ s2 = [];
1518
+ s3 = input.charAt(peg$currPos);
1519
+ if (peg$r5.test(s3)) {
1520
+ peg$currPos++;
1521
+ } else {
1522
+ s3 = peg$FAILED;
1523
+ if (peg$silentFails === 0) {
1524
+ peg$fail(peg$e13);
1724
1525
  }
1725
- if (s3 !== peg$FAILED) {
1726
- while (s3 !== peg$FAILED) {
1727
- s2.push(s3);
1728
- s3 = input.charAt(peg$currPos);
1729
- if (peg$r6.test(s3)) {
1730
- peg$currPos++;
1731
- } else {
1732
- s3 = peg$FAILED;
1733
- if (peg$silentFails === 0) {
1734
- peg$fail(peg$e15);
1735
- }
1526
+ }
1527
+ if (s3 !== peg$FAILED) {
1528
+ while (s3 !== peg$FAILED) {
1529
+ s2.push(s3);
1530
+ s3 = input.charAt(peg$currPos);
1531
+ if (peg$r5.test(s3)) {
1532
+ peg$currPos++;
1533
+ } else {
1534
+ s3 = peg$FAILED;
1535
+ if (peg$silentFails === 0) {
1536
+ peg$fail(peg$e13);
1736
1537
  }
1737
1538
  }
1738
- } else {
1739
- s2 = peg$FAILED;
1740
- }
1741
- if (s2 !== peg$FAILED) {
1742
- s1 = input.substring(s1, peg$currPos);
1743
- } else {
1744
- s1 = s2;
1745
- }
1746
- if (s1 !== peg$FAILED) {
1747
- peg$savedPos = s0;
1748
- s1 = peg$f11();
1749
1539
  }
1750
- s0 = s1;
1540
+ } else {
1541
+ s2 = peg$FAILED;
1542
+ }
1543
+ if (s2 !== peg$FAILED) {
1544
+ s1 = input.substring(s1, peg$currPos);
1545
+ } else {
1546
+ s1 = s2;
1547
+ }
1548
+ if (s1 !== peg$FAILED) {
1549
+ peg$savedPos = s0;
1550
+ s1 = peg$f10();
1751
1551
  }
1552
+ s0 = s1;
1752
1553
  }
1753
1554
  }
1754
1555
  return s0;
1755
1556
  }
1756
- chunkCHM43IJO_js.__name(peg$parseDecoratorFunctionArgValue, "peg$parseDecoratorFunctionArgValue");
1557
+ chunkX4PJ2KLO_js.__name(peg$parseDecoratorFunctionArgValue, "peg$parseDecoratorFunctionArgValue");
1757
1558
  function peg$parse_decWs() {
1758
1559
  let s0, s1, s2, s3, s4, s5, s6;
1759
1560
  s0 = [];
1760
1561
  s1 = input.charAt(peg$currPos);
1761
- if (peg$r7.test(s1)) {
1562
+ if (peg$r6.test(s1)) {
1762
1563
  peg$currPos++;
1763
1564
  } else {
1764
1565
  s1 = peg$FAILED;
1765
1566
  if (peg$silentFails === 0) {
1766
- peg$fail(peg$e16);
1567
+ peg$fail(peg$e14);
1767
1568
  }
1768
1569
  }
1769
1570
  if (s1 === peg$FAILED) {
@@ -1780,23 +1581,23 @@ function peg$parse(input, options) {
1780
1581
  if (s2 !== peg$FAILED) {
1781
1582
  s3 = [];
1782
1583
  s4 = input.charAt(peg$currPos);
1783
- if (peg$r7.test(s4)) {
1584
+ if (peg$r6.test(s4)) {
1784
1585
  peg$currPos++;
1785
1586
  } else {
1786
1587
  s4 = peg$FAILED;
1787
1588
  if (peg$silentFails === 0) {
1788
- peg$fail(peg$e16);
1589
+ peg$fail(peg$e14);
1789
1590
  }
1790
1591
  }
1791
1592
  while (s4 !== peg$FAILED) {
1792
1593
  s3.push(s4);
1793
1594
  s4 = input.charAt(peg$currPos);
1794
- if (peg$r7.test(s4)) {
1595
+ if (peg$r6.test(s4)) {
1795
1596
  peg$currPos++;
1796
1597
  } else {
1797
1598
  s4 = peg$FAILED;
1798
1599
  if (peg$silentFails === 0) {
1799
- peg$fail(peg$e16);
1600
+ peg$fail(peg$e14);
1800
1601
  }
1801
1602
  }
1802
1603
  }
@@ -1812,23 +1613,23 @@ function peg$parse(input, options) {
1812
1613
  if (s4 !== peg$FAILED) {
1813
1614
  s5 = [];
1814
1615
  s6 = input.charAt(peg$currPos);
1815
- if (peg$r7.test(s6)) {
1616
+ if (peg$r6.test(s6)) {
1816
1617
  peg$currPos++;
1817
1618
  } else {
1818
1619
  s6 = peg$FAILED;
1819
1620
  if (peg$silentFails === 0) {
1820
- peg$fail(peg$e16);
1621
+ peg$fail(peg$e14);
1821
1622
  }
1822
1623
  }
1823
1624
  while (s6 !== peg$FAILED) {
1824
1625
  s5.push(s6);
1825
1626
  s6 = input.charAt(peg$currPos);
1826
- if (peg$r7.test(s6)) {
1627
+ if (peg$r6.test(s6)) {
1827
1628
  peg$currPos++;
1828
1629
  } else {
1829
1630
  s6 = peg$FAILED;
1830
1631
  if (peg$silentFails === 0) {
1831
- peg$fail(peg$e16);
1632
+ peg$fail(peg$e14);
1832
1633
  }
1833
1634
  }
1834
1635
  }
@@ -1846,12 +1647,12 @@ function peg$parse(input, options) {
1846
1647
  while (s1 !== peg$FAILED) {
1847
1648
  s0.push(s1);
1848
1649
  s1 = input.charAt(peg$currPos);
1849
- if (peg$r7.test(s1)) {
1650
+ if (peg$r6.test(s1)) {
1850
1651
  peg$currPos++;
1851
1652
  } else {
1852
1653
  s1 = peg$FAILED;
1853
1654
  if (peg$silentFails === 0) {
1854
- peg$fail(peg$e16);
1655
+ peg$fail(peg$e14);
1855
1656
  }
1856
1657
  }
1857
1658
  if (s1 === peg$FAILED) {
@@ -1868,23 +1669,23 @@ function peg$parse(input, options) {
1868
1669
  if (s2 !== peg$FAILED) {
1869
1670
  s3 = [];
1870
1671
  s4 = input.charAt(peg$currPos);
1871
- if (peg$r7.test(s4)) {
1672
+ if (peg$r6.test(s4)) {
1872
1673
  peg$currPos++;
1873
1674
  } else {
1874
1675
  s4 = peg$FAILED;
1875
1676
  if (peg$silentFails === 0) {
1876
- peg$fail(peg$e16);
1677
+ peg$fail(peg$e14);
1877
1678
  }
1878
1679
  }
1879
1680
  while (s4 !== peg$FAILED) {
1880
1681
  s3.push(s4);
1881
1682
  s4 = input.charAt(peg$currPos);
1882
- if (peg$r7.test(s4)) {
1683
+ if (peg$r6.test(s4)) {
1883
1684
  peg$currPos++;
1884
1685
  } else {
1885
1686
  s4 = peg$FAILED;
1886
1687
  if (peg$silentFails === 0) {
1887
- peg$fail(peg$e16);
1688
+ peg$fail(peg$e14);
1888
1689
  }
1889
1690
  }
1890
1691
  }
@@ -1900,23 +1701,23 @@ function peg$parse(input, options) {
1900
1701
  if (s4 !== peg$FAILED) {
1901
1702
  s5 = [];
1902
1703
  s6 = input.charAt(peg$currPos);
1903
- if (peg$r7.test(s6)) {
1704
+ if (peg$r6.test(s6)) {
1904
1705
  peg$currPos++;
1905
1706
  } else {
1906
1707
  s6 = peg$FAILED;
1907
1708
  if (peg$silentFails === 0) {
1908
- peg$fail(peg$e16);
1709
+ peg$fail(peg$e14);
1909
1710
  }
1910
1711
  }
1911
1712
  while (s6 !== peg$FAILED) {
1912
1713
  s5.push(s6);
1913
1714
  s6 = input.charAt(peg$currPos);
1914
- if (peg$r7.test(s6)) {
1715
+ if (peg$r6.test(s6)) {
1915
1716
  peg$currPos++;
1916
1717
  } else {
1917
1718
  s6 = peg$FAILED;
1918
1719
  if (peg$silentFails === 0) {
1919
- peg$fail(peg$e16);
1720
+ peg$fail(peg$e14);
1920
1721
  }
1921
1722
  }
1922
1723
  }
@@ -1934,7 +1735,7 @@ function peg$parse(input, options) {
1934
1735
  }
1935
1736
  return s0;
1936
1737
  }
1937
- chunkCHM43IJO_js.__name(peg$parse_decWs, "peg$parse_decWs");
1738
+ chunkX4PJ2KLO_js.__name(peg$parse_decWs, "peg$parse_decWs");
1938
1739
  function peg$parseFunctionCall() {
1939
1740
  let s0, s1, s2;
1940
1741
  s0 = peg$currPos;
@@ -1943,7 +1744,7 @@ function peg$parse(input, options) {
1943
1744
  s2 = peg$parseFunctionArgs();
1944
1745
  if (s2 !== peg$FAILED) {
1945
1746
  peg$savedPos = s0;
1946
- s0 = peg$f12(s1, s2);
1747
+ s0 = peg$f11(s1, s2);
1947
1748
  } else {
1948
1749
  peg$currPos = s0;
1949
1750
  s0 = peg$FAILED;
@@ -1954,7 +1755,7 @@ function peg$parse(input, options) {
1954
1755
  }
1955
1756
  return s0;
1956
1757
  }
1957
- chunkCHM43IJO_js.__name(peg$parseFunctionCall, "peg$parseFunctionCall");
1758
+ chunkX4PJ2KLO_js.__name(peg$parseFunctionCall, "peg$parseFunctionCall");
1958
1759
  function peg$parseFunctionName() {
1959
1760
  let s0, s1, s2, s3, s4;
1960
1761
  s0 = peg$currPos;
@@ -1971,23 +1772,23 @@ function peg$parse(input, options) {
1971
1772
  if (s2 !== peg$FAILED) {
1972
1773
  s3 = [];
1973
1774
  s4 = input.charAt(peg$currPos);
1974
- if (peg$r5.test(s4)) {
1775
+ if (peg$r7.test(s4)) {
1975
1776
  peg$currPos++;
1976
1777
  } else {
1977
1778
  s4 = peg$FAILED;
1978
1779
  if (peg$silentFails === 0) {
1979
- peg$fail(peg$e11);
1780
+ peg$fail(peg$e15);
1980
1781
  }
1981
1782
  }
1982
1783
  while (s4 !== peg$FAILED) {
1983
1784
  s3.push(s4);
1984
1785
  s4 = input.charAt(peg$currPos);
1985
- if (peg$r5.test(s4)) {
1786
+ if (peg$r7.test(s4)) {
1986
1787
  peg$currPos++;
1987
1788
  } else {
1988
1789
  s4 = peg$FAILED;
1989
1790
  if (peg$silentFails === 0) {
1990
- peg$fail(peg$e11);
1791
+ peg$fail(peg$e15);
1991
1792
  }
1992
1793
  }
1993
1794
  }
@@ -2004,17 +1805,17 @@ function peg$parse(input, options) {
2004
1805
  }
2005
1806
  return s0;
2006
1807
  }
2007
- chunkCHM43IJO_js.__name(peg$parseFunctionName, "peg$parseFunctionName");
1808
+ chunkX4PJ2KLO_js.__name(peg$parseFunctionName, "peg$parseFunctionName");
2008
1809
  function peg$parseFunctionArgs() {
2009
1810
  let s0, s1, s3, s4, s5, s6, s7, s8, s9;
2010
1811
  s0 = peg$currPos;
2011
1812
  if (input.charCodeAt(peg$currPos) === 40) {
2012
- s1 = peg$c6;
1813
+ s1 = peg$c5;
2013
1814
  peg$currPos++;
2014
1815
  } else {
2015
1816
  s1 = peg$FAILED;
2016
1817
  if (peg$silentFails === 0) {
2017
- peg$fail(peg$e12);
1818
+ peg$fail(peg$e10);
2018
1819
  }
2019
1820
  }
2020
1821
  if (s1 !== peg$FAILED) {
@@ -2037,7 +1838,7 @@ function peg$parse(input, options) {
2037
1838
  s8 = peg$parseFunctionArgValue();
2038
1839
  if (s8 !== peg$FAILED) {
2039
1840
  peg$savedPos = s5;
2040
- s5 = peg$f13(s6, s8);
1841
+ s5 = peg$f12(s6, s8);
2041
1842
  } else {
2042
1843
  peg$currPos = s5;
2043
1844
  s5 = peg$FAILED;
@@ -2059,12 +1860,12 @@ function peg$parse(input, options) {
2059
1860
  s6 = peg$currPos;
2060
1861
  s7 = peg$parse_valWs();
2061
1862
  if (input.charCodeAt(peg$currPos) === 44) {
2062
- s8 = peg$c7;
1863
+ s8 = peg$c6;
2063
1864
  peg$currPos++;
2064
1865
  } else {
2065
1866
  s8 = peg$FAILED;
2066
1867
  if (peg$silentFails === 0) {
2067
- peg$fail(peg$e13);
1868
+ peg$fail(peg$e11);
2068
1869
  }
2069
1870
  }
2070
1871
  if (s8 !== peg$FAILED) {
@@ -2092,7 +1893,7 @@ function peg$parse(input, options) {
2092
1893
  s9 = peg$parseFunctionArgValue();
2093
1894
  if (s9 !== peg$FAILED) {
2094
1895
  peg$savedPos = s6;
2095
- s6 = peg$f13(s7, s9);
1896
+ s6 = peg$f12(s7, s9);
2096
1897
  } else {
2097
1898
  peg$currPos = s6;
2098
1899
  s6 = peg$FAILED;
@@ -2130,12 +1931,12 @@ function peg$parse(input, options) {
2130
1931
  s4 = peg$currPos;
2131
1932
  s5 = peg$parse_valWs();
2132
1933
  if (input.charCodeAt(peg$currPos) === 44) {
2133
- s6 = peg$c7;
1934
+ s6 = peg$c6;
2134
1935
  peg$currPos++;
2135
1936
  } else {
2136
1937
  s6 = peg$FAILED;
2137
1938
  if (peg$silentFails === 0) {
2138
- peg$fail(peg$e13);
1939
+ peg$fail(peg$e11);
2139
1940
  }
2140
1941
  }
2141
1942
  if (s6 !== peg$FAILED) {
@@ -2150,17 +1951,17 @@ function peg$parse(input, options) {
2150
1951
  }
2151
1952
  s5 = peg$parse_valWs();
2152
1953
  if (input.charCodeAt(peg$currPos) === 41) {
2153
- s6 = peg$c8;
1954
+ s6 = peg$c7;
2154
1955
  peg$currPos++;
2155
1956
  } else {
2156
1957
  s6 = peg$FAILED;
2157
1958
  if (peg$silentFails === 0) {
2158
- peg$fail(peg$e14);
1959
+ peg$fail(peg$e12);
2159
1960
  }
2160
1961
  }
2161
1962
  if (s6 !== peg$FAILED) {
2162
1963
  peg$savedPos = s0;
2163
- s0 = peg$f14(s3);
1964
+ s0 = peg$f13(s3);
2164
1965
  } else {
2165
1966
  peg$currPos = s0;
2166
1967
  s0 = peg$FAILED;
@@ -2171,7 +1972,7 @@ function peg$parse(input, options) {
2171
1972
  }
2172
1973
  return s0;
2173
1974
  }
2174
- chunkCHM43IJO_js.__name(peg$parseFunctionArgs, "peg$parseFunctionArgs");
1975
+ chunkX4PJ2KLO_js.__name(peg$parseFunctionArgs, "peg$parseFunctionArgs");
2175
1976
  function peg$parseFunctionArgKeyName() {
2176
1977
  let s0, s1, s2, s3, s4;
2177
1978
  s0 = peg$currPos;
@@ -2188,23 +1989,23 @@ function peg$parse(input, options) {
2188
1989
  if (s2 !== peg$FAILED) {
2189
1990
  s3 = [];
2190
1991
  s4 = input.charAt(peg$currPos);
2191
- if (peg$r5.test(s4)) {
1992
+ if (peg$r7.test(s4)) {
2192
1993
  peg$currPos++;
2193
1994
  } else {
2194
1995
  s4 = peg$FAILED;
2195
1996
  if (peg$silentFails === 0) {
2196
- peg$fail(peg$e11);
1997
+ peg$fail(peg$e15);
2197
1998
  }
2198
1999
  }
2199
2000
  while (s4 !== peg$FAILED) {
2200
2001
  s3.push(s4);
2201
2002
  s4 = input.charAt(peg$currPos);
2202
- if (peg$r5.test(s4)) {
2003
+ if (peg$r7.test(s4)) {
2203
2004
  peg$currPos++;
2204
2005
  } else {
2205
2006
  s4 = peg$FAILED;
2206
2007
  if (peg$silentFails === 0) {
2207
- peg$fail(peg$e11);
2008
+ peg$fail(peg$e15);
2208
2009
  }
2209
2010
  }
2210
2011
  }
@@ -2221,59 +2022,56 @@ function peg$parse(input, options) {
2221
2022
  }
2222
2023
  return s0;
2223
2024
  }
2224
- chunkCHM43IJO_js.__name(peg$parseFunctionArgKeyName, "peg$parseFunctionArgKeyName");
2225
- function peg$parseFunctionArgValue() {
2226
- let s0, s1, s2, s3;
2227
- s0 = peg$parseFunctionCall();
2228
- if (s0 === peg$FAILED) {
2229
- s0 = peg$parseRegexLiteral();
2230
- if (s0 === peg$FAILED) {
2231
- s0 = peg$parsequotedString();
2232
- if (s0 === peg$FAILED) {
2233
- s0 = peg$currPos;
2234
- s1 = peg$currPos;
2235
- s2 = [];
2236
- s3 = input.charAt(peg$currPos);
2237
- if (peg$r6.test(s3)) {
2238
- peg$currPos++;
2239
- } else {
2240
- s3 = peg$FAILED;
2241
- if (peg$silentFails === 0) {
2242
- peg$fail(peg$e15);
2243
- }
2025
+ chunkX4PJ2KLO_js.__name(peg$parseFunctionArgKeyName, "peg$parseFunctionArgKeyName");
2026
+ function peg$parseFunctionArgValue() {
2027
+ let s0, s1, s2, s3;
2028
+ s0 = peg$parseFunctionCall();
2029
+ if (s0 === peg$FAILED) {
2030
+ s0 = peg$parsequotedString();
2031
+ if (s0 === peg$FAILED) {
2032
+ s0 = peg$currPos;
2033
+ s1 = peg$currPos;
2034
+ s2 = [];
2035
+ s3 = input.charAt(peg$currPos);
2036
+ if (peg$r5.test(s3)) {
2037
+ peg$currPos++;
2038
+ } else {
2039
+ s3 = peg$FAILED;
2040
+ if (peg$silentFails === 0) {
2041
+ peg$fail(peg$e13);
2244
2042
  }
2245
- if (s3 !== peg$FAILED) {
2246
- while (s3 !== peg$FAILED) {
2247
- s2.push(s3);
2248
- s3 = input.charAt(peg$currPos);
2249
- if (peg$r6.test(s3)) {
2250
- peg$currPos++;
2251
- } else {
2252
- s3 = peg$FAILED;
2253
- if (peg$silentFails === 0) {
2254
- peg$fail(peg$e15);
2255
- }
2043
+ }
2044
+ if (s3 !== peg$FAILED) {
2045
+ while (s3 !== peg$FAILED) {
2046
+ s2.push(s3);
2047
+ s3 = input.charAt(peg$currPos);
2048
+ if (peg$r5.test(s3)) {
2049
+ peg$currPos++;
2050
+ } else {
2051
+ s3 = peg$FAILED;
2052
+ if (peg$silentFails === 0) {
2053
+ peg$fail(peg$e13);
2256
2054
  }
2257
2055
  }
2258
- } else {
2259
- s2 = peg$FAILED;
2260
- }
2261
- if (s2 !== peg$FAILED) {
2262
- s1 = input.substring(s1, peg$currPos);
2263
- } else {
2264
- s1 = s2;
2265
2056
  }
2266
- if (s1 !== peg$FAILED) {
2267
- peg$savedPos = s0;
2268
- s1 = peg$f15();
2269
- }
2270
- s0 = s1;
2057
+ } else {
2058
+ s2 = peg$FAILED;
2059
+ }
2060
+ if (s2 !== peg$FAILED) {
2061
+ s1 = input.substring(s1, peg$currPos);
2062
+ } else {
2063
+ s1 = s2;
2064
+ }
2065
+ if (s1 !== peg$FAILED) {
2066
+ peg$savedPos = s0;
2067
+ s1 = peg$f14();
2271
2068
  }
2069
+ s0 = s1;
2272
2070
  }
2273
2071
  }
2274
2072
  return s0;
2275
2073
  }
2276
- chunkCHM43IJO_js.__name(peg$parseFunctionArgValue, "peg$parseFunctionArgValue");
2074
+ chunkX4PJ2KLO_js.__name(peg$parseFunctionArgValue, "peg$parseFunctionArgValue");
2277
2075
  function peg$parse_valWs() {
2278
2076
  let s0, s1;
2279
2077
  s0 = [];
@@ -2283,7 +2081,7 @@ function peg$parse(input, options) {
2283
2081
  } else {
2284
2082
  s1 = peg$FAILED;
2285
2083
  if (peg$silentFails === 0) {
2286
- peg$fail(peg$e17);
2084
+ peg$fail(peg$e16);
2287
2085
  }
2288
2086
  }
2289
2087
  while (s1 !== peg$FAILED) {
@@ -2294,13 +2092,13 @@ function peg$parse(input, options) {
2294
2092
  } else {
2295
2093
  s1 = peg$FAILED;
2296
2094
  if (peg$silentFails === 0) {
2297
- peg$fail(peg$e17);
2095
+ peg$fail(peg$e16);
2298
2096
  }
2299
2097
  }
2300
2098
  }
2301
2099
  return s0;
2302
2100
  }
2303
- chunkCHM43IJO_js.__name(peg$parse_valWs, "peg$parse_valWs");
2101
+ chunkX4PJ2KLO_js.__name(peg$parse_valWs, "peg$parse_valWs");
2304
2102
  function peg$parseDivider() {
2305
2103
  let s0, s1, s2, s3, s4, s5, s6, s7;
2306
2104
  s0 = peg$currPos;
@@ -2327,7 +2125,7 @@ function peg$parse(input, options) {
2327
2125
  } else {
2328
2126
  s7 = peg$FAILED;
2329
2127
  if (peg$silentFails === 0) {
2330
- peg$fail(peg$e18);
2128
+ peg$fail(peg$e17);
2331
2129
  }
2332
2130
  }
2333
2131
  while (s7 !== peg$FAILED) {
@@ -2338,7 +2136,7 @@ function peg$parse(input, options) {
2338
2136
  } else {
2339
2137
  s7 = peg$FAILED;
2340
2138
  if (peg$silentFails === 0) {
2341
- peg$fail(peg$e18);
2139
+ peg$fail(peg$e17);
2342
2140
  }
2343
2141
  }
2344
2142
  }
@@ -2386,7 +2184,7 @@ function peg$parse(input, options) {
2386
2184
  s4 = peg$parse_n();
2387
2185
  if (s4 !== peg$FAILED) {
2388
2186
  peg$savedPos = s0;
2389
- s0 = peg$f16(s2, s3);
2187
+ s0 = peg$f15(s2, s3);
2390
2188
  } else {
2391
2189
  peg$currPos = s0;
2392
2190
  s0 = peg$FAILED;
@@ -2401,113 +2199,7 @@ function peg$parse(input, options) {
2401
2199
  }
2402
2200
  return s0;
2403
2201
  }
2404
- chunkCHM43IJO_js.__name(peg$parseDivider, "peg$parseDivider");
2405
- function peg$parseRegexLiteral() {
2406
- let s0, s1, s2, s3, s4, s5, s6;
2407
- s0 = peg$currPos;
2408
- if (input.charCodeAt(peg$currPos) === 47) {
2409
- s1 = peg$c9;
2410
- peg$currPos++;
2411
- } else {
2412
- s1 = peg$FAILED;
2413
- if (peg$silentFails === 0) {
2414
- peg$fail(peg$e19);
2415
- }
2416
- }
2417
- if (s1 !== peg$FAILED) {
2418
- s2 = peg$currPos;
2419
- s3 = [];
2420
- if (input.substr(peg$currPos, 2) === peg$c10) {
2421
- s4 = peg$c10;
2422
- peg$currPos += 2;
2423
- } else {
2424
- s4 = peg$FAILED;
2425
- if (peg$silentFails === 0) {
2426
- peg$fail(peg$e20);
2427
- }
2428
- }
2429
- if (s4 === peg$FAILED) {
2430
- s4 = input.charAt(peg$currPos);
2431
- if (peg$r10.test(s4)) {
2432
- peg$currPos++;
2433
- } else {
2434
- s4 = peg$FAILED;
2435
- if (peg$silentFails === 0) {
2436
- peg$fail(peg$e21);
2437
- }
2438
- }
2439
- }
2440
- while (s4 !== peg$FAILED) {
2441
- s3.push(s4);
2442
- if (input.substr(peg$currPos, 2) === peg$c10) {
2443
- s4 = peg$c10;
2444
- peg$currPos += 2;
2445
- } else {
2446
- s4 = peg$FAILED;
2447
- if (peg$silentFails === 0) {
2448
- peg$fail(peg$e20);
2449
- }
2450
- }
2451
- if (s4 === peg$FAILED) {
2452
- s4 = input.charAt(peg$currPos);
2453
- if (peg$r10.test(s4)) {
2454
- peg$currPos++;
2455
- } else {
2456
- s4 = peg$FAILED;
2457
- if (peg$silentFails === 0) {
2458
- peg$fail(peg$e21);
2459
- }
2460
- }
2461
- }
2462
- }
2463
- s2 = input.substring(s2, peg$currPos);
2464
- if (input.charCodeAt(peg$currPos) === 47) {
2465
- s3 = peg$c9;
2466
- peg$currPos++;
2467
- } else {
2468
- s3 = peg$FAILED;
2469
- if (peg$silentFails === 0) {
2470
- peg$fail(peg$e19);
2471
- }
2472
- }
2473
- if (s3 !== peg$FAILED) {
2474
- s4 = peg$currPos;
2475
- s5 = [];
2476
- s6 = input.charAt(peg$currPos);
2477
- if (peg$r11.test(s6)) {
2478
- peg$currPos++;
2479
- } else {
2480
- s6 = peg$FAILED;
2481
- if (peg$silentFails === 0) {
2482
- peg$fail(peg$e22);
2483
- }
2484
- }
2485
- while (s6 !== peg$FAILED) {
2486
- s5.push(s6);
2487
- s6 = input.charAt(peg$currPos);
2488
- if (peg$r11.test(s6)) {
2489
- peg$currPos++;
2490
- } else {
2491
- s6 = peg$FAILED;
2492
- if (peg$silentFails === 0) {
2493
- peg$fail(peg$e22);
2494
- }
2495
- }
2496
- }
2497
- s4 = input.substring(s4, peg$currPos);
2498
- peg$savedPos = s0;
2499
- s0 = peg$f17(s2, s4);
2500
- } else {
2501
- peg$currPos = s0;
2502
- s0 = peg$FAILED;
2503
- }
2504
- } else {
2505
- peg$currPos = s0;
2506
- s0 = peg$FAILED;
2507
- }
2508
- return s0;
2509
- }
2510
- chunkCHM43IJO_js.__name(peg$parseRegexLiteral, "peg$parseRegexLiteral");
2202
+ chunkX4PJ2KLO_js.__name(peg$parseDivider, "peg$parseDivider");
2511
2203
  function peg$parseunquotedString() {
2512
2204
  let s0, s1, s2, s3, s4, s5, s6;
2513
2205
  s0 = peg$currPos;
@@ -2517,12 +2209,12 @@ function peg$parse(input, options) {
2517
2209
  s4 = peg$currPos;
2518
2210
  peg$silentFails++;
2519
2211
  s5 = input.charAt(peg$currPos);
2520
- if (peg$r12.test(s5)) {
2212
+ if (peg$r10.test(s5)) {
2521
2213
  peg$currPos++;
2522
2214
  } else {
2523
2215
  s5 = peg$FAILED;
2524
2216
  if (peg$silentFails === 0) {
2525
- peg$fail(peg$e23);
2217
+ peg$fail(peg$e18);
2526
2218
  }
2527
2219
  }
2528
2220
  peg$silentFails--;
@@ -2535,24 +2227,24 @@ function peg$parse(input, options) {
2535
2227
  if (s4 !== peg$FAILED) {
2536
2228
  s5 = [];
2537
2229
  s6 = input.charAt(peg$currPos);
2538
- if (peg$r13.test(s6)) {
2230
+ if (peg$r11.test(s6)) {
2539
2231
  peg$currPos++;
2540
2232
  } else {
2541
2233
  s6 = peg$FAILED;
2542
2234
  if (peg$silentFails === 0) {
2543
- peg$fail(peg$e24);
2235
+ peg$fail(peg$e19);
2544
2236
  }
2545
2237
  }
2546
2238
  if (s6 !== peg$FAILED) {
2547
2239
  while (s6 !== peg$FAILED) {
2548
2240
  s5.push(s6);
2549
2241
  s6 = input.charAt(peg$currPos);
2550
- if (peg$r13.test(s6)) {
2242
+ if (peg$r11.test(s6)) {
2551
2243
  peg$currPos++;
2552
2244
  } else {
2553
2245
  s6 = peg$FAILED;
2554
2246
  if (peg$silentFails === 0) {
2555
- peg$fail(peg$e24);
2247
+ peg$fail(peg$e19);
2556
2248
  }
2557
2249
  }
2558
2250
  }
@@ -2577,12 +2269,12 @@ function peg$parse(input, options) {
2577
2269
  }
2578
2270
  if (s1 !== peg$FAILED) {
2579
2271
  peg$savedPos = s0;
2580
- s1 = peg$f18();
2272
+ s1 = peg$f16();
2581
2273
  }
2582
2274
  s0 = s1;
2583
2275
  return s0;
2584
2276
  }
2585
- chunkCHM43IJO_js.__name(peg$parseunquotedString, "peg$parseunquotedString");
2277
+ chunkX4PJ2KLO_js.__name(peg$parseunquotedString, "peg$parseunquotedString");
2586
2278
  function peg$parseunquotedStringWithoutSpaces() {
2587
2279
  let s0, s1, s2, s3, s4, s5;
2588
2280
  s0 = peg$currPos;
@@ -2591,12 +2283,12 @@ function peg$parse(input, options) {
2591
2283
  s3 = peg$currPos;
2592
2284
  peg$silentFails++;
2593
2285
  s4 = input.charAt(peg$currPos);
2594
- if (peg$r12.test(s4)) {
2286
+ if (peg$r10.test(s4)) {
2595
2287
  peg$currPos++;
2596
2288
  } else {
2597
2289
  s4 = peg$FAILED;
2598
2290
  if (peg$silentFails === 0) {
2599
- peg$fail(peg$e23);
2291
+ peg$fail(peg$e18);
2600
2292
  }
2601
2293
  }
2602
2294
  peg$silentFails--;
@@ -2609,24 +2301,24 @@ function peg$parse(input, options) {
2609
2301
  if (s3 !== peg$FAILED) {
2610
2302
  s4 = [];
2611
2303
  s5 = input.charAt(peg$currPos);
2612
- if (peg$r14.test(s5)) {
2304
+ if (peg$r12.test(s5)) {
2613
2305
  peg$currPos++;
2614
2306
  } else {
2615
2307
  s5 = peg$FAILED;
2616
2308
  if (peg$silentFails === 0) {
2617
- peg$fail(peg$e25);
2309
+ peg$fail(peg$e20);
2618
2310
  }
2619
2311
  }
2620
2312
  if (s5 !== peg$FAILED) {
2621
2313
  while (s5 !== peg$FAILED) {
2622
2314
  s4.push(s5);
2623
2315
  s5 = input.charAt(peg$currPos);
2624
- if (peg$r14.test(s5)) {
2316
+ if (peg$r12.test(s5)) {
2625
2317
  peg$currPos++;
2626
2318
  } else {
2627
2319
  s5 = peg$FAILED;
2628
2320
  if (peg$silentFails === 0) {
2629
- peg$fail(peg$e25);
2321
+ peg$fail(peg$e20);
2630
2322
  }
2631
2323
  }
2632
2324
  }
@@ -2651,12 +2343,12 @@ function peg$parse(input, options) {
2651
2343
  }
2652
2344
  if (s1 !== peg$FAILED) {
2653
2345
  peg$savedPos = s0;
2654
- s1 = peg$f19();
2346
+ s1 = peg$f17();
2655
2347
  }
2656
2348
  s0 = s1;
2657
2349
  return s0;
2658
2350
  }
2659
- chunkCHM43IJO_js.__name(peg$parseunquotedStringWithoutSpaces, "peg$parseunquotedStringWithoutSpaces");
2351
+ chunkX4PJ2KLO_js.__name(peg$parseunquotedStringWithoutSpaces, "peg$parseunquotedStringWithoutSpaces");
2660
2352
  function peg$parsequotedString() {
2661
2353
  let s0;
2662
2354
  s0 = peg$parseDQuotedString();
@@ -2668,76 +2360,76 @@ function peg$parse(input, options) {
2668
2360
  }
2669
2361
  return s0;
2670
2362
  }
2671
- chunkCHM43IJO_js.__name(peg$parsequotedString, "peg$parsequotedString");
2363
+ chunkX4PJ2KLO_js.__name(peg$parsequotedString, "peg$parsequotedString");
2672
2364
  function peg$parseDQuotedString() {
2673
2365
  let s0, s1, s2, s3;
2674
2366
  s0 = peg$currPos;
2675
2367
  s1 = input.charAt(peg$currPos);
2676
- if (peg$r15.test(s1)) {
2368
+ if (peg$r13.test(s1)) {
2677
2369
  peg$currPos++;
2678
2370
  } else {
2679
2371
  s1 = peg$FAILED;
2680
2372
  if (peg$silentFails === 0) {
2681
- peg$fail(peg$e26);
2373
+ peg$fail(peg$e21);
2682
2374
  }
2683
2375
  }
2684
2376
  if (s1 !== peg$FAILED) {
2685
2377
  s2 = [];
2686
- if (input.substr(peg$currPos, 2) === peg$c11) {
2687
- s3 = peg$c11;
2378
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2379
+ s3 = peg$c8;
2688
2380
  peg$currPos += 2;
2689
2381
  } else {
2690
2382
  s3 = peg$FAILED;
2691
2383
  if (peg$silentFails === 0) {
2692
- peg$fail(peg$e27);
2384
+ peg$fail(peg$e22);
2693
2385
  }
2694
2386
  }
2695
2387
  if (s3 === peg$FAILED) {
2696
2388
  s3 = input.charAt(peg$currPos);
2697
- if (peg$r16.test(s3)) {
2389
+ if (peg$r14.test(s3)) {
2698
2390
  peg$currPos++;
2699
2391
  } else {
2700
2392
  s3 = peg$FAILED;
2701
2393
  if (peg$silentFails === 0) {
2702
- peg$fail(peg$e28);
2394
+ peg$fail(peg$e23);
2703
2395
  }
2704
2396
  }
2705
2397
  }
2706
2398
  while (s3 !== peg$FAILED) {
2707
2399
  s2.push(s3);
2708
- if (input.substr(peg$currPos, 2) === peg$c11) {
2709
- s3 = peg$c11;
2400
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2401
+ s3 = peg$c8;
2710
2402
  peg$currPos += 2;
2711
2403
  } else {
2712
2404
  s3 = peg$FAILED;
2713
2405
  if (peg$silentFails === 0) {
2714
- peg$fail(peg$e27);
2406
+ peg$fail(peg$e22);
2715
2407
  }
2716
2408
  }
2717
2409
  if (s3 === peg$FAILED) {
2718
2410
  s3 = input.charAt(peg$currPos);
2719
- if (peg$r16.test(s3)) {
2411
+ if (peg$r14.test(s3)) {
2720
2412
  peg$currPos++;
2721
2413
  } else {
2722
2414
  s3 = peg$FAILED;
2723
2415
  if (peg$silentFails === 0) {
2724
- peg$fail(peg$e28);
2416
+ peg$fail(peg$e23);
2725
2417
  }
2726
2418
  }
2727
2419
  }
2728
2420
  }
2729
2421
  s3 = input.charAt(peg$currPos);
2730
- if (peg$r15.test(s3)) {
2422
+ if (peg$r13.test(s3)) {
2731
2423
  peg$currPos++;
2732
2424
  } else {
2733
2425
  s3 = peg$FAILED;
2734
2426
  if (peg$silentFails === 0) {
2735
- peg$fail(peg$e26);
2427
+ peg$fail(peg$e21);
2736
2428
  }
2737
2429
  }
2738
2430
  if (s3 !== peg$FAILED) {
2739
2431
  peg$savedPos = s0;
2740
- s0 = peg$f20(s1);
2432
+ s0 = peg$f18(s1);
2741
2433
  } else {
2742
2434
  peg$currPos = s0;
2743
2435
  s0 = peg$FAILED;
@@ -2748,76 +2440,76 @@ function peg$parse(input, options) {
2748
2440
  }
2749
2441
  return s0;
2750
2442
  }
2751
- chunkCHM43IJO_js.__name(peg$parseDQuotedString, "peg$parseDQuotedString");
2443
+ chunkX4PJ2KLO_js.__name(peg$parseDQuotedString, "peg$parseDQuotedString");
2752
2444
  function peg$parseSQuotedString() {
2753
2445
  let s0, s1, s2, s3;
2754
2446
  s0 = peg$currPos;
2755
2447
  s1 = input.charAt(peg$currPos);
2756
- if (peg$r17.test(s1)) {
2448
+ if (peg$r15.test(s1)) {
2757
2449
  peg$currPos++;
2758
2450
  } else {
2759
2451
  s1 = peg$FAILED;
2760
2452
  if (peg$silentFails === 0) {
2761
- peg$fail(peg$e29);
2453
+ peg$fail(peg$e24);
2762
2454
  }
2763
2455
  }
2764
2456
  if (s1 !== peg$FAILED) {
2765
2457
  s2 = [];
2766
- if (input.substr(peg$currPos, 2) === peg$c12) {
2767
- s3 = peg$c12;
2458
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2459
+ s3 = peg$c9;
2768
2460
  peg$currPos += 2;
2769
2461
  } else {
2770
2462
  s3 = peg$FAILED;
2771
2463
  if (peg$silentFails === 0) {
2772
- peg$fail(peg$e30);
2464
+ peg$fail(peg$e25);
2773
2465
  }
2774
2466
  }
2775
2467
  if (s3 === peg$FAILED) {
2776
2468
  s3 = input.charAt(peg$currPos);
2777
- if (peg$r18.test(s3)) {
2469
+ if (peg$r16.test(s3)) {
2778
2470
  peg$currPos++;
2779
2471
  } else {
2780
2472
  s3 = peg$FAILED;
2781
2473
  if (peg$silentFails === 0) {
2782
- peg$fail(peg$e31);
2474
+ peg$fail(peg$e26);
2783
2475
  }
2784
2476
  }
2785
2477
  }
2786
2478
  while (s3 !== peg$FAILED) {
2787
2479
  s2.push(s3);
2788
- if (input.substr(peg$currPos, 2) === peg$c12) {
2789
- s3 = peg$c12;
2480
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2481
+ s3 = peg$c9;
2790
2482
  peg$currPos += 2;
2791
2483
  } else {
2792
2484
  s3 = peg$FAILED;
2793
2485
  if (peg$silentFails === 0) {
2794
- peg$fail(peg$e30);
2486
+ peg$fail(peg$e25);
2795
2487
  }
2796
2488
  }
2797
2489
  if (s3 === peg$FAILED) {
2798
2490
  s3 = input.charAt(peg$currPos);
2799
- if (peg$r18.test(s3)) {
2491
+ if (peg$r16.test(s3)) {
2800
2492
  peg$currPos++;
2801
2493
  } else {
2802
2494
  s3 = peg$FAILED;
2803
2495
  if (peg$silentFails === 0) {
2804
- peg$fail(peg$e31);
2496
+ peg$fail(peg$e26);
2805
2497
  }
2806
2498
  }
2807
2499
  }
2808
2500
  }
2809
2501
  s3 = input.charAt(peg$currPos);
2810
- if (peg$r17.test(s3)) {
2502
+ if (peg$r15.test(s3)) {
2811
2503
  peg$currPos++;
2812
2504
  } else {
2813
2505
  s3 = peg$FAILED;
2814
2506
  if (peg$silentFails === 0) {
2815
- peg$fail(peg$e29);
2507
+ peg$fail(peg$e24);
2816
2508
  }
2817
2509
  }
2818
2510
  if (s3 !== peg$FAILED) {
2819
2511
  peg$savedPos = s0;
2820
- s0 = peg$f21(s1);
2512
+ s0 = peg$f19(s1);
2821
2513
  } else {
2822
2514
  peg$currPos = s0;
2823
2515
  s0 = peg$FAILED;
@@ -2828,76 +2520,76 @@ function peg$parse(input, options) {
2828
2520
  }
2829
2521
  return s0;
2830
2522
  }
2831
- chunkCHM43IJO_js.__name(peg$parseSQuotedString, "peg$parseSQuotedString");
2523
+ chunkX4PJ2KLO_js.__name(peg$parseSQuotedString, "peg$parseSQuotedString");
2832
2524
  function peg$parseBQuotedString() {
2833
2525
  let s0, s1, s2, s3;
2834
2526
  s0 = peg$currPos;
2835
2527
  s1 = input.charAt(peg$currPos);
2836
- if (peg$r19.test(s1)) {
2528
+ if (peg$r17.test(s1)) {
2837
2529
  peg$currPos++;
2838
2530
  } else {
2839
2531
  s1 = peg$FAILED;
2840
2532
  if (peg$silentFails === 0) {
2841
- peg$fail(peg$e32);
2533
+ peg$fail(peg$e27);
2842
2534
  }
2843
2535
  }
2844
2536
  if (s1 !== peg$FAILED) {
2845
2537
  s2 = [];
2846
- if (input.substr(peg$currPos, 2) === peg$c13) {
2847
- s3 = peg$c13;
2538
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2539
+ s3 = peg$c10;
2848
2540
  peg$currPos += 2;
2849
2541
  } else {
2850
2542
  s3 = peg$FAILED;
2851
2543
  if (peg$silentFails === 0) {
2852
- peg$fail(peg$e33);
2544
+ peg$fail(peg$e28);
2853
2545
  }
2854
2546
  }
2855
2547
  if (s3 === peg$FAILED) {
2856
2548
  s3 = input.charAt(peg$currPos);
2857
- if (peg$r20.test(s3)) {
2549
+ if (peg$r18.test(s3)) {
2858
2550
  peg$currPos++;
2859
2551
  } else {
2860
2552
  s3 = peg$FAILED;
2861
2553
  if (peg$silentFails === 0) {
2862
- peg$fail(peg$e34);
2554
+ peg$fail(peg$e29);
2863
2555
  }
2864
2556
  }
2865
2557
  }
2866
2558
  while (s3 !== peg$FAILED) {
2867
2559
  s2.push(s3);
2868
- if (input.substr(peg$currPos, 2) === peg$c13) {
2869
- s3 = peg$c13;
2560
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2561
+ s3 = peg$c10;
2870
2562
  peg$currPos += 2;
2871
2563
  } else {
2872
2564
  s3 = peg$FAILED;
2873
2565
  if (peg$silentFails === 0) {
2874
- peg$fail(peg$e33);
2566
+ peg$fail(peg$e28);
2875
2567
  }
2876
2568
  }
2877
2569
  if (s3 === peg$FAILED) {
2878
2570
  s3 = input.charAt(peg$currPos);
2879
- if (peg$r20.test(s3)) {
2571
+ if (peg$r18.test(s3)) {
2880
2572
  peg$currPos++;
2881
2573
  } else {
2882
2574
  s3 = peg$FAILED;
2883
2575
  if (peg$silentFails === 0) {
2884
- peg$fail(peg$e34);
2576
+ peg$fail(peg$e29);
2885
2577
  }
2886
2578
  }
2887
2579
  }
2888
2580
  }
2889
2581
  s3 = input.charAt(peg$currPos);
2890
- if (peg$r19.test(s3)) {
2582
+ if (peg$r17.test(s3)) {
2891
2583
  peg$currPos++;
2892
2584
  } else {
2893
2585
  s3 = peg$FAILED;
2894
2586
  if (peg$silentFails === 0) {
2895
- peg$fail(peg$e32);
2587
+ peg$fail(peg$e27);
2896
2588
  }
2897
2589
  }
2898
2590
  if (s3 !== peg$FAILED) {
2899
2591
  peg$savedPos = s0;
2900
- s0 = peg$f22(s1);
2592
+ s0 = peg$f20(s1);
2901
2593
  } else {
2902
2594
  peg$currPos = s0;
2903
2595
  s0 = peg$FAILED;
@@ -2908,7 +2600,7 @@ function peg$parse(input, options) {
2908
2600
  }
2909
2601
  return s0;
2910
2602
  }
2911
- chunkCHM43IJO_js.__name(peg$parseBQuotedString, "peg$parseBQuotedString");
2603
+ chunkX4PJ2KLO_js.__name(peg$parseBQuotedString, "peg$parseBQuotedString");
2912
2604
  function peg$parsemultiLineString() {
2913
2605
  let s0;
2914
2606
  s0 = peg$parsesingleSQuotedMultiLineString();
@@ -2923,62 +2615,62 @@ function peg$parse(input, options) {
2923
2615
  }
2924
2616
  return s0;
2925
2617
  }
2926
- chunkCHM43IJO_js.__name(peg$parsemultiLineString, "peg$parsemultiLineString");
2618
+ chunkX4PJ2KLO_js.__name(peg$parsemultiLineString, "peg$parsemultiLineString");
2927
2619
  function peg$parsesingleSQuotedMultiLineString() {
2928
2620
  let s0, s1, s2, s3, s4, s5;
2929
2621
  s0 = peg$currPos;
2930
2622
  s1 = input.charAt(peg$currPos);
2931
- if (peg$r17.test(s1)) {
2623
+ if (peg$r15.test(s1)) {
2932
2624
  peg$currPos++;
2933
2625
  } else {
2934
2626
  s1 = peg$FAILED;
2935
2627
  if (peg$silentFails === 0) {
2936
- peg$fail(peg$e29);
2628
+ peg$fail(peg$e24);
2937
2629
  }
2938
2630
  }
2939
2631
  if (s1 !== peg$FAILED) {
2940
2632
  s2 = [];
2941
2633
  s3 = peg$currPos;
2942
2634
  s4 = [];
2943
- if (input.substr(peg$currPos, 2) === peg$c12) {
2944
- s5 = peg$c12;
2635
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2636
+ s5 = peg$c9;
2945
2637
  peg$currPos += 2;
2946
2638
  } else {
2947
2639
  s5 = peg$FAILED;
2948
2640
  if (peg$silentFails === 0) {
2949
- peg$fail(peg$e30);
2641
+ peg$fail(peg$e25);
2950
2642
  }
2951
2643
  }
2952
2644
  if (s5 === peg$FAILED) {
2953
2645
  s5 = input.charAt(peg$currPos);
2954
- if (peg$r18.test(s5)) {
2646
+ if (peg$r16.test(s5)) {
2955
2647
  peg$currPos++;
2956
2648
  } else {
2957
2649
  s5 = peg$FAILED;
2958
2650
  if (peg$silentFails === 0) {
2959
- peg$fail(peg$e31);
2651
+ peg$fail(peg$e26);
2960
2652
  }
2961
2653
  }
2962
2654
  }
2963
2655
  while (s5 !== peg$FAILED) {
2964
2656
  s4.push(s5);
2965
- if (input.substr(peg$currPos, 2) === peg$c12) {
2966
- s5 = peg$c12;
2657
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2658
+ s5 = peg$c9;
2967
2659
  peg$currPos += 2;
2968
2660
  } else {
2969
2661
  s5 = peg$FAILED;
2970
2662
  if (peg$silentFails === 0) {
2971
- peg$fail(peg$e30);
2663
+ peg$fail(peg$e25);
2972
2664
  }
2973
2665
  }
2974
2666
  if (s5 === peg$FAILED) {
2975
2667
  s5 = input.charAt(peg$currPos);
2976
- if (peg$r18.test(s5)) {
2668
+ if (peg$r16.test(s5)) {
2977
2669
  peg$currPos++;
2978
2670
  } else {
2979
2671
  s5 = peg$FAILED;
2980
2672
  if (peg$silentFails === 0) {
2981
- peg$fail(peg$e31);
2673
+ peg$fail(peg$e26);
2982
2674
  }
2983
2675
  }
2984
2676
  }
@@ -3004,45 +2696,45 @@ function peg$parse(input, options) {
3004
2696
  s2.push(s3);
3005
2697
  s3 = peg$currPos;
3006
2698
  s4 = [];
3007
- if (input.substr(peg$currPos, 2) === peg$c12) {
3008
- s5 = peg$c12;
2699
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2700
+ s5 = peg$c9;
3009
2701
  peg$currPos += 2;
3010
2702
  } else {
3011
2703
  s5 = peg$FAILED;
3012
2704
  if (peg$silentFails === 0) {
3013
- peg$fail(peg$e30);
2705
+ peg$fail(peg$e25);
3014
2706
  }
3015
2707
  }
3016
2708
  if (s5 === peg$FAILED) {
3017
2709
  s5 = input.charAt(peg$currPos);
3018
- if (peg$r18.test(s5)) {
2710
+ if (peg$r16.test(s5)) {
3019
2711
  peg$currPos++;
3020
2712
  } else {
3021
2713
  s5 = peg$FAILED;
3022
2714
  if (peg$silentFails === 0) {
3023
- peg$fail(peg$e31);
2715
+ peg$fail(peg$e26);
3024
2716
  }
3025
2717
  }
3026
2718
  }
3027
2719
  while (s5 !== peg$FAILED) {
3028
2720
  s4.push(s5);
3029
- if (input.substr(peg$currPos, 2) === peg$c12) {
3030
- s5 = peg$c12;
2721
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2722
+ s5 = peg$c9;
3031
2723
  peg$currPos += 2;
3032
2724
  } else {
3033
2725
  s5 = peg$FAILED;
3034
2726
  if (peg$silentFails === 0) {
3035
- peg$fail(peg$e30);
2727
+ peg$fail(peg$e25);
3036
2728
  }
3037
2729
  }
3038
2730
  if (s5 === peg$FAILED) {
3039
2731
  s5 = input.charAt(peg$currPos);
3040
- if (peg$r18.test(s5)) {
2732
+ if (peg$r16.test(s5)) {
3041
2733
  peg$currPos++;
3042
2734
  } else {
3043
2735
  s5 = peg$FAILED;
3044
2736
  if (peg$silentFails === 0) {
3045
- peg$fail(peg$e31);
2737
+ peg$fail(peg$e26);
3046
2738
  }
3047
2739
  }
3048
2740
  }
@@ -3069,61 +2761,61 @@ function peg$parse(input, options) {
3069
2761
  }
3070
2762
  if (s2 !== peg$FAILED) {
3071
2763
  s3 = [];
3072
- if (input.substr(peg$currPos, 2) === peg$c12) {
3073
- s4 = peg$c12;
2764
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2765
+ s4 = peg$c9;
3074
2766
  peg$currPos += 2;
3075
2767
  } else {
3076
2768
  s4 = peg$FAILED;
3077
2769
  if (peg$silentFails === 0) {
3078
- peg$fail(peg$e30);
2770
+ peg$fail(peg$e25);
3079
2771
  }
3080
2772
  }
3081
2773
  if (s4 === peg$FAILED) {
3082
2774
  s4 = input.charAt(peg$currPos);
3083
- if (peg$r18.test(s4)) {
2775
+ if (peg$r16.test(s4)) {
3084
2776
  peg$currPos++;
3085
2777
  } else {
3086
2778
  s4 = peg$FAILED;
3087
2779
  if (peg$silentFails === 0) {
3088
- peg$fail(peg$e31);
2780
+ peg$fail(peg$e26);
3089
2781
  }
3090
2782
  }
3091
2783
  }
3092
2784
  while (s4 !== peg$FAILED) {
3093
2785
  s3.push(s4);
3094
- if (input.substr(peg$currPos, 2) === peg$c12) {
3095
- s4 = peg$c12;
2786
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2787
+ s4 = peg$c9;
3096
2788
  peg$currPos += 2;
3097
2789
  } else {
3098
2790
  s4 = peg$FAILED;
3099
2791
  if (peg$silentFails === 0) {
3100
- peg$fail(peg$e30);
2792
+ peg$fail(peg$e25);
3101
2793
  }
3102
2794
  }
3103
2795
  if (s4 === peg$FAILED) {
3104
2796
  s4 = input.charAt(peg$currPos);
3105
- if (peg$r18.test(s4)) {
2797
+ if (peg$r16.test(s4)) {
3106
2798
  peg$currPos++;
3107
2799
  } else {
3108
2800
  s4 = peg$FAILED;
3109
2801
  if (peg$silentFails === 0) {
3110
- peg$fail(peg$e31);
2802
+ peg$fail(peg$e26);
3111
2803
  }
3112
2804
  }
3113
2805
  }
3114
2806
  }
3115
2807
  s4 = input.charAt(peg$currPos);
3116
- if (peg$r17.test(s4)) {
2808
+ if (peg$r15.test(s4)) {
3117
2809
  peg$currPos++;
3118
2810
  } else {
3119
2811
  s4 = peg$FAILED;
3120
2812
  if (peg$silentFails === 0) {
3121
- peg$fail(peg$e29);
2813
+ peg$fail(peg$e24);
3122
2814
  }
3123
2815
  }
3124
2816
  if (s4 !== peg$FAILED) {
3125
2817
  peg$savedPos = s0;
3126
- s0 = peg$f23(s1);
2818
+ s0 = peg$f21(s1);
3127
2819
  } else {
3128
2820
  peg$currPos = s0;
3129
2821
  s0 = peg$FAILED;
@@ -3138,62 +2830,62 @@ function peg$parse(input, options) {
3138
2830
  }
3139
2831
  return s0;
3140
2832
  }
3141
- chunkCHM43IJO_js.__name(peg$parsesingleSQuotedMultiLineString, "peg$parsesingleSQuotedMultiLineString");
2833
+ chunkX4PJ2KLO_js.__name(peg$parsesingleSQuotedMultiLineString, "peg$parsesingleSQuotedMultiLineString");
3142
2834
  function peg$parsesingleDQuotedMultiLineString() {
3143
2835
  let s0, s1, s2, s3, s4, s5;
3144
2836
  s0 = peg$currPos;
3145
2837
  s1 = input.charAt(peg$currPos);
3146
- if (peg$r15.test(s1)) {
2838
+ if (peg$r13.test(s1)) {
3147
2839
  peg$currPos++;
3148
2840
  } else {
3149
2841
  s1 = peg$FAILED;
3150
2842
  if (peg$silentFails === 0) {
3151
- peg$fail(peg$e26);
2843
+ peg$fail(peg$e21);
3152
2844
  }
3153
2845
  }
3154
2846
  if (s1 !== peg$FAILED) {
3155
2847
  s2 = [];
3156
2848
  s3 = peg$currPos;
3157
2849
  s4 = [];
3158
- if (input.substr(peg$currPos, 2) === peg$c11) {
3159
- s5 = peg$c11;
2850
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2851
+ s5 = peg$c8;
3160
2852
  peg$currPos += 2;
3161
2853
  } else {
3162
2854
  s5 = peg$FAILED;
3163
2855
  if (peg$silentFails === 0) {
3164
- peg$fail(peg$e27);
2856
+ peg$fail(peg$e22);
3165
2857
  }
3166
2858
  }
3167
2859
  if (s5 === peg$FAILED) {
3168
2860
  s5 = input.charAt(peg$currPos);
3169
- if (peg$r16.test(s5)) {
2861
+ if (peg$r14.test(s5)) {
3170
2862
  peg$currPos++;
3171
2863
  } else {
3172
2864
  s5 = peg$FAILED;
3173
2865
  if (peg$silentFails === 0) {
3174
- peg$fail(peg$e28);
2866
+ peg$fail(peg$e23);
3175
2867
  }
3176
2868
  }
3177
2869
  }
3178
2870
  while (s5 !== peg$FAILED) {
3179
2871
  s4.push(s5);
3180
- if (input.substr(peg$currPos, 2) === peg$c11) {
3181
- s5 = peg$c11;
2872
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2873
+ s5 = peg$c8;
3182
2874
  peg$currPos += 2;
3183
2875
  } else {
3184
2876
  s5 = peg$FAILED;
3185
2877
  if (peg$silentFails === 0) {
3186
- peg$fail(peg$e27);
2878
+ peg$fail(peg$e22);
3187
2879
  }
3188
2880
  }
3189
2881
  if (s5 === peg$FAILED) {
3190
2882
  s5 = input.charAt(peg$currPos);
3191
- if (peg$r16.test(s5)) {
2883
+ if (peg$r14.test(s5)) {
3192
2884
  peg$currPos++;
3193
2885
  } else {
3194
2886
  s5 = peg$FAILED;
3195
2887
  if (peg$silentFails === 0) {
3196
- peg$fail(peg$e28);
2888
+ peg$fail(peg$e23);
3197
2889
  }
3198
2890
  }
3199
2891
  }
@@ -3219,45 +2911,45 @@ function peg$parse(input, options) {
3219
2911
  s2.push(s3);
3220
2912
  s3 = peg$currPos;
3221
2913
  s4 = [];
3222
- if (input.substr(peg$currPos, 2) === peg$c11) {
3223
- s5 = peg$c11;
2914
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2915
+ s5 = peg$c8;
3224
2916
  peg$currPos += 2;
3225
2917
  } else {
3226
2918
  s5 = peg$FAILED;
3227
2919
  if (peg$silentFails === 0) {
3228
- peg$fail(peg$e27);
2920
+ peg$fail(peg$e22);
3229
2921
  }
3230
2922
  }
3231
2923
  if (s5 === peg$FAILED) {
3232
2924
  s5 = input.charAt(peg$currPos);
3233
- if (peg$r16.test(s5)) {
2925
+ if (peg$r14.test(s5)) {
3234
2926
  peg$currPos++;
3235
2927
  } else {
3236
2928
  s5 = peg$FAILED;
3237
2929
  if (peg$silentFails === 0) {
3238
- peg$fail(peg$e28);
2930
+ peg$fail(peg$e23);
3239
2931
  }
3240
2932
  }
3241
2933
  }
3242
2934
  while (s5 !== peg$FAILED) {
3243
2935
  s4.push(s5);
3244
- if (input.substr(peg$currPos, 2) === peg$c11) {
3245
- s5 = peg$c11;
2936
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2937
+ s5 = peg$c8;
3246
2938
  peg$currPos += 2;
3247
2939
  } else {
3248
2940
  s5 = peg$FAILED;
3249
2941
  if (peg$silentFails === 0) {
3250
- peg$fail(peg$e27);
2942
+ peg$fail(peg$e22);
3251
2943
  }
3252
2944
  }
3253
2945
  if (s5 === peg$FAILED) {
3254
2946
  s5 = input.charAt(peg$currPos);
3255
- if (peg$r16.test(s5)) {
2947
+ if (peg$r14.test(s5)) {
3256
2948
  peg$currPos++;
3257
2949
  } else {
3258
2950
  s5 = peg$FAILED;
3259
2951
  if (peg$silentFails === 0) {
3260
- peg$fail(peg$e28);
2952
+ peg$fail(peg$e23);
3261
2953
  }
3262
2954
  }
3263
2955
  }
@@ -3284,61 +2976,61 @@ function peg$parse(input, options) {
3284
2976
  }
3285
2977
  if (s2 !== peg$FAILED) {
3286
2978
  s3 = [];
3287
- if (input.substr(peg$currPos, 2) === peg$c11) {
3288
- s4 = peg$c11;
2979
+ if (input.substr(peg$currPos, 2) === peg$c8) {
2980
+ s4 = peg$c8;
3289
2981
  peg$currPos += 2;
3290
2982
  } else {
3291
2983
  s4 = peg$FAILED;
3292
2984
  if (peg$silentFails === 0) {
3293
- peg$fail(peg$e27);
2985
+ peg$fail(peg$e22);
3294
2986
  }
3295
2987
  }
3296
2988
  if (s4 === peg$FAILED) {
3297
2989
  s4 = input.charAt(peg$currPos);
3298
- if (peg$r16.test(s4)) {
2990
+ if (peg$r14.test(s4)) {
3299
2991
  peg$currPos++;
3300
2992
  } else {
3301
2993
  s4 = peg$FAILED;
3302
2994
  if (peg$silentFails === 0) {
3303
- peg$fail(peg$e28);
2995
+ peg$fail(peg$e23);
3304
2996
  }
3305
2997
  }
3306
2998
  }
3307
2999
  while (s4 !== peg$FAILED) {
3308
3000
  s3.push(s4);
3309
- if (input.substr(peg$currPos, 2) === peg$c11) {
3310
- s4 = peg$c11;
3001
+ if (input.substr(peg$currPos, 2) === peg$c8) {
3002
+ s4 = peg$c8;
3311
3003
  peg$currPos += 2;
3312
3004
  } else {
3313
3005
  s4 = peg$FAILED;
3314
3006
  if (peg$silentFails === 0) {
3315
- peg$fail(peg$e27);
3007
+ peg$fail(peg$e22);
3316
3008
  }
3317
3009
  }
3318
3010
  if (s4 === peg$FAILED) {
3319
3011
  s4 = input.charAt(peg$currPos);
3320
- if (peg$r16.test(s4)) {
3012
+ if (peg$r14.test(s4)) {
3321
3013
  peg$currPos++;
3322
3014
  } else {
3323
3015
  s4 = peg$FAILED;
3324
3016
  if (peg$silentFails === 0) {
3325
- peg$fail(peg$e28);
3017
+ peg$fail(peg$e23);
3326
3018
  }
3327
3019
  }
3328
3020
  }
3329
3021
  }
3330
3022
  s4 = input.charAt(peg$currPos);
3331
- if (peg$r15.test(s4)) {
3023
+ if (peg$r13.test(s4)) {
3332
3024
  peg$currPos++;
3333
3025
  } else {
3334
3026
  s4 = peg$FAILED;
3335
3027
  if (peg$silentFails === 0) {
3336
- peg$fail(peg$e26);
3028
+ peg$fail(peg$e21);
3337
3029
  }
3338
3030
  }
3339
3031
  if (s4 !== peg$FAILED) {
3340
3032
  peg$savedPos = s0;
3341
- s0 = peg$f24(s1);
3033
+ s0 = peg$f22(s1);
3342
3034
  } else {
3343
3035
  peg$currPos = s0;
3344
3036
  s0 = peg$FAILED;
@@ -3353,43 +3045,43 @@ function peg$parse(input, options) {
3353
3045
  }
3354
3046
  return s0;
3355
3047
  }
3356
- chunkCHM43IJO_js.__name(peg$parsesingleDQuotedMultiLineString, "peg$parsesingleDQuotedMultiLineString");
3048
+ chunkX4PJ2KLO_js.__name(peg$parsesingleDQuotedMultiLineString, "peg$parsesingleDQuotedMultiLineString");
3357
3049
  function peg$parsetripleDQuotedMultiLineString() {
3358
3050
  let s0, s1, s2, s3, s4, s5, s6, s7;
3359
3051
  s0 = peg$currPos;
3360
- if (input.substr(peg$currPos, 3) === peg$c14) {
3361
- s1 = peg$c14;
3052
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3053
+ s1 = peg$c11;
3362
3054
  peg$currPos += 3;
3363
3055
  } else {
3364
3056
  s1 = peg$FAILED;
3365
3057
  if (peg$silentFails === 0) {
3366
- peg$fail(peg$e35);
3058
+ peg$fail(peg$e30);
3367
3059
  }
3368
3060
  }
3369
3061
  if (s1 !== peg$FAILED) {
3370
3062
  s2 = [];
3371
3063
  s3 = peg$currPos;
3372
3064
  s4 = [];
3373
- if (input.substr(peg$currPos, 4) === peg$c15) {
3374
- s5 = peg$c15;
3065
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3066
+ s5 = peg$c12;
3375
3067
  peg$currPos += 4;
3376
3068
  } else {
3377
3069
  s5 = peg$FAILED;
3378
3070
  if (peg$silentFails === 0) {
3379
- peg$fail(peg$e36);
3071
+ peg$fail(peg$e31);
3380
3072
  }
3381
3073
  }
3382
3074
  if (s5 === peg$FAILED) {
3383
3075
  s5 = peg$currPos;
3384
3076
  s6 = peg$currPos;
3385
3077
  peg$silentFails++;
3386
- if (input.substr(peg$currPos, 3) === peg$c14) {
3387
- s7 = peg$c14;
3078
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3079
+ s7 = peg$c11;
3388
3080
  peg$currPos += 3;
3389
3081
  } else {
3390
3082
  s7 = peg$FAILED;
3391
3083
  if (peg$silentFails === 0) {
3392
- peg$fail(peg$e35);
3084
+ peg$fail(peg$e30);
3393
3085
  }
3394
3086
  }
3395
3087
  peg$silentFails--;
@@ -3423,26 +3115,26 @@ function peg$parse(input, options) {
3423
3115
  }
3424
3116
  while (s5 !== peg$FAILED) {
3425
3117
  s4.push(s5);
3426
- if (input.substr(peg$currPos, 4) === peg$c15) {
3427
- s5 = peg$c15;
3118
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3119
+ s5 = peg$c12;
3428
3120
  peg$currPos += 4;
3429
3121
  } else {
3430
3122
  s5 = peg$FAILED;
3431
3123
  if (peg$silentFails === 0) {
3432
- peg$fail(peg$e36);
3124
+ peg$fail(peg$e31);
3433
3125
  }
3434
3126
  }
3435
3127
  if (s5 === peg$FAILED) {
3436
3128
  s5 = peg$currPos;
3437
3129
  s6 = peg$currPos;
3438
3130
  peg$silentFails++;
3439
- if (input.substr(peg$currPos, 3) === peg$c14) {
3440
- s7 = peg$c14;
3131
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3132
+ s7 = peg$c11;
3441
3133
  peg$currPos += 3;
3442
3134
  } else {
3443
3135
  s7 = peg$FAILED;
3444
3136
  if (peg$silentFails === 0) {
3445
- peg$fail(peg$e35);
3137
+ peg$fail(peg$e30);
3446
3138
  }
3447
3139
  }
3448
3140
  peg$silentFails--;
@@ -3496,26 +3188,26 @@ function peg$parse(input, options) {
3496
3188
  s2.push(s3);
3497
3189
  s3 = peg$currPos;
3498
3190
  s4 = [];
3499
- if (input.substr(peg$currPos, 4) === peg$c15) {
3500
- s5 = peg$c15;
3191
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3192
+ s5 = peg$c12;
3501
3193
  peg$currPos += 4;
3502
3194
  } else {
3503
3195
  s5 = peg$FAILED;
3504
3196
  if (peg$silentFails === 0) {
3505
- peg$fail(peg$e36);
3197
+ peg$fail(peg$e31);
3506
3198
  }
3507
3199
  }
3508
3200
  if (s5 === peg$FAILED) {
3509
3201
  s5 = peg$currPos;
3510
3202
  s6 = peg$currPos;
3511
3203
  peg$silentFails++;
3512
- if (input.substr(peg$currPos, 3) === peg$c14) {
3513
- s7 = peg$c14;
3204
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3205
+ s7 = peg$c11;
3514
3206
  peg$currPos += 3;
3515
3207
  } else {
3516
3208
  s7 = peg$FAILED;
3517
3209
  if (peg$silentFails === 0) {
3518
- peg$fail(peg$e35);
3210
+ peg$fail(peg$e30);
3519
3211
  }
3520
3212
  }
3521
3213
  peg$silentFails--;
@@ -3549,26 +3241,26 @@ function peg$parse(input, options) {
3549
3241
  }
3550
3242
  while (s5 !== peg$FAILED) {
3551
3243
  s4.push(s5);
3552
- if (input.substr(peg$currPos, 4) === peg$c15) {
3553
- s5 = peg$c15;
3244
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3245
+ s5 = peg$c12;
3554
3246
  peg$currPos += 4;
3555
3247
  } else {
3556
3248
  s5 = peg$FAILED;
3557
3249
  if (peg$silentFails === 0) {
3558
- peg$fail(peg$e36);
3250
+ peg$fail(peg$e31);
3559
3251
  }
3560
3252
  }
3561
3253
  if (s5 === peg$FAILED) {
3562
3254
  s5 = peg$currPos;
3563
3255
  s6 = peg$currPos;
3564
3256
  peg$silentFails++;
3565
- if (input.substr(peg$currPos, 3) === peg$c14) {
3566
- s7 = peg$c14;
3257
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3258
+ s7 = peg$c11;
3567
3259
  peg$currPos += 3;
3568
3260
  } else {
3569
3261
  s7 = peg$FAILED;
3570
3262
  if (peg$silentFails === 0) {
3571
- peg$fail(peg$e35);
3263
+ peg$fail(peg$e30);
3572
3264
  }
3573
3265
  }
3574
3266
  peg$silentFails--;
@@ -3623,26 +3315,26 @@ function peg$parse(input, options) {
3623
3315
  }
3624
3316
  if (s2 !== peg$FAILED) {
3625
3317
  s3 = [];
3626
- if (input.substr(peg$currPos, 4) === peg$c15) {
3627
- s4 = peg$c15;
3318
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3319
+ s4 = peg$c12;
3628
3320
  peg$currPos += 4;
3629
3321
  } else {
3630
3322
  s4 = peg$FAILED;
3631
3323
  if (peg$silentFails === 0) {
3632
- peg$fail(peg$e36);
3324
+ peg$fail(peg$e31);
3633
3325
  }
3634
3326
  }
3635
3327
  if (s4 === peg$FAILED) {
3636
3328
  s4 = peg$currPos;
3637
3329
  s5 = peg$currPos;
3638
3330
  peg$silentFails++;
3639
- if (input.substr(peg$currPos, 3) === peg$c14) {
3640
- s6 = peg$c14;
3331
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3332
+ s6 = peg$c11;
3641
3333
  peg$currPos += 3;
3642
3334
  } else {
3643
3335
  s6 = peg$FAILED;
3644
3336
  if (peg$silentFails === 0) {
3645
- peg$fail(peg$e35);
3337
+ peg$fail(peg$e30);
3646
3338
  }
3647
3339
  }
3648
3340
  peg$silentFails--;
@@ -3676,26 +3368,26 @@ function peg$parse(input, options) {
3676
3368
  }
3677
3369
  while (s4 !== peg$FAILED) {
3678
3370
  s3.push(s4);
3679
- if (input.substr(peg$currPos, 4) === peg$c15) {
3680
- s4 = peg$c15;
3371
+ if (input.substr(peg$currPos, 4) === peg$c12) {
3372
+ s4 = peg$c12;
3681
3373
  peg$currPos += 4;
3682
3374
  } else {
3683
3375
  s4 = peg$FAILED;
3684
3376
  if (peg$silentFails === 0) {
3685
- peg$fail(peg$e36);
3377
+ peg$fail(peg$e31);
3686
3378
  }
3687
3379
  }
3688
3380
  if (s4 === peg$FAILED) {
3689
3381
  s4 = peg$currPos;
3690
3382
  s5 = peg$currPos;
3691
3383
  peg$silentFails++;
3692
- if (input.substr(peg$currPos, 3) === peg$c14) {
3693
- s6 = peg$c14;
3384
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3385
+ s6 = peg$c11;
3694
3386
  peg$currPos += 3;
3695
3387
  } else {
3696
3388
  s6 = peg$FAILED;
3697
3389
  if (peg$silentFails === 0) {
3698
- peg$fail(peg$e35);
3390
+ peg$fail(peg$e30);
3699
3391
  }
3700
3392
  }
3701
3393
  peg$silentFails--;
@@ -3728,18 +3420,18 @@ function peg$parse(input, options) {
3728
3420
  }
3729
3421
  }
3730
3422
  }
3731
- if (input.substr(peg$currPos, 3) === peg$c14) {
3732
- s4 = peg$c14;
3423
+ if (input.substr(peg$currPos, 3) === peg$c11) {
3424
+ s4 = peg$c11;
3733
3425
  peg$currPos += 3;
3734
3426
  } else {
3735
3427
  s4 = peg$FAILED;
3736
3428
  if (peg$silentFails === 0) {
3737
- peg$fail(peg$e35);
3429
+ peg$fail(peg$e30);
3738
3430
  }
3739
3431
  }
3740
3432
  if (s4 !== peg$FAILED) {
3741
3433
  peg$savedPos = s0;
3742
- s0 = peg$f25(s1);
3434
+ s0 = peg$f23(s1);
3743
3435
  } else {
3744
3436
  peg$currPos = s0;
3745
3437
  s0 = peg$FAILED;
@@ -3754,43 +3446,43 @@ function peg$parse(input, options) {
3754
3446
  }
3755
3447
  return s0;
3756
3448
  }
3757
- chunkCHM43IJO_js.__name(peg$parsetripleDQuotedMultiLineString, "peg$parsetripleDQuotedMultiLineString");
3449
+ chunkX4PJ2KLO_js.__name(peg$parsetripleDQuotedMultiLineString, "peg$parsetripleDQuotedMultiLineString");
3758
3450
  function peg$parsetripleBQuotedMultiLineString() {
3759
3451
  let s0, s1, s2, s3, s4, s5, s6, s7;
3760
3452
  s0 = peg$currPos;
3761
- if (input.substr(peg$currPos, 3) === peg$c16) {
3762
- s1 = peg$c16;
3453
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3454
+ s1 = peg$c13;
3763
3455
  peg$currPos += 3;
3764
3456
  } else {
3765
3457
  s1 = peg$FAILED;
3766
3458
  if (peg$silentFails === 0) {
3767
- peg$fail(peg$e37);
3459
+ peg$fail(peg$e32);
3768
3460
  }
3769
3461
  }
3770
3462
  if (s1 !== peg$FAILED) {
3771
3463
  s2 = [];
3772
3464
  s3 = peg$currPos;
3773
3465
  s4 = [];
3774
- if (input.substr(peg$currPos, 4) === peg$c17) {
3775
- s5 = peg$c17;
3466
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3467
+ s5 = peg$c14;
3776
3468
  peg$currPos += 4;
3777
3469
  } else {
3778
3470
  s5 = peg$FAILED;
3779
3471
  if (peg$silentFails === 0) {
3780
- peg$fail(peg$e38);
3472
+ peg$fail(peg$e33);
3781
3473
  }
3782
3474
  }
3783
3475
  if (s5 === peg$FAILED) {
3784
3476
  s5 = peg$currPos;
3785
3477
  s6 = peg$currPos;
3786
3478
  peg$silentFails++;
3787
- if (input.substr(peg$currPos, 3) === peg$c16) {
3788
- s7 = peg$c16;
3479
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3480
+ s7 = peg$c13;
3789
3481
  peg$currPos += 3;
3790
3482
  } else {
3791
3483
  s7 = peg$FAILED;
3792
3484
  if (peg$silentFails === 0) {
3793
- peg$fail(peg$e37);
3485
+ peg$fail(peg$e32);
3794
3486
  }
3795
3487
  }
3796
3488
  peg$silentFails--;
@@ -3824,26 +3516,26 @@ function peg$parse(input, options) {
3824
3516
  }
3825
3517
  while (s5 !== peg$FAILED) {
3826
3518
  s4.push(s5);
3827
- if (input.substr(peg$currPos, 4) === peg$c17) {
3828
- s5 = peg$c17;
3519
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3520
+ s5 = peg$c14;
3829
3521
  peg$currPos += 4;
3830
3522
  } else {
3831
3523
  s5 = peg$FAILED;
3832
3524
  if (peg$silentFails === 0) {
3833
- peg$fail(peg$e38);
3525
+ peg$fail(peg$e33);
3834
3526
  }
3835
3527
  }
3836
3528
  if (s5 === peg$FAILED) {
3837
3529
  s5 = peg$currPos;
3838
3530
  s6 = peg$currPos;
3839
3531
  peg$silentFails++;
3840
- if (input.substr(peg$currPos, 3) === peg$c16) {
3841
- s7 = peg$c16;
3532
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3533
+ s7 = peg$c13;
3842
3534
  peg$currPos += 3;
3843
3535
  } else {
3844
3536
  s7 = peg$FAILED;
3845
3537
  if (peg$silentFails === 0) {
3846
- peg$fail(peg$e37);
3538
+ peg$fail(peg$e32);
3847
3539
  }
3848
3540
  }
3849
3541
  peg$silentFails--;
@@ -3897,26 +3589,26 @@ function peg$parse(input, options) {
3897
3589
  s2.push(s3);
3898
3590
  s3 = peg$currPos;
3899
3591
  s4 = [];
3900
- if (input.substr(peg$currPos, 4) === peg$c17) {
3901
- s5 = peg$c17;
3592
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3593
+ s5 = peg$c14;
3902
3594
  peg$currPos += 4;
3903
3595
  } else {
3904
3596
  s5 = peg$FAILED;
3905
3597
  if (peg$silentFails === 0) {
3906
- peg$fail(peg$e38);
3598
+ peg$fail(peg$e33);
3907
3599
  }
3908
3600
  }
3909
3601
  if (s5 === peg$FAILED) {
3910
3602
  s5 = peg$currPos;
3911
3603
  s6 = peg$currPos;
3912
3604
  peg$silentFails++;
3913
- if (input.substr(peg$currPos, 3) === peg$c16) {
3914
- s7 = peg$c16;
3605
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3606
+ s7 = peg$c13;
3915
3607
  peg$currPos += 3;
3916
3608
  } else {
3917
3609
  s7 = peg$FAILED;
3918
3610
  if (peg$silentFails === 0) {
3919
- peg$fail(peg$e37);
3611
+ peg$fail(peg$e32);
3920
3612
  }
3921
3613
  }
3922
3614
  peg$silentFails--;
@@ -3950,26 +3642,26 @@ function peg$parse(input, options) {
3950
3642
  }
3951
3643
  while (s5 !== peg$FAILED) {
3952
3644
  s4.push(s5);
3953
- if (input.substr(peg$currPos, 4) === peg$c17) {
3954
- s5 = peg$c17;
3645
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3646
+ s5 = peg$c14;
3955
3647
  peg$currPos += 4;
3956
3648
  } else {
3957
3649
  s5 = peg$FAILED;
3958
3650
  if (peg$silentFails === 0) {
3959
- peg$fail(peg$e38);
3651
+ peg$fail(peg$e33);
3960
3652
  }
3961
3653
  }
3962
3654
  if (s5 === peg$FAILED) {
3963
3655
  s5 = peg$currPos;
3964
3656
  s6 = peg$currPos;
3965
3657
  peg$silentFails++;
3966
- if (input.substr(peg$currPos, 3) === peg$c16) {
3967
- s7 = peg$c16;
3658
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3659
+ s7 = peg$c13;
3968
3660
  peg$currPos += 3;
3969
3661
  } else {
3970
3662
  s7 = peg$FAILED;
3971
3663
  if (peg$silentFails === 0) {
3972
- peg$fail(peg$e37);
3664
+ peg$fail(peg$e32);
3973
3665
  }
3974
3666
  }
3975
3667
  peg$silentFails--;
@@ -4024,26 +3716,26 @@ function peg$parse(input, options) {
4024
3716
  }
4025
3717
  if (s2 !== peg$FAILED) {
4026
3718
  s3 = [];
4027
- if (input.substr(peg$currPos, 4) === peg$c17) {
4028
- s4 = peg$c17;
3719
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3720
+ s4 = peg$c14;
4029
3721
  peg$currPos += 4;
4030
3722
  } else {
4031
3723
  s4 = peg$FAILED;
4032
3724
  if (peg$silentFails === 0) {
4033
- peg$fail(peg$e38);
3725
+ peg$fail(peg$e33);
4034
3726
  }
4035
3727
  }
4036
3728
  if (s4 === peg$FAILED) {
4037
3729
  s4 = peg$currPos;
4038
3730
  s5 = peg$currPos;
4039
3731
  peg$silentFails++;
4040
- if (input.substr(peg$currPos, 3) === peg$c16) {
4041
- s6 = peg$c16;
3732
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3733
+ s6 = peg$c13;
4042
3734
  peg$currPos += 3;
4043
3735
  } else {
4044
3736
  s6 = peg$FAILED;
4045
3737
  if (peg$silentFails === 0) {
4046
- peg$fail(peg$e37);
3738
+ peg$fail(peg$e32);
4047
3739
  }
4048
3740
  }
4049
3741
  peg$silentFails--;
@@ -4077,26 +3769,26 @@ function peg$parse(input, options) {
4077
3769
  }
4078
3770
  while (s4 !== peg$FAILED) {
4079
3771
  s3.push(s4);
4080
- if (input.substr(peg$currPos, 4) === peg$c17) {
4081
- s4 = peg$c17;
3772
+ if (input.substr(peg$currPos, 4) === peg$c14) {
3773
+ s4 = peg$c14;
4082
3774
  peg$currPos += 4;
4083
3775
  } else {
4084
3776
  s4 = peg$FAILED;
4085
3777
  if (peg$silentFails === 0) {
4086
- peg$fail(peg$e38);
3778
+ peg$fail(peg$e33);
4087
3779
  }
4088
3780
  }
4089
3781
  if (s4 === peg$FAILED) {
4090
3782
  s4 = peg$currPos;
4091
3783
  s5 = peg$currPos;
4092
3784
  peg$silentFails++;
4093
- if (input.substr(peg$currPos, 3) === peg$c16) {
4094
- s6 = peg$c16;
3785
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3786
+ s6 = peg$c13;
4095
3787
  peg$currPos += 3;
4096
3788
  } else {
4097
3789
  s6 = peg$FAILED;
4098
3790
  if (peg$silentFails === 0) {
4099
- peg$fail(peg$e37);
3791
+ peg$fail(peg$e32);
4100
3792
  }
4101
3793
  }
4102
3794
  peg$silentFails--;
@@ -4129,18 +3821,18 @@ function peg$parse(input, options) {
4129
3821
  }
4130
3822
  }
4131
3823
  }
4132
- if (input.substr(peg$currPos, 3) === peg$c16) {
4133
- s4 = peg$c16;
3824
+ if (input.substr(peg$currPos, 3) === peg$c13) {
3825
+ s4 = peg$c13;
4134
3826
  peg$currPos += 3;
4135
3827
  } else {
4136
3828
  s4 = peg$FAILED;
4137
3829
  if (peg$silentFails === 0) {
4138
- peg$fail(peg$e37);
3830
+ peg$fail(peg$e32);
4139
3831
  }
4140
3832
  }
4141
3833
  if (s4 !== peg$FAILED) {
4142
3834
  peg$savedPos = s0;
4143
- s0 = peg$f26(s1);
3835
+ s0 = peg$f24(s1);
4144
3836
  } else {
4145
3837
  peg$currPos = s0;
4146
3838
  s0 = peg$FAILED;
@@ -4155,7 +3847,7 @@ function peg$parse(input, options) {
4155
3847
  }
4156
3848
  return s0;
4157
3849
  }
4158
- chunkCHM43IJO_js.__name(peg$parsetripleBQuotedMultiLineString, "peg$parsetripleBQuotedMultiLineString");
3850
+ chunkX4PJ2KLO_js.__name(peg$parsetripleBQuotedMultiLineString, "peg$parsetripleBQuotedMultiLineString");
4159
3851
  function peg$parse_n() {
4160
3852
  let s0, s1;
4161
3853
  if (input.charCodeAt(peg$currPos) === 10) {
@@ -4176,7 +3868,7 @@ function peg$parse(input, options) {
4176
3868
  } else {
4177
3869
  s1 = peg$FAILED;
4178
3870
  if (peg$silentFails === 0) {
4179
- peg$fail(peg$e39);
3871
+ peg$fail(peg$e34);
4180
3872
  }
4181
3873
  }
4182
3874
  peg$silentFails--;
@@ -4189,56 +3881,56 @@ function peg$parse(input, options) {
4189
3881
  }
4190
3882
  return s0;
4191
3883
  }
4192
- chunkCHM43IJO_js.__name(peg$parse_n, "peg$parse_n");
3884
+ chunkX4PJ2KLO_js.__name(peg$parse_n, "peg$parse_n");
4193
3885
  function peg$parse_() {
4194
3886
  let s0, s1;
4195
3887
  s0 = [];
4196
3888
  s1 = input.charAt(peg$currPos);
4197
- if (peg$r7.test(s1)) {
3889
+ if (peg$r6.test(s1)) {
4198
3890
  peg$currPos++;
4199
3891
  } else {
4200
3892
  s1 = peg$FAILED;
4201
3893
  if (peg$silentFails === 0) {
4202
- peg$fail(peg$e16);
3894
+ peg$fail(peg$e14);
4203
3895
  }
4204
3896
  }
4205
3897
  while (s1 !== peg$FAILED) {
4206
3898
  s0.push(s1);
4207
3899
  s1 = input.charAt(peg$currPos);
4208
- if (peg$r7.test(s1)) {
3900
+ if (peg$r6.test(s1)) {
4209
3901
  peg$currPos++;
4210
3902
  } else {
4211
3903
  s1 = peg$FAILED;
4212
3904
  if (peg$silentFails === 0) {
4213
- peg$fail(peg$e16);
3905
+ peg$fail(peg$e14);
4214
3906
  }
4215
3907
  }
4216
3908
  }
4217
3909
  return s0;
4218
3910
  }
4219
- chunkCHM43IJO_js.__name(peg$parse_, "peg$parse_");
3911
+ chunkX4PJ2KLO_js.__name(peg$parse_, "peg$parse_");
4220
3912
  function peg$parse__() {
4221
3913
  let s0, s1;
4222
3914
  s0 = [];
4223
3915
  s1 = input.charAt(peg$currPos);
4224
- if (peg$r7.test(s1)) {
3916
+ if (peg$r6.test(s1)) {
4225
3917
  peg$currPos++;
4226
3918
  } else {
4227
3919
  s1 = peg$FAILED;
4228
3920
  if (peg$silentFails === 0) {
4229
- peg$fail(peg$e16);
3921
+ peg$fail(peg$e14);
4230
3922
  }
4231
3923
  }
4232
3924
  if (s1 !== peg$FAILED) {
4233
3925
  while (s1 !== peg$FAILED) {
4234
3926
  s0.push(s1);
4235
3927
  s1 = input.charAt(peg$currPos);
4236
- if (peg$r7.test(s1)) {
3928
+ if (peg$r6.test(s1)) {
4237
3929
  peg$currPos++;
4238
3930
  } else {
4239
3931
  s1 = peg$FAILED;
4240
3932
  if (peg$silentFails === 0) {
4241
- peg$fail(peg$e16);
3933
+ peg$fail(peg$e14);
4242
3934
  }
4243
3935
  }
4244
3936
  }
@@ -4247,7 +3939,7 @@ function peg$parse(input, options) {
4247
3939
  }
4248
3940
  return s0;
4249
3941
  }
4250
- chunkCHM43IJO_js.__name(peg$parse__, "peg$parse__");
3942
+ chunkX4PJ2KLO_js.__name(peg$parse__, "peg$parse__");
4251
3943
  peg$result = peg$startRuleFunction();
4252
3944
  const peg$success = peg$result !== peg$FAILED && peg$currPos === input.length;
4253
3945
  function peg$throw() {
@@ -4260,7 +3952,7 @@ function peg$parse(input, options) {
4260
3952
  peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
4261
3953
  );
4262
3954
  }
4263
- chunkCHM43IJO_js.__name(peg$throw, "peg$throw");
3955
+ chunkX4PJ2KLO_js.__name(peg$throw, "peg$throw");
4264
3956
  if (options.peg$library) {
4265
3957
  return (
4266
3958
  /** @type {any} */
@@ -4281,69 +3973,65 @@ function peg$parse(input, options) {
4281
3973
  peg$throw();
4282
3974
  }
4283
3975
  }
4284
- chunkCHM43IJO_js.__name(peg$parse, "peg$parse");
3976
+ chunkX4PJ2KLO_js.__name(peg$parse, "peg$parse");
4285
3977
 
4286
3978
  // src/index.ts
4287
3979
  function parseEnvSpecDotEnvFile(source) {
4288
3980
  return peg$parse(source.replaceAll("\r\n", "\n"));
4289
3981
  }
4290
- chunkCHM43IJO_js.__name(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
3982
+ chunkX4PJ2KLO_js.__name(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
4291
3983
 
4292
3984
  Object.defineProperty(exports, "ParsedEnvSpecBlankLine", {
4293
3985
  enumerable: true,
4294
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecBlankLine; }
3986
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecBlankLine; }
4295
3987
  });
4296
3988
  Object.defineProperty(exports, "ParsedEnvSpecComment", {
4297
3989
  enumerable: true,
4298
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecComment; }
3990
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecComment; }
4299
3991
  });
4300
3992
  Object.defineProperty(exports, "ParsedEnvSpecCommentBlock", {
4301
3993
  enumerable: true,
4302
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecCommentBlock; }
3994
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecCommentBlock; }
4303
3995
  });
4304
3996
  Object.defineProperty(exports, "ParsedEnvSpecConfigItem", {
4305
3997
  enumerable: true,
4306
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecConfigItem; }
3998
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecConfigItem; }
4307
3999
  });
4308
4000
  Object.defineProperty(exports, "ParsedEnvSpecDecorator", {
4309
4001
  enumerable: true,
4310
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecDecorator; }
4002
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecDecorator; }
4311
4003
  });
4312
4004
  Object.defineProperty(exports, "ParsedEnvSpecDecoratorComment", {
4313
4005
  enumerable: true,
4314
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecDecoratorComment; }
4006
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecDecoratorComment; }
4315
4007
  });
4316
4008
  Object.defineProperty(exports, "ParsedEnvSpecDivider", {
4317
4009
  enumerable: true,
4318
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecDivider; }
4010
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecDivider; }
4319
4011
  });
4320
4012
  Object.defineProperty(exports, "ParsedEnvSpecFile", {
4321
4013
  enumerable: true,
4322
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecFile; }
4014
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecFile; }
4323
4015
  });
4324
4016
  Object.defineProperty(exports, "ParsedEnvSpecFunctionArgs", {
4325
4017
  enumerable: true,
4326
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecFunctionArgs; }
4018
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecFunctionArgs; }
4327
4019
  });
4328
4020
  Object.defineProperty(exports, "ParsedEnvSpecFunctionCall", {
4329
4021
  enumerable: true,
4330
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecFunctionCall; }
4022
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecFunctionCall; }
4331
4023
  });
4332
4024
  Object.defineProperty(exports, "ParsedEnvSpecKeyValuePair", {
4333
4025
  enumerable: true,
4334
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecKeyValuePair; }
4335
- });
4336
- Object.defineProperty(exports, "ParsedEnvSpecRegexLiteral", {
4337
- enumerable: true,
4338
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecRegexLiteral; }
4026
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecKeyValuePair; }
4339
4027
  });
4340
4028
  Object.defineProperty(exports, "ParsedEnvSpecStaticValue", {
4341
4029
  enumerable: true,
4342
- get: function () { return chunkCHM43IJO_js.ParsedEnvSpecStaticValue; }
4030
+ get: function () { return chunkX4PJ2KLO_js.ParsedEnvSpecStaticValue; }
4343
4031
  });
4344
4032
  Object.defineProperty(exports, "expand", {
4345
4033
  enumerable: true,
4346
- get: function () { return chunkCHM43IJO_js.expand; }
4034
+ get: function () { return chunkX4PJ2KLO_js.expand; }
4347
4035
  });
4348
4036
  exports.envSpecUpdater = envSpecUpdater;
4349
4037
  exports.parseEnvSpecDotEnvFile = parseEnvSpecDotEnvFile;