@wener/miniquery/src/ast/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 OPS = {
	'!': 'NOT',
	'&&': 'AND',
	'||': 'OR',
	'==': '=',
	'===': '=',
};

const KEYWORDS = new Set([
	'FALSE',
	'NULL',
	'TRUE',
	'AND',
	'AS',
	'BETWEEN',
	'CASE',
	'ELSE',
	'END',
	'ILIKE',
	'IN',
	'IS',
	'LIKE',
	'LIKE',
	'NOT',
	'OR',
	'RLIKE',
	'THEN',
	'WHEN',
]);

function _op(op) {
	let s = Array.isArray(op)
		? op
				.flat()
				.filter((v) => v && v.trim())
				.join(' ')
		: op;
	s = s.toUpperCase();
	return OPS[s] || s;
}

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 = '[';
	const peg$c6 = ']';
	const peg$c7 = '.';
	const peg$c8 = 'case';
	const peg$c9 = 'CASE';
	const peg$c10 = 'when';
	const peg$c11 = 'WHEN';
	const peg$c12 = 'then';
	const peg$c13 = 'THEN';
	const peg$c14 = 'else';
	const peg$c15 = 'ELSE';
	const peg$c16 = 'end';
	const peg$c17 = 'END';
	const peg$c18 = 'in';
	const peg$c19 = 'IN';
	const peg$c20 = 'is';
	const peg$c21 = 'IS';
	const peg$c22 = 'like';
	const peg$c23 = 'LIKE';
	const peg$c24 = 'between';
	const peg$c25 = 'BETWEEN';
	const peg$c26 = 'and';
	const peg$c27 = 'AND';
	const peg$c28 = '&&';
	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 = '"';
	const peg$c36 = 'null';
	const peg$c37 = 'NULL';
	const peg$c38 = 'true';
	const peg$c39 = 'false';
	const peg$c40 = 'TRUE';
	const peg$c41 = 'FALSE';
	const peg$c42 = '>=';
	const peg$c43 = '<=';
	const peg$c44 = '<>';
	const peg$c45 = '==';
	const peg$c46 = '!=';
	const peg$c47 = '@>';
	const peg$c48 = '<@';
	const peg$c49 = '~';
	const peg$c50 = '/*';
	const peg$c51 = '*/';
	const peg$c52 = '--';
	const peg$c53 = '\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 = /^[A-Za-z0-9_]/;
	const peg$r9 = /^[^*]/;
	const peg$r10 = /^[^\r\n]/;
	const peg$r11 = /^[ \t\n\r]/;

	const peg$e0 = peg$literalExpectation('!', false);
	const peg$e1 = peg$literalExpectation('=', false);
	const peg$e2 = peg$classExpectation(['+', '-'], false, false, false);
	const peg$e3 = peg$classExpectation(['%', '*', '/'], false, false, false);
	const peg$e4 = peg$literalExpectation('(', false);
	const peg$e5 = peg$literalExpectation(')', false);
	const peg$e6 = peg$literalExpectation(',', false);
	const peg$e7 = peg$literalExpectation('[', false);
	const peg$e8 = peg$literalExpectation(']', false);
	const peg$e9 = peg$literalExpectation('.', false);
	const peg$e10 = peg$classExpectation(
		[
			['a', 'z'],
			['A', 'Z'],
		],
		false,
		false,
		false,
	);
	const peg$e11 = peg$classExpectation(['_', ['a', 'z'], ['A', 'Z'], ['0', '9']], false, false, false);
	const peg$e12 = peg$literalExpectation('case', false);
	const peg$e13 = peg$literalExpectation('CASE', false);
	const peg$e14 = peg$literalExpectation('when', false);
	const peg$e15 = peg$literalExpectation('WHEN', false);
	const peg$e16 = peg$literalExpectation('then', false);
	const peg$e17 = peg$literalExpectation('THEN', false);
	const peg$e18 = peg$literalExpectation('else', false);
	const peg$e19 = peg$literalExpectation('ELSE', false);
	const peg$e20 = peg$literalExpectation('end', false);
	const peg$e21 = peg$literalExpectation('END', false);
	const peg$e22 = peg$literalExpectation('in', false);
	const peg$e23 = peg$literalExpectation('IN', false);
	const peg$e24 = peg$literalExpectation('is', false);
	const peg$e25 = peg$literalExpectation('IS', false);
	const peg$e26 = peg$literalExpectation('like', false);
	const peg$e27 = peg$literalExpectation('LIKE', false);
	const peg$e28 = peg$literalExpectation('between', false);
	const peg$e29 = peg$literalExpectation('BETWEEN', false);
	const peg$e30 = peg$literalExpectation('and', false);
	const peg$e31 = peg$literalExpectation('AND', false);
	const peg$e32 = peg$literalExpectation('&&', 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$literalExpectation('||', false);
	const peg$e38 = peg$classExpectation([['0', '9']], false, false, false);
	const peg$e39 = peg$literalExpectation("'", false);
	const peg$e40 = peg$classExpectation(["'"], true, false, false);
	const peg$e41 = peg$literalExpectation('"', false);
	const peg$e42 = peg$classExpectation(['"'], true, false, false);
	const peg$e43 = peg$literalExpectation('null', false);
	const peg$e44 = peg$literalExpectation('NULL', false);
	const peg$e45 = peg$literalExpectation('true', false);
	const peg$e46 = peg$literalExpectation('false', false);
	const peg$e47 = peg$literalExpectation('TRUE', false);
	const peg$e48 = peg$literalExpectation('FALSE', false);
	const peg$e49 = peg$literalExpectation('>=', false);
	const peg$e50 = peg$literalExpectation('<=', false);
	const peg$e51 = peg$literalExpectation('<>', false);
	const peg$e52 = peg$classExpectation(['<', '>'], false, false, false);
	const peg$e53 = peg$literalExpectation('==', false);
	const peg$e54 = peg$literalExpectation('!=', false);
	const peg$e55 = peg$literalExpectation('@>', false);
	const peg$e56 = peg$literalExpectation('<@', false);
	const peg$e57 = peg$literalExpectation('~', false);
	const peg$e58 = peg$classExpectation([['A', 'Z'], ['a', 'z'], ['0', '9'], '_'], false, false, false);
	const peg$e59 = peg$literalExpectation('/*', false);
	const peg$e60 = peg$classExpectation(['*'], true, false, false);
	const peg$e61 = peg$literalExpectation('*/', false);
	const peg$e62 = peg$literalExpectation('--', false);
	const peg$e63 = peg$classExpectation(['\r', '\n'], true, false, false);
	const peg$e64 = peg$literalExpectation('\n', false);
	const peg$e65 = peg$classExpectation([' ', '\t', '\n', '\r'], false, false, false);
	const peg$e66 = peg$anyExpectation();

	function peg$f0(head, tail) {
		return buildChain(head, tail);
	}
	function peg$f1(head, tail) {
		return buildChain(head, tail);
	}
	function peg$f2(op, expr) {
		return createUnaryExpr(op, expr);
	}
	function peg$f3(left, right) {
		if (right) {
			const { op, right: r, ...rest } = right;
			return { type: 'compare', op, left, right: r, ...rest };
		}
		return left;
	}
	function peg$f4(op, right) {
		return { op: _op(op), right };
	}
	function peg$f5(op, right) {
		return { op: _op(op), right };
	}
	function peg$f6(op, a, b) {
		return { op: _op(op), right: { type: 'list', items: [a, b] } };
	}
	function peg$f7(op, right) {
		return { op: _op(op), right };
	}
	function peg$f8(op, right) {
		return { op: _op(op), right };
	}
	function peg$f9(head, tail) {
		return buildChain(head, tail);
	}
	function peg$f10(head, tail) {
		return buildChain(head, tail);
	}
	function peg$f11(condition, cases, ele) {
		return {
			type: 'case',
			condition,
			cases,
			...(ele ? { else: ele[1] } : {}),
		};
	}
	function peg$f12(when, then) {
		return { when, then };
	}
	function peg$f13(expr) {
		return ['ELSE', expr];
	}
	function peg$f14(name, args) {
		return { type: 'func', name, args: args || [] };
	}
	function peg$f15(a, next) {
		return next;
	}
	function peg$f16(a, b) {
		return b ? [a, ...b] : a;
	}
	function peg$f17(next) {
		return next || [];
	}
	function peg$f18(items) {
		return { type: 'list', items: items || [] };
	}
	function peg$f19(items) {
		return { type: 'list', items: items || [] };
	}
	function peg$f20(a) {
		return { type: 'ref', value: a };
	}
	function peg$f21(name) {
		return KEYWORDS.has(name.toUpperCase());
	}
	function peg$f22(name) {
		return name;
	}
	function peg$f23() {
		return text();
	}
	function peg$f24() {
		return 'CASE';
	}
	function peg$f25() {
		return 'WHEN';
	}
	function peg$f26() {
		return 'THEN';
	}
	function peg$f27() {
		return 'ELSE';
	}
	function peg$f28() {
		return 'END';
	}
	function peg$f29() {
		return 'IN';
	}
	function peg$f30() {
		return 'IS';
	}
	function peg$f31() {
		return 'LIKE';
	}
	function peg$f32() {
		return 'BETWEEN';
	}
	function peg$f33() {
		return 'AND';
	}
	function peg$f34() {
		return 'NOT';
	}
	function peg$f35() {
		return 'OR';
	}
	function peg$f36() {
		return { type: 'literal', value: parseInt(text()) };
	}
	function peg$f37() {
		return { type: 'literal', value: parseFloat(text()) };
	}
	function peg$f38(v) {
		return { type: 'literal', value: v.join('') };
	}
	function peg$f39(v) {
		return { type: 'literal', value: v.join('') };
	}
	function peg$f40() {
		return { type: 'literal', value: null };
	}
	function peg$f41() {
		return { type: 'literal', value: text().toLowerCase() === 'true' };
	}
	function peg$f42() {
		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;

		s0 = peg$parseQueryExpr();

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parseExpr();
		if (s1 !== peg$FAILED) {
			s2 = peg$parseEOF();
			if (s2 !== peg$FAILED) {
				s0 = s1;
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} 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$parseOrExpr();
		if (s2 !== peg$FAILED) {
			s3 = peg$parse_();
			s0 = s2;
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parseAndExpr();
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = peg$currPos;
			s4 = peg$parse_();
			s5 = peg$parseor();
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s7 = peg$parseAndExpr();
				if (s7 !== peg$FAILED) {
					s4 = [s4, s5, s6, s7];
					s3 = s4;
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = peg$currPos;
				s4 = peg$parse_();
				s5 = peg$parseor();
				if (s5 !== peg$FAILED) {
					s6 = peg$parse_();
					s7 = peg$parseAndExpr();
					if (s7 !== peg$FAILED) {
						s4 = [s4, s5, s6, s7];
						s3 = s4;
					} else {
						peg$currPos = s3;
						s3 = peg$FAILED;
					}
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			}
			peg$savedPos = s0;
			s0 = peg$f0(s1, s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parseNotExpr();
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = peg$currPos;
			s4 = peg$parse_();
			s5 = peg$parseand();
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s7 = peg$parseNotExpr();
				if (s7 !== peg$FAILED) {
					s4 = [s4, s5, s6, s7];
					s3 = s4;
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = peg$currPos;
				s4 = peg$parse_();
				s5 = peg$parseand();
				if (s5 !== peg$FAILED) {
					s6 = peg$parse_();
					s7 = peg$parseNotExpr();
					if (s7 !== peg$FAILED) {
						s4 = [s4, s5, s6, s7];
						s3 = s4;
					} else {
						peg$currPos = s3;
						s3 = peg$FAILED;
					}
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			}
			peg$savedPos = s0;
			s0 = peg$f1(s1, s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsenot();
		if (s1 === peg$FAILED) {
			if (input.charCodeAt(peg$currPos) === 33) {
				s1 = peg$c0;
				peg$currPos++;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e0);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			if (input.charCodeAt(peg$currPos) === 61) {
				s3 = peg$c1;
				peg$currPos++;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e1);
				}
			}
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				s3 = peg$parse_();
				s4 = peg$parseNotExpr();
				if (s4 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f2(s1, s4);
				} 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$parseComparisonExpr();
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parseAdditiveExpr();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseComparisonRightExpr();
			if (s3 === peg$FAILED) {
				s3 = null;
			}
			peg$savedPos = s0;
			s0 = peg$f3(s1, s3);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsecomparison_operator();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseAdditiveExpr();
			if (s3 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f4(s1, s3);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}
		if (s0 === peg$FAILED) {
			s0 = peg$currPos;
			s1 = peg$currPos;
			s2 = peg$parsenot();
			if (s2 === peg$FAILED) {
				s2 = null;
			}
			s3 = peg$parse_();
			s4 = peg$parsein();
			if (s4 !== peg$FAILED) {
				s2 = [s2, s3, s4];
				s1 = s2;
			} else {
				peg$currPos = s1;
				s1 = peg$FAILED;
			}
			if (s1 !== peg$FAILED) {
				s2 = peg$parse_();
				s3 = peg$parseList();
				if (s3 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f5(s1, s3);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
			if (s0 === peg$FAILED) {
				s0 = peg$currPos;
				s1 = peg$currPos;
				s2 = peg$parsenot();
				if (s2 === peg$FAILED) {
					s2 = null;
				}
				s3 = peg$parse_();
				s4 = peg$parsebetween();
				if (s4 !== peg$FAILED) {
					s2 = [s2, s3, s4];
					s1 = s2;
				} else {
					peg$currPos = s1;
					s1 = peg$FAILED;
				}
				if (s1 !== peg$FAILED) {
					s2 = peg$parse_();
					s3 = peg$parseValue();
					if (s3 !== peg$FAILED) {
						s4 = peg$parse_();
						s5 = peg$parseand();
						if (s5 !== peg$FAILED) {
							s6 = peg$parse_();
							s7 = peg$parseValue();
							if (s7 !== peg$FAILED) {
								peg$savedPos = s0;
								s0 = peg$f6(s1, s3, s7);
							} 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$currPos;
					s2 = peg$parseis();
					if (s2 !== peg$FAILED) {
						s3 = peg$parse_();
						s4 = peg$parsenot();
						if (s4 === peg$FAILED) {
							s4 = null;
						}
						s2 = [s2, s3, s4];
						s1 = s2;
					} else {
						peg$currPos = s1;
						s1 = peg$FAILED;
					}
					if (s1 !== peg$FAILED) {
						s2 = peg$parse_();
						s3 = peg$parsenull();
						if (s3 === peg$FAILED) {
							s3 = peg$parsebool();
						}
						if (s3 !== peg$FAILED) {
							peg$savedPos = s0;
							s0 = peg$f7(s1, s3);
						} else {
							peg$currPos = s0;
							s0 = peg$FAILED;
						}
					} else {
						peg$currPos = s0;
						s0 = peg$FAILED;
					}
					if (s0 === peg$FAILED) {
						s0 = peg$currPos;
						s1 = peg$currPos;
						s2 = peg$parsenot();
						if (s2 === peg$FAILED) {
							s2 = null;
						}
						s3 = peg$parse_();
						s4 = peg$parselike();
						if (s4 !== peg$FAILED) {
							s2 = [s2, s3, s4];
							s1 = s2;
						} else {
							peg$currPos = s1;
							s1 = peg$FAILED;
						}
						if (s1 !== peg$FAILED) {
							s2 = peg$parse_();
							s3 = peg$parsestring();
							if (s3 !== peg$FAILED) {
								peg$savedPos = s0;
								s0 = peg$f8(s1, s3);
							} else {
								peg$currPos = s0;
								s0 = peg$FAILED;
							}
						} else {
							peg$currPos = s0;
							s0 = peg$FAILED;
						}
					}
				}
			}
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parseMultiplicativeExpr();
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = peg$currPos;
			s4 = peg$parse_();
			s5 = input.charAt(peg$currPos);
			if (peg$r0.test(s5)) {
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e2);
				}
			}
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s7 = peg$parseMultiplicativeExpr();
				if (s7 !== peg$FAILED) {
					s4 = [s4, s5, s6, s7];
					s3 = s4;
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = peg$currPos;
				s4 = peg$parse_();
				s5 = input.charAt(peg$currPos);
				if (peg$r0.test(s5)) {
					peg$currPos++;
				} else {
					s5 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e2);
					}
				}
				if (s5 !== peg$FAILED) {
					s6 = peg$parse_();
					s7 = peg$parseMultiplicativeExpr();
					if (s7 !== peg$FAILED) {
						s4 = [s4, s5, s6, s7];
						s3 = s4;
					} else {
						peg$currPos = s3;
						s3 = peg$FAILED;
					}
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			}
			peg$savedPos = s0;
			s0 = peg$f9(s1, s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsePrimaryExpr();
		if (s1 !== peg$FAILED) {
			s2 = [];
			s3 = peg$currPos;
			s4 = peg$parse_();
			s5 = input.charAt(peg$currPos);
			if (peg$r1.test(s5)) {
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e3);
				}
			}
			if (s5 !== peg$FAILED) {
				s6 = peg$parse_();
				s7 = peg$parsePrimaryExpr();
				if (s7 !== peg$FAILED) {
					s4 = [s4, s5, s6, s7];
					s3 = s4;
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			} else {
				peg$currPos = s3;
				s3 = peg$FAILED;
			}
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = peg$currPos;
				s4 = peg$parse_();
				s5 = input.charAt(peg$currPos);
				if (peg$r1.test(s5)) {
					peg$currPos++;
				} else {
					s5 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e3);
					}
				}
				if (s5 !== peg$FAILED) {
					s6 = peg$parse_();
					s7 = peg$parsePrimaryExpr();
					if (s7 !== peg$FAILED) {
						s4 = [s4, s5, s6, s7];
						s3 = s4;
					} else {
						peg$currPos = s3;
						s3 = peg$FAILED;
					}
				} else {
					peg$currPos = s3;
					s3 = peg$FAILED;
				}
			}
			peg$savedPos = s0;
			s0 = peg$f10(s1, s2);
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		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$e4);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseExpr();
			if (s3 !== peg$FAILED) {
				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$e5);
					}
				}
				if (s5 !== peg$FAILED) {
					s0 = 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$parseCaseExpr();
			if (s0 === peg$FAILED) {
				s0 = peg$parseFunctionCall();
				if (s0 === peg$FAILED) {
					s0 = peg$parseAnyValue();
				}
			}
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsecase();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseExpr();
			if (s3 === peg$FAILED) {
				s3 = null;
			}
			s4 = peg$parse_();
			s5 = [];
			s6 = peg$parseCaseWhenThen();
			if (s6 !== peg$FAILED) {
				while (s6 !== peg$FAILED) {
					s5.push(s6);
					s6 = peg$parseCaseWhenThen();
				}
			} else {
				s5 = peg$FAILED;
			}
			if (s5 !== peg$FAILED) {
				s6 = peg$parseCaseElse();
				if (s6 === peg$FAILED) {
					s6 = null;
				}
				s7 = peg$parse_();
				s8 = peg$parseend();
				if (s8 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f11(s3, s5, s6);
				} 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$parseCaseWhenThen() {
		let s0, s1, s2, s3, s4, s5, s6, s7;

		s0 = peg$currPos;
		s1 = peg$parsewhen();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseExpr();
			if (s3 !== peg$FAILED) {
				s4 = peg$parse_();
				s5 = peg$parsethen();
				if (s5 !== peg$FAILED) {
					s6 = peg$parse_();
					s7 = peg$parseExpr();
					if (s7 !== peg$FAILED) {
						peg$savedPos = s0;
						s0 = peg$f12(s3, s7);
					} 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$parseCaseElse() {
		let s0, s1, s2, s3;

		s0 = peg$currPos;
		s1 = peg$parseelse();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseExpr();
			if (s3 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f13(s3);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsename();
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 40) {
				s3 = peg$c2;
				peg$currPos++;
			} else {
				s3 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e4);
				}
			}
			if (s3 !== peg$FAILED) {
				s4 = peg$parse_();
				s5 = peg$parseValues();
				s6 = peg$parse_();
				if (input.charCodeAt(peg$currPos) === 41) {
					s7 = peg$c3;
					peg$currPos++;
				} else {
					s7 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e5);
					}
				}
				if (s7 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f14(s1, s5);
				} 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$parseValue() {
		let s0;

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

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$currPos;
		s2 = peg$parseValue();
		if (s2 !== peg$FAILED) {
			s3 = peg$parse_();
			s4 = [];
			s5 = peg$currPos;
			s6 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 44) {
				s7 = peg$c4;
				peg$currPos++;
			} else {
				s7 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e6);
				}
			}
			if (s7 !== peg$FAILED) {
				s8 = peg$parse_();
				s9 = peg$parseValue();
				if (s9 !== peg$FAILED) {
					peg$savedPos = s5;
					s5 = peg$f15(s2, s9);
				} else {
					peg$currPos = s5;
					s5 = peg$FAILED;
				}
			} else {
				peg$currPos = s5;
				s5 = peg$FAILED;
			}
			while (s5 !== peg$FAILED) {
				s4.push(s5);
				s5 = peg$currPos;
				s6 = peg$parse_();
				if (input.charCodeAt(peg$currPos) === 44) {
					s7 = peg$c4;
					peg$currPos++;
				} else {
					s7 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e6);
					}
				}
				if (s7 !== peg$FAILED) {
					s8 = peg$parse_();
					s9 = peg$parseValue();
					if (s9 !== peg$FAILED) {
						peg$savedPos = s5;
						s5 = peg$f15(s2, s9);
					} else {
						peg$currPos = s5;
						s5 = peg$FAILED;
					}
				} else {
					peg$currPos = s5;
					s5 = peg$FAILED;
				}
			}
			if (input.charCodeAt(peg$currPos) === 44) {
				s5 = peg$c4;
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e6);
				}
			}
			if (s5 === peg$FAILED) {
				s5 = null;
			}
			peg$savedPos = s1;
			s1 = peg$f16(s2, s4);
		} else {
			peg$currPos = s1;
			s1 = peg$FAILED;
		}
		if (s1 === peg$FAILED) {
			s1 = null;
		}
		peg$savedPos = s0;
		s1 = peg$f17(s1);
		s0 = s1;

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.charCodeAt(peg$currPos) === 91) {
			s1 = peg$c5;
			peg$currPos++;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e7);
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$parse_();
			s3 = peg$parseValues();
			s4 = peg$parse_();
			if (input.charCodeAt(peg$currPos) === 93) {
				s5 = peg$c6;
				peg$currPos++;
			} else {
				s5 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e8);
				}
			}
			if (s5 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f18(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$e4);
				}
			}
			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$e5);
					}
				}
				if (s5 !== peg$FAILED) {
					peg$savedPos = s0;
					s0 = peg$f19(s3);
				} else {
					peg$currPos = s0;
					s0 = peg$FAILED;
				}
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		}

		return s0;
	}

	function peg$parseAnyValue() {
		let s0;

		s0 = peg$parseList();
		if (s0 === peg$FAILED) {
			s0 = peg$parseValue();
		}

		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$c7;
				peg$currPos++;
			} else {
				s6 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e9);
				}
			}
			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$f20(s1);
		}
		s0 = s1;

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = peg$parsebare_name();
		if (s1 !== peg$FAILED) {
			peg$savedPos = peg$currPos;
			s2 = peg$f21(s1);
			if (s2) {
				s2 = peg$FAILED;
			} else {
				s2 = undefined;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f22(s1);
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

	function peg$parsebare_name() {
		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$e10);
			}
		}
		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$e11);
				}
			}
			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$e11);
					}
				}
			}
			s2 = [s2, s3];
			s1 = s2;
		} else {
			peg$currPos = s1;
			s1 = peg$FAILED;
		}
		if (s1 !== peg$FAILED) {
			peg$savedPos = s0;
			s1 = peg$f23();
		}
		s0 = s1;

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c8) {
			s1 = peg$c8;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e12);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c9) {
				s1 = peg$c9;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e13);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f24();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c10) {
			s1 = peg$c10;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e14);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c11) {
				s1 = peg$c11;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e15);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f25();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c12) {
			s1 = peg$c12;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e16);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c13) {
				s1 = peg$c13;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e17);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f26();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c14) {
			s1 = peg$c14;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e18);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c15) {
				s1 = peg$c15;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e19);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f27();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 3) === peg$c16) {
			s1 = peg$c16;
			peg$currPos += 3;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e20);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 3) === peg$c17) {
				s1 = peg$c17;
				peg$currPos += 3;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e21);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f28();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 2) === peg$c18) {
			s1 = peg$c18;
			peg$currPos += 2;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e22);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 2) === peg$c19) {
				s1 = peg$c19;
				peg$currPos += 2;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e23);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f29();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 2) === peg$c20) {
			s1 = peg$c20;
			peg$currPos += 2;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e24);
			}
		}
		if (s1 === peg$FAILED) {
			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) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f30();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 4) === peg$c22) {
			s1 = peg$c22;
			peg$currPos += 4;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e26);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 4) === peg$c23) {
				s1 = peg$c23;
				peg$currPos += 4;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e27);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f31();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 7) === peg$c24) {
			s1 = peg$c24;
			peg$currPos += 7;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e28);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 7) === peg$c25) {
				s1 = peg$c25;
				peg$currPos += 7;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e29);
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f32();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		if (input.substr(peg$currPos, 3) === peg$c26) {
			s1 = peg$c26;
			peg$currPos += 3;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e30);
			}
		}
		if (s1 === peg$FAILED) {
			if (input.substr(peg$currPos, 3) === peg$c27) {
				s1 = peg$c27;
				peg$currPos += 3;
			} else {
				s1 = peg$FAILED;
				if (peg$silentFails === 0) {
					peg$fail(peg$e31);
				}
			}
			if (s1 === peg$FAILED) {
				if (input.substr(peg$currPos, 2) === peg$c28) {
					s1 = peg$c28;
					peg$currPos += 2;
				} else {
					s1 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e32);
					}
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f33();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		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) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f34();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		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) {
				if (input.substr(peg$currPos, 2) === peg$c33) {
					s1 = peg$c33;
					peg$currPos += 2;
				} else {
					s1 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e37);
					}
				}
			}
		}
		if (s1 !== peg$FAILED) {
			s2 = peg$currPos;
			peg$silentFails++;
			s3 = peg$parseidentifier_start();
			peg$silentFails--;
			if (s3 === peg$FAILED) {
				s2 = undefined;
			} else {
				peg$currPos = s2;
				s2 = peg$FAILED;
			}
			if (s2 !== peg$FAILED) {
				peg$savedPos = s0;
				s0 = peg$f35();
			} else {
				peg$currPos = s0;
				s0 = peg$FAILED;
			}
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		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, s3;

		s0 = peg$currPos;
		s1 = input.charAt(peg$currPos);
		if (peg$r0.test(s1)) {
			peg$currPos++;
		} else {
			s1 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e2);
			}
		}
		if (s1 === peg$FAILED) {
			s1 = null;
		}
		s2 = [];
		s3 = input.charAt(peg$currPos);
		if (peg$r4.test(s3)) {
			peg$currPos++;
		} else {
			s3 = peg$FAILED;
			if (peg$silentFails === 0) {
				peg$fail(peg$e38);
			}
		}
		if (s3 !== peg$FAILED) {
			while (s3 !== peg$FAILED) {
				s2.push(s3);
				s3 = input.charAt(peg$currPos);
				if (peg$r4.test(s3)) {
					peg$currPos++;
				} else {
					s3 = peg$FAILED;
					if (peg$silentFails === 0) {
						peg$fail(peg$e38);
					}
				}
			}
		} else {
			s2 = peg$FAILED;
		}
		if (s2 !== peg$FAILED) {
			peg$savedPos = s0;
			s0 = peg$f36();
		} else {
			peg$currPos = s0;
			s0 = peg$FAILED;
		}

		return s0;
	}

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

		s0 = peg$currPos;
		s1 = input.charAt(peg$currPos);
		if (peg$r0.test(s1)) {
			peg$currP