@wener/miniquery/src/mikro-orm/parser.js

SQL Where like **safe** filter expression for ORM.

// @generated by Peggy 5.0.5.
//
// https://peggyjs.org/

/* eslint-disable @typescript-eslint/interface-name-prefix,@typescript-eslint/no-empty-interface,no-case-declarations,no-control-regex,prefer-const */
// ts-nocheck
const pick = (obj, keys) => keys.reduce((o, k) => ((o[k] = obj[k]), o), {});
// https://mikro-orm.io/docs/query-conditions
const OPERATORS = {
	'>=': '$gte',
	'<=': '$lte',
	'>': '$gt',
	'<': '$lt',
	// ":":"$eq",// fixme has
	'=': '$eq',
	'==': '$eq',
	'===': '$eq',
	'<>': '$ne',
	'!=': '$ne',
	in: '$in',
	'not in': '$nin',
	'&&': '$and',
	and: '$and',
	'||': '$or',
	or: '$or',
	nor: '$nor',
	'!': '$not',
	'~': '$re',
	like: '$like',
	ilike: '$ilike',
	// https://www.postgresql.org/docs/current/functions-json.html
	'@>': '$contains',
	'<@': '$contained',
	// $overlap	&&
	// https://www.postgresql.org/docs/current/functions-textsearch.html
	// $fulltext
	between: '$between',
};
// https://www.postgresql.org/docs/current/functions-array.html
const ARRAY_OPERATORS = Object.assign({ '&&': '$overlap' }, pick(OPERATORS, ['@>', '<@']));

class peg$SyntaxError extends SyntaxError {
	constructor(message, expected, found, location) {
		super(message);
		this.expected = expected;
		this.found = found;
		this.location = location;
		this.name = 'SyntaxError';
	}

	format(sources) {
		let str = 'Error: ' + this.message;
		if (this.location) {
			let src = null;
			const st = sources.find((s) => s.source === this.location.source);
			if (st) {
				src = st.text.split(/\r\n|\n|\r/g);
			}
			const s = this.location.start;
			const offset_s =
				this.location.source && typeof this.location.source.offset === 'function' ? this.location.source.offset(s) : s;
			const loc = this.location.source + ':' + offset_s.line + ':' + offset_s.column;
			if (src) {
				const e = this.location.end;
				const filler = ''.padEnd(offset_s.line.toString().length, ' ');
				const line = src[s.line - 1];
				const last = s.line === e.line ? e.column : line.length + 1;
				const hatLen = last - s.column || 1;
				str +=
					'\n --> '
					+ loc
					+ '\n'
					+ filler
					+ ' |\n'
					+ offset_s.line
					+ ' | '
					+ line
					+ '\n'
					+ filler
					+ ' | '
					+ ''.padEnd(s.column - 1, ' ')
					+ ''.padEnd(hatLen, '^');
			} else {
				str += '\n at ' + loc;
			}
		}
		return str;
	}

	static buildMessage(expected, found) {
		function hex(ch) {
			return ch.codePointAt(0).toString(16).toUpperCase();
		}

		const nonPrintable = Object.prototype.hasOwnProperty.call(RegExp.prototype, 'unicode')
			? new RegExp('[\\p{C}\\p{Mn}\\p{Mc}]', 'gu')
			: null;

		function unicodeEscape(s) {
			if (nonPrintable) {
				return s.replace(nonPrintable, (ch) => '\\u{' + hex(ch) + '}');
			}
			return s;
		}

		function literalEscape(s) {
			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)),
			);
		}

		function classEscape(s) {
			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)),
			);
		}

		const DESCRIBE_EXPECTATION_FNS = {
			literal(expectation) {
				return '"' + literalEscape(expectation.text) + '"';
			},

			class(expectation) {
				const escapedParts = expectation.parts.map((part) =>
					Array.isArray(part) ? classEscape(part[0]) + '-' + classEscape(part[1]) : classEscape(part),
				);

				return '[' + (expectation.inverted ? '^' : '') + escapedParts.join('') + ']' + (expectation.unicode ? 'u' : '');
			},

			any() {
				return 'any character';
			},

			end() {
				return 'end of input';
			},

			other(expectation) {
				return expectation.description;
			},
		};

		function describeExpectation(expectation) {
			return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
		}

		function describeExpected(expected) {
			const descriptions = expected.map(describeExpectation);
			descriptions.sort();

			if (descriptions.length > 0) {
				let j = 1;
				for (let i = 1; i < descriptions.length; i++) {
					if (descriptions[i - 1] !== descriptions[i]) {
						descriptions[j] = descriptions[i];
						j++;
					}
				}
				descriptions.length = j;
			}

			switch (descriptions.length) {
				case 1:
					return descriptions[0];

				case 2:
					return descriptions[0] + ' or ' + descriptions[1];

				default:
					return descriptions.slice(0, -1).join(', ') + ', or ' + descriptions[descriptions.length - 1];
			}
		}

		function describeFound(found) {
			return found ? '"' + literalEscape(found) + '"' : 'end of input';
		}

		return 'Expected ' + describeExpected(expected) + ' but ' + describeFound(found) + ' found.';
	}
}

function peg$parse(input, options) {
	options = options !== undefined ? options : {};

	const peg$FAILED = {};
	const peg$source = options.grammarSource;

	const peg$startRuleFunctions = {
		Main: peg$parseMain,
	};
	let peg$startRuleFunction = peg$parseMain;

	const peg$c0 = '&&';
	const peg$c1 = '||';
	const peg$c2 = '(';
	const peg$c3 = ')';
	const peg$c4 = '!';
	const peg$c5 = 'between';
	const peg$c6 = 'and';
	const peg$c7 = '>=';
	const peg$c8 = '<=';
	const peg$c9 = '<>';
	const peg$c10 = '===';
	const peg$c11 = '==';
	const peg$c12 = '!=';
	const peg$c13 = '@>';
	const peg$c14 = '<@';
	const peg$c15 = '~';
	const peg$c16 = ',';
	const peg$c17 = '[';
	const peg$c18 = ']';
	const peg$c19 = '.';
	const peg$c20 = 'in';
	const peg$c21 = 'IN';
	const peg$c22 = 'is';
	const peg$c23 = 'IS';
	const peg$c24 = 'like';
	const peg$c25 = 'LIKE';
	const peg$c26 = 'ilike';
	const peg$c27 = 'ILIKE';
	const peg$c28 = 'AND';
	const peg$c29 = 'not';
	const peg$c30 = 'NOT';
	const peg$c31 = 'or';
	const peg$c32 = 'OR';
	const peg$c33 = "'";
	const peg$c34 = '"';
	const peg$c35 = 'null';
	const peg$c36 = 'NULL';
	const peg$c37 = 'true';
	const peg$c38 = 'false';
	const peg$c39 = 'TRUE';
	const peg$c40 = 'FALSE';
	const peg$c41 = '/*';
	const peg$c42 = '*/';
	const peg$c43 = '--';
	const peg$c44 = '\n';

	const peg$r0 = /^[<>]/;
	const peg$r1 = /^[:=]/;
	const peg$r2 = /^[a-zA-Z]/;
	const peg$r3 = /^[_a-zA-Z0-9]/;
	const peg$r4 = /^[0-9]/;
	const peg$r5 = /^[^']/;
	const peg$r6 = /^[^"]/;
	const peg$r7 = /^[^*]/;
	const peg$r8 = /^[^\r\n]/;
	const peg$r9 = /^[ \t\n\r]/;

	const peg$e0 = peg$literalExpectation('&&', false);
	const peg$e1 = peg$literalExpectation('||', false);
	const peg$e2 = peg$literalExpectation('(', false);
	const peg$e3 = peg$literalExpectation(')', false);
	const peg$e4 = peg$literalExpectation('!', false);
	const peg$e5 = peg$literalExpectation('between', false);
	const peg$e6 = peg$literalExpectation('and', false);
	const peg$e7 = peg$literalExpectation('>=', false);
	const peg$e8 = peg$literalExpectation('<=', false);
	const peg$e9 = peg$literalExpectation('<>', false);
	const peg$e10 = peg$classExpectation(['<', '>'], false, false, false);
	const peg$e11 = peg$literalExpectation('===', false);
	const peg$e12 = peg$literalExpectation('==', false);
	const peg$e13 = peg$literalExpectation('!=', false);
	const peg$e14 = peg$classExpectation([':', '='], false, false, false);
	const peg$e15 = peg$literalExpectation('@>', false);
	const peg$e16 = peg$literalExpectation('<@', false);
	const peg$e17 = peg$literalExpectation('~', false);
	const peg$e18 = peg$literalExpectation(',', false);
	const peg$e19 = peg$literalExpectation('[', false);
	const peg$e20 = peg$literalExpectation(']', false);
	const peg$e21 = peg$literalExpectation('.', false);
	const peg$e22 = peg$classExpectation(
		[
			['a', 'z'],
			['A', 'Z'],
		],
		false,
		false,
		false,
	);
	const peg$e23 = peg$classExpectation(['_', ['a', 'z'], ['A', 'Z'], ['0', '9']], false, false, false);
	const peg$e24 = peg$literalExpectation('in', false);
	const peg$e25 = peg$literalExpectation('IN', false);
	const peg$e26 = peg$literalExpectation('is', false);
	const peg$e27 = peg$literalExpectation('IS', false);
	const peg$e28 = peg$literalExpectation('like', false);
	const peg$e29 = peg$literalExpectation('LIKE', false);
	const peg$e30 = peg$literalExpectation('ilike', false);
	const peg$e31 = peg$literalExpectation('ILIKE', false);
	const peg$e32 = peg$literalExpectation('AND', false);
	const peg$e33 = peg$literalExpectation('not', false);
	const peg$e34 = peg$literalExpectation('NOT', false);
	const peg$e35 = peg$literalExpectation('or', false);
	const peg$e36 = peg$literalExpectation('OR', false);
	const peg$e37 = peg$classExpectation([['0', '9']], false, false, false);
	const peg$e38 = peg$literalExpectation("'", false);
	const peg$e39 = peg$classExpectation(["'"], true, false, false);
	const peg$e40 = peg$literalExpectation('"', false);
	const peg$e41 = peg$classExpectation(['"'], true, false, false);
	const peg$e42 = peg$literalExpectation('null', false);
	const peg$e43 = peg$literalExpectation('NULL', false);
	const peg$e44 = peg$literalExpectation('true', false);
	const peg$e45 = peg$literalExpectation('false', false);
	const peg$e46 = peg$literalExpectation('TRUE', false);
	const peg$e47 = peg$literalExpectation('FALSE', false);
	const peg$e48 = peg$otherExpectation('whitespace');
	const peg$e49 = peg$literalExpectation('/*', false);
	const peg$e50 = peg$classExpectation(['*'], true, false, false);
	const peg$e51 = peg$literalExpectation('*/', false);
	const peg$e52 = peg$literalExpectation('--', false);
	const peg$e53 = peg$classExpectation(['\r', '\n'], true, false, false);
	const peg$e54 = peg$literalExpectation('\n', false);
	const peg$e55 = peg$classExpectation([' ', '\t', '\n', '\r'], false, false, false);
	const peg$e56 = peg$anyExpectation();

	function peg$f0(next) {
		return next;
	}

	function peg$f1(next) {
		return next;
	}

	function peg$f2(left, op, right) {
		return { op, right };
	}

	function peg$f3(left, rest) {
		return rest?.right ? _compound(rest?.op, left, rest?.right) : left;
	}

	function peg$f4(next) {
		return next;
	}

	function peg$f5(next) {
		return { $not: next };
	}

	function peg$f6(field, value1, value2) {
		return _make(field, '$between', value1, value2);
	}

	function peg$f7(field, op, value) {
		return _make(field, op, value);
	}

	function peg$f8(field, op, value) {
		return _make(field, ARRAY_OPERATORS[op], value);
	}

	function peg$f9(field, op, value) {
		return _make(field, op, value);
	}

	function peg$f10(field, op) {
		return _make(field, '=', null);
	}

	function peg$f11(field, op) {
		return _make(field, '!=', null);
	}

	function peg$f12(field, op, value) {
		return _make(field, op, value);
	}

	function peg$f13(field, op, value) {
		return _make(field, op, value);
	}

	function peg$f14(next) {
		return next || [];
	}

	function peg$f15(next) {
		return next;
	}

	function peg$f16(next) {
		return next;
	}

	function peg$f17(a) {
		return a;
	}

	function peg$f18() {
		return text();
	}

	function peg$f19() {
		return 'in';
	}

	function peg$f20() {
		return 'is';
	}

	function peg$f21() {
		return 'like';
	}

	function peg$f22() {
		return 'ilike';
	}

	function peg$f23() {
		return 'and';
	}

	function peg$f24() {
		return 'not';
	}

	function peg$f25() {
		return 'or';
	}

	function peg$f26() {
		return parseInt(text());
	}

	function peg$f27() {
		return parseFloat(text());
	}

	function peg$f28(v) {
		return v.join('');
	}

	function peg$f29(v) {
		return v.join('');
	}

	function peg$f30() {
		return null;
	}

	function peg$f31() {
		return text().toLowerCase() === 'true';
	}

	function peg$f32() {
		return '';
	}

	function peg$f33() {
		return ' ';
	}

	let peg$currPos = options.peg$currPos | 0;
	let peg$savedPos = peg$currPos;
	const peg$posDetailsCache = [{ line: 1, column: 1 }];
	let peg$maxFailPos = peg$currPos;
	let peg$maxFailExpected = options.peg$maxFailExpected || [];
	let peg$silentFails = options.peg$silentFails | 0;

	let peg$result;

	if (options.startRule) {
		if (!(options.startRule in peg$startRuleFunctions)) {
			throw new Error('Can\'t start parsing from rule "' + options.startRule + '".');
		}

		peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
	}

	function text() {
		return input.substring(peg$savedPos, peg$currPos);
	}

	function offset() {
		return peg$savedPos;
	}

	function range() {
		return {
			source: peg$source,
			start: peg$savedPos,
			end: peg$currPos,
		};
	}

	function location() {
		return peg$computeLocation(peg$savedPos, peg$currPos);
	}

	function expected(description, location) {
		location = location !== undefined ? location : peg$computeLocation(peg$savedPos, peg$currPos);

		throw peg$buildStructuredError(
			[peg$otherExpectation(description)],
			input.substring(peg$savedPos, peg$currPos),
			location,
		);
	}

	function error(message, location) {
		location = location !== undefined ? location : peg$computeLocation(peg$savedPos, peg$currPos);

		throw peg$buildSimpleError(message, location);
	}

	function peg$getUnicode(pos = peg$currPos) {
		const cp = input.codePointAt(pos);
		if (cp === undefined) {
			return '';
		}
		return String.fromCodePoint(cp);
	}

	function peg$literalExpectation(text, ignoreCase) {
		return { type: 'literal', text, ignoreCase };
	}

	function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
		return { type: 'class', parts, inverted, ignoreCase, unicode };
	}

	function peg$anyExpectation() {
		return { type: 'any' };
	}

	function peg$endExpectation() {
		return { type: 'end' };
	}

	function peg$otherExpectation(description) {
		return { type: 'other', description };
	}

	function peg$computePosDetails(pos) {
		let details = peg$posDetailsCache[pos];
		let p;

		if (details) {
			return details;
		} else {
			if (pos >= peg$posDetailsCache.length) {
				p = peg$posDetailsCache.length - 1;
			} else {
				p = pos;
				while (!peg$posDetailsCache[--p]) {}
			}

			details = peg$posDetailsCache[p];
			details = {
				line: details.line,
				column: details.column,
			};

			while (p < pos) {
				if (input.charCodeAt(p) === 10) {
					details.line++;
					details.column = 1;
				} else {
					details.column++;
				}

				p++;
			}

			peg$posDetailsCache[pos] = details;

			return details;
		}
	}

	function peg$computeLocation(startPos, endPos, offset) {
		const startPosDetails = peg$computePosDetails(startPos);
		const endPosDetails = peg$computePosDetails(endPos);

		const res = {
			source: peg$source,
			start: {
				offset: startPos,
				line: startPosDetails.line,
				column: startPosDetails.column,
			},
			end: {
				offset: endPos,
				line: endPosDetails.line,
				column: endPosDetails.column,
			},
		};
		if (offset && peg$source && typeof peg$source.offset === 'function') {
			res.start = peg$source.offset(res.start);
			res.end = peg$source.offset(res.end);
		}
		return res;
	}

	function peg$fail(expected) {
		if (peg$currPos < peg$maxFailPos) {
			return;
		}

		if (peg$currPos > peg$maxFailPos) {
			peg$maxFailPos = peg$currPos;
			peg$maxFailExpected = [];
		}

		peg$maxFailExpected.push(expected);
	}

	function peg$buildSimpleError(message, location) {
		return new peg$SyntaxError(message, null, null, location);
	}

	function peg$buildStructuredError(expected, found, location) {
		return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
	}

	function peg$parseMain() {
		let s0, s1, s2;

		s0 = peg$currPos;
		s1 = peg$parseQueryExpr();
		if (s1 !== peg$FAILED) {
			s2 = peg$parseEOF();
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f0(s1);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parseQueryExpr() {
		let s0, s1, s2, s3;

		s0 = peg$currPos;
		s1 = peg$parse_();
		s2 = peg$parseCompoundExpr();
		if (s2 !== peg$FAILED) {
			s3 = peg$parse_();
			s0 = s2;
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parseExpr() {
		let s0, s1, s2, s3;

		s0 = peg$currPos;
		s1 = peg$parse_();
		s2 = peg$parseCompoundExpr();
		if (s2 !== peg$FAILED) {
			s3 = peg$parse_();
			peg$savedPos = s0;
			s0 = peg$f1(s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parseCompoundExpr() {
		let s0, s1, s2, s3, s4, s5, s6;

		s0 = peg$currPos;
		s1 = peg$parseRelExpr();
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			s3 = peg$currPos;
			s4 = peg$parse_();
			if (input.substr(peg$currPos, 2) === peg$c0) {
				s5 = peg$c0;
				peg$currPos += 2;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e0);
				}
			}
			if (s5 === peg$FAILED) {
				if (input.substr(peg$currPos, 2) === peg$c1) {
					s5 = peg$c1;
					peg$currPos += 2;
				} else {
					s5 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e1);
					}
				}
			}
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s4 = [s4, s5, s6];
				s3 = s4;
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			if (s3 === peg$FAILED) {
				s3 = peg$currPos;
				s4 = peg$parse__();
				if (s4 !== peg$FAILED) {
					s5 = peg$parseand();
					if (s5 === peg$FAILED) {
						s5 = peg$parseor();
					}
					if (s5 !== peg$FAILED) {
						s6 = peg$parse__();
						if (s6 !== peg$FAILED) {
							s4 = [s4, s5, s6];
							s3 = s4;
						} else {
							peg$currPos = s3;
							s3 = peg$FAILED;
						}
					} else {
						peg$currPos = s3;
						s3 = peg$FAILED;
					}
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			}
			if (s3 !== peg$FAILED) {
				s4 = peg$parseCompoundExpr();
				if (s4 !== peg$FAILED) {
					peg$savedPos = s2;
					s2 = peg$f2(s1, s3, s4);
				} else {
					peg$currPos = s2;
					s2 = peg$FAILED;
				}
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 === peg$FAILED) {
				s2 = null;
			}
			peg$savedPos = s0;
			s0 = peg$f3(s1, s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parseRelExpr() {
		let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;

		s0 = peg$currPos;
		if (input.charCodeAt(peg$currPos) === 40) {
			s1 = peg$c2;
			peg$currPos++;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e2);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$parseExpr();
			if (s2 !== peg$FAILED) {
				if (input.charCodeAt(peg$currPos) === 41) {
					s3 = peg$c3;
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e3);
					}
				}
				if (s3 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f4(s2);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.charCodeAt(peg$currPos) === 33) {
				s1 = peg$c4;
				peg$currPos++;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e4);
				}
			}
			if (s1 !== peg$FAILED) {
				s2 = peg$parseRelExpr();
				if (s2 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f5(s2);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
			if (s0 === peg$FAILED) {
				s0 = peg$currPos;
				s1 = peg$parseField();
				if (s1 !== peg$FAILED) {
					s2 = peg$parse__();
					if (s2 !== peg$FAILED) {
						if (input.substr(peg$currPos, 7) === peg$c5) {
							s3 = peg$c5;
							peg$currPos += 7;
						} else {
							s3 = peg$FAILED;
							if (peg$silentFails === 0) {
								peg$fail(peg$e5);
							}
						}
						if (s3 !== peg$FAILED) {
							s4 = peg$parse__();
							if (s4 !== peg$FAILED) {
								s5 = peg$parseliteral();
								if (s5 !== peg$FAILED) {
									s6 = peg$parse__();
									if (s6 !== peg$FAILED) {
										if (input.substr(peg$currPos, 3) === peg$c6) {
											s7 = peg$c6;
											peg$currPos += 3;
										} else {
											s7 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$e6);
											}
										}
										if (s7 !== peg$FAILED) {
											s8 = peg$parse__();
											if (s8 !== peg$FAILED) {
												s9 = peg$parseliteral();
												if (s9 !== peg$FAILED) {
													peg$savedPos = s0;
													s0 = peg$f6(s1, s5, s9);
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
							} else {
								peg$currPos = s0;
								s0 = peg$FAILED;
							}
						} else {
							peg$currPos = s0;
							s0 = peg$FAILED;
						}
					} else {
						peg$currPos = s0;
						s0 = peg$FAILED;
					}
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
				if (s0 === peg$FAILED) {
					s0 = peg$currPos;
					s1 = peg$parseField();
					if (s1 !== peg$FAILED) {
						s2 = peg$parse_();
						if (input.substr(peg$currPos, 2) === peg$c7) {
							s3 = peg$c7;
							peg$currPos += 2;
						} else {
							s3 = peg$FAILED;
							if (peg$silentFails === 0) {
								peg$fail(peg$e7);
							}
						}
						if (s3 === peg$FAILED) {
							if (input.substr(peg$currPos, 2) === peg$c8) {
								s3 = peg$c8;
								peg$currPos += 2;
							} else {
								s3 = peg$FAILED;
								if (peg$silentFails === 0) {
									peg$fail(peg$e8);
								}
							}
							if (s3 === peg$FAILED) {
								if (input.substr(peg$currPos, 2) === peg$c9) {
									s3 = peg$c9;
									peg$currPos += 2;
								} else {
									s3 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$e9);
									}
								}
								if (s3 === peg$FAILED) {
									s3 = input.charAt(peg$currPos);
									if (peg$r0.test(s3)) {
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$e10);
										}
									}
									if (s3 === peg$FAILED) {
										if (input.substr(peg$currPos, 3) === peg$c10) {
											s3 = peg$c10;
											peg$currPos += 3;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$e11);
											}
										}
										if (s3 === peg$FAILED) {
											if (input.substr(peg$currPos, 2) === peg$c11) {
												s3 = peg$c11;
												peg$currPos += 2;
											} else {
												s3 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$e12);
												}
											}
											if (s3 === peg$FAILED) {
												if (input.substr(peg$currPos, 2) === peg$c12) {
													s3 = peg$c12;
													peg$currPos += 2;
												} else {
													s3 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$e13);
													}
												}
												if (s3 === peg$FAILED) {
													s3 = input.charAt(peg$currPos);
													if (peg$r1.test(s3)) {
														peg$currPos++;
													} else {
														s3 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$e14);
														}
													}
												}
											}
										}
									}
								}
							}
						}
						if (s3 !== peg$FAILED) {
							s4 = peg$parse_();
							s5 = peg$parseliteral();
							if (s5 !== peg$FAILED) {
								peg$savedPos = s0;
								s0 = peg$f7(s1, s3, s5);
							} else {
								peg$currPos = s0;
								s0 = peg$FAILED;
							}
						} else {
							peg$currPos = s0;
							s0 = peg$FAILED;
						}
					} else {
						peg$currPos = s0;
						s0 = peg$FAILED;
					}
					if (s0 === peg$FAILED) {
						s0 = peg$currPos;
						s1 = peg$parseField();
						if (s1 !== peg$FAILED) {
							s2 = peg$parse_();
							if (input.substr(peg$currPos, 2) === peg$c13) {
								s3 = peg$c13;
								peg$currPos += 2;
							} else {
								s3 = peg$FAILED;
								if (peg$silentFails === 0) {
									peg$fail(peg$e15);
								}
							}
							if (s3 === peg$FAILED) {
								if (input.substr(peg$currPos, 2) === peg$c14) {
									s3 = peg$c14;
									peg$currPos += 2;
								} else {
									s3 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$e16);
									}
								}
								if (s3 === peg$FAILED) {
									if (input.substr(peg$currPos, 2) === peg$c0) {
										s3 = peg$c0;
										peg$currPos += 2;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$e0);
										}
									}
								}
							}
							if (s3 !== peg$FAILED) {
								s4 = peg$parse_();
								s5 = peg$parseArray();
								if (s5 !== peg$FAILED) {
									peg$savedPos = s0;
									s0 = peg$f8(s1, s3, s5);
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
							} else {
								peg$currPos = s0;
								s0 = peg$FAILED;
							}
						} else {
							peg$currPos = s0;
							s0 = peg$FAILED;
						}
						if (s0 === peg$FAILED) {
							s0 = peg$currPos;
							s1 = peg$parseField();
							if (s1 !== peg$FAILED) {
								s2 = peg$parse_();
								if (input.charCodeAt(peg$currPos) === 126) {
									s3 = peg$c15;
									peg$currPos++;
								} else {
									s3 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$e17);
									}
								}
								if (s3 !== peg$FAILED) {
									s4 = peg$parse_();
									s5 = peg$parsestring();
									if (s5 !== peg$FAILED) {
										peg$savedPos = s0;
										s0 = peg$f9(s1, s3, s5);
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
							} else {
								peg$currPos = s0;
								s0 = peg$FAILED;
							}
							if (s0 === peg$FAILED) {
								s0 = peg$currPos;
								s1 = peg$parseField();
								if (s1 !== peg$FAILED) {
									s2 = peg$parse__();
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseis();
										if (s4 !== peg$FAILED) {
											s5 = peg$parse__();
											if (s5 !== peg$FAILED) {
												s6 = peg$parsenull();
												if (s6 !== peg$FAILED) {
													s4 = [s4, s5, s6];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s0 = peg$f10(s1, s3);
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseField();
									if (s1 !== peg$FAILED) {
										s2 = peg$parse__();
										if (s2 !== peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$parseis();
											if (s4 !== peg$FAILED) {
												s5 = peg$parse__();
												if (s5 !== peg$FAILED) {
													s6 = peg$parsenot();
													if (s6 !== peg$FAILED) {
														s7 = peg$parse__();
														if (s7 !== peg$FAILED) {
															s8 = peg$parsenull();
															if (s8 !== peg$FAILED) {
																s4 = [s4, s5, s6, s7, s8];
																s3 = s4;
															} else {
																peg$currPos = s3;
																s3 = peg$FAILED;
															}
														} else {
															peg$currPos = s3;
															s3 = peg$FAILED;
														}
													} else {
														peg$currPos = s3;
														s3 = peg$FAILED;
													}
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
											if (s3 !== peg$FAILED) {
												peg$savedPos = s0;
												s0 = peg$f11(s1, s3);
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseField();
										if (s1 !== peg$FAILED) {
											s2 = peg$parse__();
											if (s2 !== peg$FAILED) {
												s3 = peg$currPos;
												s4 = peg$currPos;
												s5 = peg$parsenot();
												if (s5 !== peg$FAILED) {
													s6 = peg$parse__();
													if (s6 !== peg$FAILED) {
														s5 = [s5, s6];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
												if (s4 === peg$FAILED) {
													s4 = null;
												}
												s5 = peg$parsein();
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
												if (s3 !== peg$FAILED) {
													s4 = peg$parse__();
													if (s4 !== peg$FAILED) {
														s5 = peg$parseArray();
														if (s5 !== peg$FAILED) {
															peg$savedPos = s0;
															s0 = peg$f12(s1, s3, s5);
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseField();
											if (s1 !== peg$FAILED) {
												s2 = peg$parse__();
												if (s2 !== peg$FAILED) {
													s3 = peg$currPos;
													s4 = peg$currPos;
													s5 = peg$parsenot();
													if (s5 !== peg$FAILED) {
														s6 = peg$parse__();
														if (s6 !== peg$FAILED) {
															s5 = [s5, s6];
															s4 = s5;
														} else {
															peg$currPos = s4;
															s4 = peg$FAILED;
														}
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
													if (s4 === peg$FAILED) {
														s4 = null;
													}
													s5 = peg$parselike();
													if (s5 === peg$FAILED) {
														s5 = peg$parseilike();
													}
													if (s5 !== peg$FAILED) {
														s4 = [s4, s5];
														s3 = s4;
													} else {
														peg$currPos = s3;
														s3 = peg$FAILED;
													}
													if (s3 !== peg$FAILED) {
														s4 = peg$parse__();
														if (s4 !== peg$FAILED) {
															s5 = peg$parsestring();
															if (s5 !== peg$FAILED) {
																peg$savedPos = s0;
																s0 = peg$f13(s1, s3, s5);
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}

		return s0;
	}

	function peg$parseField() {
		let s0;

		s0 = peg$parseref();
		if (s0 === peg$FAILED) {
			s0 = peg$parsename();
		}

		return s0;
	}

	function peg$parseValues() {
		let s0, s1, s2, s3, s4, s5, s6;

		s0 = peg$currPos;
		s1 = [];
		s2 = peg$parseliteral();
		while (s2 !== peg$FAILED) {
			s1.push(s2);
			s2 = peg$currPos;
			s3 = peg$currPos;
			s4 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 44) {
				s5 = peg$c16;
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e18);
				}
			}
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s4 = [s4, s5, s6];
				s3 = s4;
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			if (s3 !== peg$FAILED) {
				s3 = peg$parseliteral();
				if (s3 === peg$FAILED) {
					peg$currPos = s2;
					s2 = peg$FAILED;
				} else {
					s2 = s3;
				}
			} else {
				s2 = s3;
			}
		}
		s2 = peg$parse_();
		if (input.charCodeAt(peg$currPos) === 44) {
			s3 = peg$c16;
			peg$currPos++;
		} else {
			s3 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e18);
			}
		}
		if (s3 === peg$FAILED) {
			s3 = null;
		}
		peg$savedPos = s0;
		s0 = peg$f14(s1);

		return s0;
	}

	function peg$parseArray() {
		let s0, s1, s2, s3, s4, s5;

		s0 = peg$currPos;
		if (input.charCodeAt(peg$currPos) === 91) {
			s1 = peg$c17;
			peg$currPos++;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e19);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseValues();
			s4 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 93) {
				s5 = peg$c18;
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e20);
				}
			}
			if (s5 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f15(s3);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.charCodeAt(peg$currPos) === 40) {
				s1 = peg$c2;
				peg$currPos++;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e2);
				}
			}
			if (s1 !== peg$FAILED) {
				s2 = peg$parse_();
				s3 = peg$parseValues();
				s4 = peg$parse_();
				if (input.charCodeAt(peg$currPos) === 41) {
					s5 = peg$c3;
					peg$currPos++;
				} else {
					s5 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e3);
					}
				}
				if (s5 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f16(s3);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		}

		return s0;
	}

	function peg$parseref() {
		let s0, s1, s2, s3, s4, s5, s6, s7;

		s0 = peg$currPos;
		s1 = peg$currPos;
		s2 = [];
		s3 = peg$parsename();
		while (s3 !== peg$FAILED) {
			s2.push(s3);
			s3 = peg$currPos;
			s4 = peg$currPos;
			s5 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 46) {
				s6 = peg$c19;
				peg$currPos++;
			} else {
				s6 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e21);
				}
			}
			if (s6 !== peg$FAILED) {
				s7 = peg$parse_();
				s5 = [s5, s6, s7];
				s4 = s5;
			} else {
				peg$currPos = s4;
				s4 = peg$FAILED;
			}
			if (s4 !== peg$FAILED) {
				s4 = peg$parsename();
				if (s4 === peg$FAILED) {
					peg$currPos = s3;
					s3 = peg$FAILED;
				} else {
					s3 = s4;
				}
			} else {
				s3 = s4;
			}
		}
		if (s2.length < 1) {
			peg$currPos = s1;
			s1 = peg$FAILED;
		} else {
			s1 = s2;
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f17(s1);
		}
		s0 = s1;

		return s0;
	}

	function peg$parsename() {
		let s0, s1, s2, s3, s4;

		s0 = peg$currPos;
		s1 = peg$currPos;
		s2 = input.charAt(peg$currPos);
		if (peg$r2.test(s2)) {
			peg$currPos++;
		} else {
			s2 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e22);
			}
		}
		if (s2 !== peg$FAILED) {
			s3 = [];
			s4 = input.charAt(peg$currPos);
			if (peg$r3.test(s4)) {
				peg$currPos++;
			} else {
				s4 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e23);
				}
			}
			while (s4 !== peg$FAILED) {
				s3.push(s4);
				s4 = input.charAt(peg$currPos);
				if (peg$r3.test(s4)) {
					peg$currPos++;
				} else {
					s4 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e23);
					}
				}
			}
			s2 = [s2, s3];
			s1 = s2;
		} else {
			peg$currPos = s1;
			s1 = peg$FAILED;
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f18();
		}
		s0 = s1;

		return s0;
	}

	function peg$parsein() {
		let s0, s1;

		if (input.substr(peg$currPos, 2) === peg$c20) {
			s0 = peg$c20;
			peg$currPos += 2;
		} else {
			s0 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e24);
			}
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.substr(peg$currPos, 2) === peg$c21) {
				s1 = peg$c21;
				peg$currPos += 2;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e25);
				}
			}
			if (s1 !== peg$FAILED) {
				peg$savedPos = s0;
				s1 = peg$f19();
			}
			s0 = s1;
		}

		return s0;
	}

	function peg$parseis() {
		let s0, s1;

		if (input.substr(peg$currPos, 2) === peg$c22) {
			s0 = peg$c22;
			peg$currPos += 2;
		} else {
			s0 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e26);
			}
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.substr(peg$currPos, 2) === peg$c23) {
				s1 = peg$c23;
				peg$currPos += 2;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e27);
				}
			}
			if (s1 !== peg$FAILED) {
				peg$savedPos = s0;
				s1 = peg$f20();
			}
			s0 = s1;
		}

		return s0;
	}

	function peg$parselike() {
		let s0, s1;

		if (input.substr(peg$currPos, 4) === peg$c24) {
			s0 = peg$c24;
			peg$currPos += 4;
		} else {
			s0 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e28);
			}
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.substr(peg$currPos, 4) === peg$c25) {
				s1 = peg$c25;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e29);
				}
			}
			if (s1 !== peg$FAILED) {
				peg$savedPos = s0;
				s1 = peg$f21();
			}
			s0 = s1;
		}

		return s0;
	}

	function peg$parseilike() {
		let s0, s1;

		if (input.substr(peg$currPos, 5) === peg$c26) {
			s0 = peg$c26;
			peg$currPos += 5;
		} else {
			s0 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e30);
			}
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.substr(peg$currPos, 5) === peg$c27) {
				s1 = peg$c27;
				peg$currPos += 5;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e31);
				}
			}
			if (s1 !== peg$FAILED) {
				peg$savedPos = s0;
				s1 = peg$f22();
			}
			s0 = s1;
		}

		return s0;
	}

	function peg$parseand() {
		let s0, s1;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 3) === peg$c6) {
			s1 = peg$c6;
			peg$currPos += 3;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e6);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 3) === peg$c28) {
				s1 = peg$c28;
				peg$currPos += 3;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e32);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f23();
		}
		s0 = s1;

		return s0;
	}

	function peg$parsenot() {
		let s0, s1;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 3) === peg$c29) {
			s1 = peg$c29;
			peg$currPos += 3;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e33);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 3) === peg$c30) {
				s1 = peg$c30;
				peg$currPos += 3;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e34);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f24();
		}
		s0 = s1;

		return s0;
	}

	function peg$parseor() {
		let s0, s1;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 2) === peg$c31) {
			s1 = peg$c31;
			peg$currPos += 2;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e35);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 2) === peg$c32) {
				s1 = peg$c32;
				peg$currPos += 2;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e36);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f25();
		}
		s0 = s1;

		return s0;
	}

	function peg$parseliteral() {
		let s0;

		s0 = peg$parsestring();
		if (s0 === peg$FAILED) {
			s0 = peg$parsefloat();
			if (s0 === peg$FAILED) {
				s0 = peg$parseint();
				if (s0 === peg$FAILED) {
					s0 = peg$parsebool();
					if (s0 === peg$FAILED) {
						s0 = peg$parsenull();
					}
				}
			}
		}

		return s0;
	}

	function peg$parseint() {
		let s0, s1, s2;

		s0 = peg$currPos;
		s1 = [];
		s2 = input.charAt(peg$currPos);
		if (peg$r4.test(s2)) {
			peg$currPos++;
		} else {
			s2 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e37);
			}
		}
		if (s2 !== peg$FAILED) {
			while (s2 !== peg$FAILED) {
				s1.push(s2);
				s2 = input.charAt(peg$currPos);
				if (peg$r4.test(s2)) {
					peg$currPos++;
				} else {
					s2 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e37);
					}
				}
			}
		} else {
			s1 = peg$FAILED;
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f26();
		}
		s0 = s1;

		return s0;
	}

	function peg$parsefloat() {
		let s0, s1, s2, s3, s4;

		s0 = peg$currPos;
		s1 = [];
		s2 = input.charAt(peg$currPos);
		if (peg$r4.test(s2)) {
			peg$currPos++;
		} else {
			s2 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e37);
			}
		}
		if (s2 !== peg$FAILED) {
			while (s2 !== peg$FAILED) {
				s1.push(s2);
				s2 = input.charAt(peg$currPos);
				if (peg$r4.test(s2)) {
					peg$currPos++;
				} else {
					s2 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e37);
					}
				}
			}
		} else {
			s1 = peg$FAILED;
		}
		if (s1 !== peg$FAILED) {
			if (input.charCodeAt(peg$currPos) === 46) {
				s2 = peg$c19;
				peg$currPos++;
			} else {
				s2 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e21);
				}
			}
			if (s2 !== peg$FAILED) {
				s3 = [];
				s4 = input.charAt(peg$currPos);
				if (peg$r4.test(s4)) {
					peg$currPos++;
				} else {
					s4 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e37);
					}
				}
				if (s4 !== peg$FAILED) {
					while (s4 !== peg$FAILED) {
						s3.push(s4);
						s4 = input.charAt(peg$currPos);
						if (peg$r4.test(s4)) {
							peg$currPos++;
						} else {
							s4 = peg$FAILED;
							if (peg$silentFails === 0) {
								peg$fail(peg$e37);
							}
						}
					}
				} else {
					s3 = peg$FAILED;
				}
				if (s3 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f27();
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parsestring() {
		let s0, s1, s2, s3;

		s0 = peg$currPos;
		if (input.charCodeAt(peg$currPos) === 39) {
			s1 = peg$c33;
			peg$currPos++;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e38);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = input.charAt(peg$currPos);
			if (peg$r5.test(s3)) {
				peg$currPos++;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e39);
				}
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = input.charAt(peg$currPos);
				if (peg$r5.test(s3)) {
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e39);
					}
				}
			}
			if (input.charCodeAt(peg$currPos) === 39) {
				s3 = peg$c33;
				peg$currPos++;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e38);
				}
			}
			if (s3 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f28(s2);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.charCodeAt(peg$currPos) === 34) {
				s1 = peg$c34;
				peg$currPos++;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e40);
				}
			}
			if (s1 !== peg$FAILED) {
				s2 = [];
				s3 = input.charAt(peg$currPos);
				if (peg$r6.test(s3)) {
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e41);
					}
				}
				while (s3 !== peg$FAILED) {
					s2.push(s3);
					s3 = input.charAt(peg$currPos);
					if (peg$r6.test(s3)) {
						peg$currPos++;
					} else {
						s3 = peg$FAILED;
						if (peg$silentFails === 0) {
							peg$fail(peg$e41);
						}
					}
				}
				if (input.charCodeAt(peg$currPos) === 34) {
					s3 = peg$c34;
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e40);
					}
				}
				if (s3 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f29(s2);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		}

		return s0;
	}

	function peg$parsenull() {
		let s0, s1;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c35) {
			s1 = peg$c35;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e42);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c36) {
				s1 = peg$c36;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e43);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f30();
		}
		s0 = s1;

		return s0;
	}

	function peg$parsebool() {
		let s0, s1;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c37) {
			s1 = peg$c37;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e44);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 5) === peg$c38) {
				s1 = peg$c38;
				peg$currPos += 5;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e45);
				}
			}
			if (s1 === peg$FAILED) {
				if (input.substr(peg$currPos, 4) === peg$c39) {
					s1 = peg$c39;
					peg$currPos += 4;
				} else {
					s1 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e46);
					}
				}
				if (s1 === peg$FAILED) {
					if (input.substr(peg$currPos, 5) === peg$c40) {
						s1 = peg$c40;
						peg$currPos += 5;
					} else {
						s1 = peg$FAILED;
						if (peg$silentFails === 0) {
							peg$fail(peg$e47);
						}
					}
				}
			}
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f31();
		}
		s0 = s1;

		return s0;
	}

	function peg$parse_() {
		let s0, s1, s2;

		peg$silentFails++;
		s0 = peg$currPos;
		s1 = [];
		s2 = peg$parsewhite();
		while (s2 !== peg$FAILED) {
			s1.push(s2);
			s2 = peg$parsewhite();
		}
		peg$savedPos = s0;
		s1 = peg$f32();
		s0 = s1;
		peg$silentFails--;

		return s0;
	}

	function peg$parse__() {
		let s0, s1, s2;

		peg$silentFails++;
		s0 = peg$currPos;
		s1 = [];
		s2 = peg$parsewhite();
		if (s2 !== peg$FAILED) {
			while (s2 !== peg$FAILED) {
				s1.push(s2);
				s2 = peg$parsewhite();
			}
		} else {
			s1 = peg$FAILED;
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f33();
		}
		s0 = s1;
		peg$silentFails--;
		if (s0 === peg$FAILED) {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e48);
			}
		}

		return s0;
	}

	function peg$parsewhite() {
		let s0, s1, s2, s3;

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 2) === peg$c41) {
			s1 = peg$c41;
			peg$currPos += 2;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e49);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = input.charAt(peg$currPos);
			if (peg$r7.test(s3)) {
				peg$currPos++;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e50);
				}
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = input.charAt(peg$currPos);
				if (peg$r7.test(s3)) {
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e50);
					}
				}
			}
			if (input.substr(peg$currPos, 2) === peg$c42) {
				s3 = peg$c42;
				peg$currPos += 2;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e51);
				}
			}
			if (s3 !== peg$FAILED) {
				s1 = [s1, s2, s3];
				s0 = s1;
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			if (input.substr(peg$currPos, 2) === peg$c43) {
				s1 = peg$c43;
				peg$currPos += 2;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e52);
				}
			}
			if (s1 !== peg$FAILED) {
				s2 = [];
				s3 = input.charAt(peg$currPos);
				if (peg$r8.test(s3)) {
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e53);
					}
				}
				while (s3 !== peg$FAILED) {
					s2.push(s3);
					s3 = input.charAt(peg$currPos);
					if (peg$r8.test(s3)) {