@opra/common 0.5.0 → 0.6.0

package/cjs/filter/antlr/OpraFilterVisitor.js

@@ -0,0 +1,3 @@
+"use strict";
+// Generated from ../antlr/OpraFilter.g4 by ANTLR 4.9.0-SNAPSHOT
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/filter/ast/abstract/ast.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ast = void 0;
+class Ast {
+    kind;
+    constructor() {
+        this.kind = Object.getPrototypeOf(this).constructor.name;
+    }
+}
+exports.Ast = Ast;

package/cjs/filter/ast/abstract/expression.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expression = void 0;
+const ast_js_1 = require("./ast.js");
+class Expression extends ast_js_1.Ast {
+}
+exports.Expression = Expression;

package/cjs/filter/ast/abstract/literal.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Literal = void 0;
+const term_js_1 = require("./term.js");
+class Literal extends term_js_1.Term {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return '' + this.value;
+    }
+}
+exports.Literal = Literal;

package/cjs/filter/ast/abstract/term.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Term = void 0;
+const expression_js_1 = require("./expression.js");
+class Term extends expression_js_1.Expression {
+}
+exports.Term = Term;

package/cjs/filter/ast/expressions/arithmetic-expression.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArithmeticExpressionItem = exports.ArithmeticExpression = void 0;
+const expression_js_1 = require("../abstract/expression.js");
+class ArithmeticExpression extends expression_js_1.Expression {
+    items = [];
+    constructor() {
+        super();
+    }
+    append(op, expression) {
+        this.items.push(new ArithmeticExpressionItem({
+            op,
+            expression
+        }));
+        return this;
+    }
+    toString() {
+        return this.items.map((child, i) => (i > 0 ? child.op : '') + child.expression).join('');
+    }
+}
+exports.ArithmeticExpression = ArithmeticExpression;
+class ArithmeticExpressionItem {
+    op;
+    expression;
+    constructor(o) {
+        Object.assign(this, o);
+    }
+}
+exports.ArithmeticExpressionItem = ArithmeticExpressionItem;

package/cjs/filter/ast/expressions/array-expression.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayExpression = void 0;
+const term_js_1 = require("../abstract/term.js");
+class ArrayExpression extends term_js_1.Term {
+    items;
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    toString() {
+        return '[' + this.items.map(child => '' + child).join(',') + ']';
+    }
+}
+exports.ArrayExpression = ArrayExpression;

package/cjs/filter/ast/expressions/comparison-expression.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComparisonExpression = void 0;
+const expression_js_1 = require("../abstract/expression.js");
+const WORD_PATTERN = /\w/;
+class ComparisonExpression extends expression_js_1.Expression {
+    op;
+    left;
+    right;
+    constructor(o) {
+        super();
+        Object.assign(this, o);
+    }
+    toString() {
+        return `${this.left}${WORD_PATTERN.test(this.op) ? ' ' + this.op + ' ' : this.op}${this.right}`;
+    }
+}
+exports.ComparisonExpression = ComparisonExpression;

package/cjs/filter/ast/expressions/logical-expression.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalExpression = void 0;
+const expression_js_1 = require("../abstract/expression.js");
+class LogicalExpression extends expression_js_1.Expression {
+    op;
+    items;
+    constructor(o) {
+        super();
+        Object.assign(this, o);
+    }
+    toString() {
+        return this.items
+            .map(child => '' + child)
+            .join(' ' + this.op + ' ');
+    }
+}
+exports.LogicalExpression = LogicalExpression;

package/cjs/filter/ast/expressions/parentheses-expression.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParenthesesExpression = void 0;
+const expression_js_1 = require("../abstract/expression.js");
+class ParenthesesExpression extends expression_js_1.Expression {
+    expression;
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    toString() {
+        return `(${this.expression})`;
+    }
+}
+exports.ParenthesesExpression = ParenthesesExpression;

package/cjs/filter/ast/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./abstract/ast.js"), exports);
+tslib_1.__exportStar(require("./abstract/expression.js"), exports);
+tslib_1.__exportStar(require("./abstract/literal.js"), exports);
+tslib_1.__exportStar(require("./abstract/term.js"), exports);
+tslib_1.__exportStar(require("./expressions/arithmetic-expression.js"), exports);
+tslib_1.__exportStar(require("./expressions/array-expression.js"), exports);
+tslib_1.__exportStar(require("./expressions/comparison-expression.js"), exports);
+tslib_1.__exportStar(require("./expressions/logical-expression.js"), exports);
+tslib_1.__exportStar(require("./expressions/parentheses-expression.js"), exports);
+tslib_1.__exportStar(require("./terms/boolean-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/date-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/null-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/number-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/qualified-identifier.js"), exports);
+tslib_1.__exportStar(require("./terms/string-literal.js"), exports);
+tslib_1.__exportStar(require("./terms/time-literal.js"), exports);

package/cjs/filter/ast/terms/boolean-literal.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanLiteral = void 0;
+const literal_js_1 = require("../abstract/literal.js");
+class BooleanLiteral extends literal_js_1.Literal {
+    constructor(value) {
+        super(value);
+    }
+}
+exports.BooleanLiteral = BooleanLiteral;

package/cjs/filter/ast/terms/date-literal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateLiteral = void 0;
+const luxon_1 = require("luxon"); // todo dont use luxon. it has circular deps!
+const errors_js_1 = require("../../errors.js");
+const utils_js_1 = require("../../utils.js");
+const literal_js_1 = require("../abstract/literal.js");
+const DATE_PATTERN = /^(\d{4})-(0[1-9]|1[012])-([123]0|[012][1-9]|31)/;
+class DateLiteral extends literal_js_1.Literal {
+    value;
+    constructor(value) {
+        super('');
+        if (value instanceof Date) {
+            this.value = value.toISOString();
+            return;
+        }
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'string' && DATE_PATTERN.test(value) && luxon_1.DateTime.fromISO(value).isValid) {
+            this.value = value;
+            return;
+        }
+        throw new errors_js_1.ValidationError(`Invalid date value "${value}"`);
+    }
+    toString() {
+        return (0, utils_js_1.quoteFilterString)(this.value);
+    }
+}
+exports.DateLiteral = DateLiteral;

package/cjs/filter/ast/terms/external-constant.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalConstant = void 0;
+const literal_js_1 = require("../abstract/literal.js");
+class ExternalConstant extends literal_js_1.Literal {
+    constructor(value) {
+        super('' + value);
+    }
+    toString() {
+        return '@' + super.toString();
+    }
+}
+exports.ExternalConstant = ExternalConstant;

package/cjs/filter/ast/terms/null-literal.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullLiteral = void 0;
+const literal_js_1 = require("../abstract/literal.js");
+class NullLiteral extends literal_js_1.Literal {
+    value = null;
+    constructor() {
+        super(null);
+    }
+}
+exports.NullLiteral = NullLiteral;

package/cjs/filter/ast/terms/number-literal.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberLiteral = void 0;
+const errors_js_1 = require("../../errors.js");
+const literal_js_1 = require("../abstract/literal.js");
+class NumberLiteral extends literal_js_1.Literal {
+    value;
+    constructor(value) {
+        super(0);
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            this.value = value;
+            return;
+        }
+        try {
+            // noinspection SuspiciousTypeOfGuard
+            if (typeof value === 'string') {
+                if (value.includes('.')) {
+                    this.value = parseFloat(value);
+                    return;
+                }
+                const n = Number(value);
+                if ('' + n === value)
+                    this.value = n;
+                else
+                    this.value = BigInt(value);
+                return;
+            }
+        }
+        catch {
+            //
+        }
+        throw new errors_js_1.ValidationError(`Invalid number literal ${value}`);
+    }
+    toString() {
+        return typeof this.value === 'bigint'
+            ? ('' + this.value).replace(/n$/, '')
+            : ('' + this.value);
+    }
+}
+exports.NumberLiteral = NumberLiteral;

package/cjs/filter/ast/terms/qualified-identifier.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QualifiedIdentifier = void 0;
+const literal_js_1 = require("../abstract/literal.js");
+class QualifiedIdentifier extends literal_js_1.Literal {
+    constructor(value) {
+        super('' + value);
+    }
+}
+exports.QualifiedIdentifier = QualifiedIdentifier;

package/cjs/filter/ast/terms/string-literal.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringLiteral = void 0;
+const utils_js_1 = require("../../utils.js");
+const literal_js_1 = require("../abstract/literal.js");
+class StringLiteral extends literal_js_1.Literal {
+    constructor(value) {
+        super('' + value);
+    }
+    toString() {
+        return (0, utils_js_1.quoteFilterString)(this.value);
+    }
+}
+exports.StringLiteral = StringLiteral;

package/cjs/filter/ast/terms/time-literal.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeLiteral = void 0;
+const errors_js_1 = require("../../errors.js");
+const utils_js_1 = require("../../utils.js");
+const literal_js_1 = require("../abstract/literal.js");
+const TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d)?(\.(\d+))?$/;
+class TimeLiteral extends literal_js_1.Literal {
+    value;
+    constructor(value) {
+        super('');
+        if (value instanceof Date) {
+            this.value = pad(value.getHours()) + ':' +
+                pad(value.getMinutes()) +
+                (value.getSeconds() ? ':' + pad(value.getSeconds()) : '') +
+                (value.getMilliseconds() ? '.' + pad(value.getMilliseconds()) : '');
+            return;
+        }
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'string' && TIME_PATTERN.test(value)) {
+            this.value = value;
+            return;
+        }
+        throw new errors_js_1.ValidationError(`Invalid time value "${value}"`);
+    }
+    toString() {
+        return (0, utils_js_1.quoteFilterString)(this.value);
+    }
+}
+exports.TimeLiteral = TimeLiteral;
+function pad(n) {
+    return n <= 9 ? '0' + n : '' + n;
+}

package/cjs/filter/build.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$arithmetic = exports.$paren = exports.$notILike = exports.$ilike = exports.$notLike = exports.$like = exports.$notIn = exports.$in = exports.$lte = exports.$lt = exports.$gte = exports.$gt = exports.$ne = exports.$eq = exports.$field = exports.$array = exports.$number = exports.$time = exports.$date = exports.$and = exports.$or = void 0;
+const index_js_1 = require("./ast/index.js");
+function $or(...items) {
+    return new index_js_1.LogicalExpression({ op: 'or', items });
+}
+exports.$or = $or;
+function $and(...items) {
+    return new index_js_1.LogicalExpression({ op: 'and', items });
+}
+exports.$and = $and;
+function $date(v) {
+    return new index_js_1.DateLiteral(v);
+}
+exports.$date = $date;
+function $time(v) {
+    return new index_js_1.TimeLiteral(v);
+}
+exports.$time = $time;
+function $number(v) {
+    return new index_js_1.NumberLiteral(v);
+}
+exports.$number = $number;
+function $array(...items) {
+    return new index_js_1.ArrayExpression(items.map(wrapEntryValue));
+}
+exports.$array = $array;
+function $field(v) {
+    return new index_js_1.QualifiedIdentifier(v);
+}
+exports.$field = $field;
+function $eq(left, right) {
+    return comparisonExpression('=', left, right);
+}
+exports.$eq = $eq;
+function $ne(left, right) {
+    return comparisonExpression('!=', left, right);
+}
+exports.$ne = $ne;
+function $gt(left, right) {
+    return comparisonExpression('>', left, right);
+}
+exports.$gt = $gt;
+function $gte(left, right) {
+    return comparisonExpression('>=', left, right);
+}
+exports.$gte = $gte;
+function $lt(left, right) {
+    return comparisonExpression('<', left, right);
+}
+exports.$lt = $lt;
+function $lte(left, right) {
+    return comparisonExpression('<=', left, right);
+}
+exports.$lte = $lte;
+function $in(left, right) {
+    return comparisonExpression('in', left, right);
+}
+exports.$in = $in;
+function $notIn(left, right) {
+    return comparisonExpression('!in', left, right);
+}
+exports.$notIn = $notIn;
+function $like(left, right) {
+    return comparisonExpression('like', left, right);
+}
+exports.$like = $like;
+function $notLike(left, right) {
+    return comparisonExpression('!like', left, right);
+}
+exports.$notLike = $notLike;
+function $ilike(left, right) {
+    return comparisonExpression('ilike', left, right);
+}
+exports.$ilike = $ilike;
+function $notILike(left, right) {
+    return comparisonExpression('!ilike', left, right);
+}
+exports.$notILike = $notILike;
+function $paren(expression) {
+    return new index_js_1.ParenthesesExpression(expression);
+}
+exports.$paren = $paren;
+function $arithmetic(n) {
+    const exp = new index_js_1.ArithmeticExpression();
+    exp.add = (expression) => {
+        exp.append('+', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.sub = (expression) => {
+        exp.append('-', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.mul = (expression) => {
+        exp.append('*', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.div = (expression) => {
+        exp.append('/', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.append('+', wrapEntryValue(n));
+    return exp;
+}
+exports.$arithmetic = $arithmetic;
+function comparisonExpression(op, left, right) {
+    const lex = wrapEntryValue(left);
+    const rex = wrapEntryValue(right);
+    return new index_js_1.ComparisonExpression({ op, left: lex, right: rex });
+}
+const wrapEntryValue = (v) => {
+    return Array.isArray(v)
+        ? $array(...v.map(_wrapEntryValue))
+        : _wrapEntryValue(v);
+};
+const _wrapEntryValue = (v) => {
+    if (v instanceof index_js_1.Expression)
+        return v;
+    if (typeof v === 'boolean')
+        return new index_js_1.BooleanLiteral(v);
+    if (typeof v === 'number' || typeof v === 'bigint')
+        return new index_js_1.NumberLiteral(v);
+    if (v == null)
+        return new index_js_1.NullLiteral();
+    if (v instanceof Date)
+        return new index_js_1.DateLiteral(v);
+    return new index_js_1.StringLiteral('' + v);
+};

package/cjs/filter/error-listener.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorListener = void 0;
+const errors_js_1 = require("./errors.js");
+class ErrorListener {
+    errors;
+    constructor(errors) {
+        this.errors = errors;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        this.errors.push(new errors_js_1.FilterParseError(msg, { recognizer, offendingSymbol, line, charPositionInLine, e }));
+    }
+}
+exports.ErrorListener = ErrorListener;

package/cjs/filter/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterParseError = exports.ValidationError = exports.SyntaxError = void 0;
+class SyntaxError extends TypeError {
+}
+exports.SyntaxError = SyntaxError;
+class ValidationError extends TypeError {
+}
+exports.ValidationError = ValidationError;
+class FilterParseError extends Error {
+    recognizer;
+    offendingSymbol;
+    line;
+    charPositionInLine;
+    e;
+    constructor(message, args) {
+        super(message);
+        Object.assign(this, args);
+    }
+}
+exports.FilterParseError = FilterParseError;

package/cjs/filter/filter-tree-visitor.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterTreeVisitor = void 0;
+const index_js_1 = require("antlr4ts/tree/index.js");
+const OpraFilterParser_js_1 = require("./antlr/OpraFilterParser.js");
+const index_js_2 = require("./ast/index.js");
+const external_constant_js_1 = require("./ast/terms/external-constant.js");
+const errors_js_1 = require("./errors.js");
+const utils_js_1 = require("./utils.js");
+class FilterTreeVisitor extends index_js_1.AbstractParseTreeVisitor {
+    _timeZone;
+    constructor(options) {
+        super();
+        this._timeZone = options?.timeZone;
+    }
+    defaultResult() {
+        return undefined;
+    }
+    visitRoot(ctx) {
+        return this.visit(ctx.expression());
+    }
+    visitIdentifier(ctx) {
+        return ctx.text;
+    }
+    visitNullLiteral() {
+        return new index_js_2.NullLiteral();
+    }
+    visitBooleanLiteral(ctx) {
+        return new index_js_2.BooleanLiteral(ctx.text === 'true');
+    }
+    visitNumberLiteral(ctx) {
+        return new index_js_2.NumberLiteral(ctx.text);
+    }
+    visitStringLiteral(ctx) {
+        return new index_js_2.StringLiteral((0, utils_js_1.unquoteFilterString)(ctx.text));
+    }
+    visitInfinityLiteral() {
+        return new index_js_2.NumberLiteral(Infinity);
+    }
+    visitDateLiteral(ctx) {
+        return new index_js_2.DateLiteral((0, utils_js_1.unquoteFilterString)(ctx.text));
+    }
+    visitDateTimeLiteral(ctx) {
+        return new index_js_2.DateLiteral((0, utils_js_1.unquoteFilterString)(ctx.text));
+    }
+    visitTimeLiteral(ctx) {
+        return new index_js_2.TimeLiteral((0, utils_js_1.unquoteFilterString)(ctx.text));
+    }
+    visitQualifiedIdentifierTerm(ctx) {
+        return new index_js_2.QualifiedIdentifier(ctx.text);
+    }
+    visitPolarityExpression(ctx) {
+        const x = this.visit(ctx.expression());
+        if (x.kind === 'NumberLiteral') {
+            if (ctx.polarOp().text === '-')
+                x.value *= -1;
+            return x;
+        }
+        throw new errors_js_1.SyntaxError('Unexpected token "' + ctx.text + '"');
+    }
+    visitExternalConstantTerm(ctx) {
+        return new external_constant_js_1.ExternalConstant(ctx.externalConstant().text.substring(1));
+    }
+    visitParenthesizedExpression(ctx) {
+        const expression = this.visit(ctx.expression());
+        return new index_js_2.ParenthesesExpression(expression);
+    }
+    visitArrayExpression(ctx) {
+        return new index_js_2.ArrayExpression(ctx.expression().map(child => this.visit(child)));
+    }
+    visitComparisonExpression(ctx) {
+        return new index_js_2.ComparisonExpression({
+            op: ctx.compOp().text,
+            left: this.visit(ctx.expression(0)),
+            right: this.visit(ctx.expression(1))
+        });
+    }
+    visitLogicalExpression(ctx) {
+        const items = [];
+        const wrapChildren = (arr, op) => {
+            for (const c of arr) {
+                if (c instanceof OpraFilterParser_js_1.LogicalExpressionContext && c.logOp().text === op) {
+                    wrapChildren(c.expression(), c.logOp().text);
+                    continue;
+                }
+                const o = this.visit(c);
+                items.push(o);
+            }
+        };
+        wrapChildren(ctx.expression(), ctx.logOp().text);
+        return new index_js_2.LogicalExpression({
+            op: ctx.logOp().text,
+            items
+        });
+    }
+    visitArithmeticExpression(ctx) {
+        const exp = new index_js_2.ArithmeticExpression();
+        const wrapChildren = (children, op) => {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const child = children[i];
+                if (child instanceof OpraFilterParser_js_1.ArithmeticExpressionContext) {
+                    wrapChildren(child.expression(), child.arthOp().text);
+                    continue;
+                }
+                const value = this.visit(child);
+                exp.append(op || '+', value);
+            }
+        };
+        wrapChildren(ctx.expression(), ctx.arthOp().text);
+        return exp;
+    }
+}
+exports.FilterTreeVisitor = FilterTreeVisitor;

package/cjs/filter/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ast/index.js"), exports);
+tslib_1.__exportStar(require("./parse.js"), exports);
+tslib_1.__exportStar(require("./build.js"), exports);
+tslib_1.__exportStar(require("./error-listener.js"), exports);
+tslib_1.__exportStar(require("./filter-tree-visitor.js"), exports);

package/cjs/filter/parse.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFilter = void 0;
+const antlr4ts_1 = require("antlr4ts");
+const OpraFilterLexer_js_1 = require("./antlr/OpraFilterLexer.js");
+const OpraFilterParser_js_1 = require("./antlr/OpraFilterParser.js");
+const error_listener_js_1 = require("./error-listener.js");
+const errors_js_1 = require("./errors.js");
+const filter_tree_visitor_js_1 = require("./filter-tree-visitor.js");
+function parseFilter(text, visitor) {
+    const inputStream = antlr4ts_1.CharStreams.fromString(text);
+    const lexer = new OpraFilterLexer_js_1.OpraFilterLexer(inputStream);
+    const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+    const parser = new OpraFilterParser_js_1.OpraFilterParser(tokenStream);
+    parser.buildParseTree = true;
+    const errors = [];
+    const errorListener = new error_listener_js_1.ErrorListener(errors);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(errorListener);
+    parser.removeErrorListeners();
+    parser.addErrorListener(errorListener);
+    const tree = parser.root();
+    visitor = visitor || new filter_tree_visitor_js_1.FilterTreeVisitor();
+    const result = visitor.visit(tree);
+    if (errors.length) {
+        const errMsgs = [];
+        for (const err of errors) {
+            errMsgs.push(err.message +
+                ' at (' + 'line: ' + err.line + ' column: ' + err.charPositionInLine + ')');
+        }
+        const e = new errors_js_1.SyntaxError(errMsgs.join('\n'));
+        e.errors = errors;
+        throw e;
+    }
+    return result;
+}
+exports.parseFilter = parseFilter;