@steedos/odata-v4-parser 2.2.53-beta.3

package/lib/expressions.js

@@ -0,0 +1,942 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expressions = void 0;
+var utils_1 = require("./utils");
+var lexer_1 = require("./lexer");
+var primitiveLiteral_1 = require("./primitiveLiteral");
+var nameOrIdentifier_1 = require("./nameOrIdentifier");
+var json_1 = require("./json");
+var Expressions;
+(function (Expressions) {
+    function commonExpr(value, index) {
+        var token = primitiveLiteral_1.default.primitiveLiteral(value, index) ||
+            parameterAlias(value, index) ||
+            json_1.default.arrayOrObject(value, index) ||
+            rootExpr(value, index) ||
+            methodCallExpr(value, index) ||
+            firstMemberExpr(value, index) ||
+            functionExpr(value, index) ||
+            negateExpr(value, index) ||
+            parenExpr(value, index) ||
+            castExpr(value, index);
+        if (!token)
+            return;
+        var expr = addExpr(value, token.next) ||
+            subExpr(value, token.next) ||
+            mulExpr(value, token.next) ||
+            divExpr(value, token.next) ||
+            modExpr(value, token.next);
+        if (expr) {
+            token.value = {
+                left: lexer_1.default.clone(token),
+                right: expr.value
+            };
+            token.next = expr.value.next;
+            token.type = expr.type;
+            token.raw = utils_1.default.stringify(value, token.position, token.next);
+        }
+        if (token)
+            return lexer_1.default.tokenize(value, token.position, token.next, token, lexer_1.default.TokenType.CommonExpression);
+    }
+    Expressions.commonExpr = commonExpr;
+    function boolCommonExpr(value, index) {
+        var token = isofExpr(value, index) ||
+            boolMethodCallExpr(value, index) ||
+            notExpr(value, index) ||
+            commonExpr(value, index) ||
+            boolParenExpr(value, index);
+        if (!token)
+            return;
+        var commonMoreExpr = undefined;
+        if (token.type === lexer_1.default.TokenType.CommonExpression) {
+            commonMoreExpr = eqExpr(value, token.next) ||
+                neExpr(value, token.next) ||
+                ltExpr(value, token.next) ||
+                leExpr(value, token.next) ||
+                gtExpr(value, token.next) ||
+                geExpr(value, token.next) ||
+                hasExpr(value, token.next) ||
+                inExpr(value, token.next);
+            if (commonMoreExpr) {
+                token.value = {
+                    left: token.value,
+                    right: commonMoreExpr.value
+                };
+                token.next = commonMoreExpr.value.next;
+                token.type = commonMoreExpr.type;
+                token.raw = utils_1.default.stringify(value, token.position, token.next);
+            }
+        }
+        var expr = andExpr(value, token.next) ||
+            orExpr(value, token.next);
+        if (expr) {
+            var left = lexer_1.default.clone(token);
+            token.next = expr.value.next;
+            token.value = {
+                left: left,
+                right: expr.value
+            };
+            token.type = expr.type;
+            token.raw = utils_1.default.stringify(value, token.position, token.next);
+            if (token.type === lexer_1.default.TokenType.AndExpression && token.value.right.type === lexer_1.default.TokenType.OrExpression) {
+                token.value.left = lexer_1.default.tokenize(value, token.value.left.position, token.value.right.value.left.next, {
+                    left: token.value.left,
+                    right: token.value.right.value.left
+                }, token.type);
+                token.type = token.value.right.type;
+                token.value.right = token.value.right.value.right;
+            }
+        }
+        return token;
+    }
+    Expressions.boolCommonExpr = boolCommonExpr;
+    function andExpr(value, index) {
+        var rws = lexer_1.default.RWS(value, index);
+        if (rws === index || !utils_1.default.equals(value, rws, "and"))
+            return;
+        var start = index;
+        index = rws + 3;
+        rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        index = rws;
+        var token = boolCommonExpr(value, index);
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, index, token, lexer_1.default.TokenType.AndExpression);
+    }
+    Expressions.andExpr = andExpr;
+    function orExpr(value, index) {
+        var rws = lexer_1.default.RWS(value, index);
+        if (rws === index || !utils_1.default.equals(value, rws, "or"))
+            return;
+        var start = index;
+        index = rws + 2;
+        rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        index = rws;
+        var token = boolCommonExpr(value, index);
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, index, token, lexer_1.default.TokenType.OrExpression);
+    }
+    Expressions.orExpr = orExpr;
+    function leftRightExpr(value, index, expr, tokenType) {
+        var rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        var start = index;
+        index = rws;
+        if (!utils_1.default.equals(value, index, expr))
+            return;
+        index += expr.length;
+        rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        index = rws;
+        var token = commonExpr(value, index);
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, index, token.value, tokenType);
+    }
+    Expressions.leftRightExpr = leftRightExpr;
+    function eqExpr(value, index) { return leftRightExpr(value, index, "eq", lexer_1.default.TokenType.EqualsExpression); }
+    Expressions.eqExpr = eqExpr;
+    function neExpr(value, index) { return leftRightExpr(value, index, "ne", lexer_1.default.TokenType.NotEqualsExpression); }
+    Expressions.neExpr = neExpr;
+    function ltExpr(value, index) { return leftRightExpr(value, index, "lt", lexer_1.default.TokenType.LesserThanExpression); }
+    Expressions.ltExpr = ltExpr;
+    function leExpr(value, index) { return leftRightExpr(value, index, "le", lexer_1.default.TokenType.LesserOrEqualsExpression); }
+    Expressions.leExpr = leExpr;
+    function gtExpr(value, index) { return leftRightExpr(value, index, "gt", lexer_1.default.TokenType.GreaterThanExpression); }
+    Expressions.gtExpr = gtExpr;
+    function geExpr(value, index) { return leftRightExpr(value, index, "ge", lexer_1.default.TokenType.GreaterOrEqualsExpression); }
+    Expressions.geExpr = geExpr;
+    function hasExpr(value, index) { return leftRightExpr(value, index, "has", lexer_1.default.TokenType.HasExpression); }
+    Expressions.hasExpr = hasExpr;
+    function addExpr(value, index) { return leftRightExpr(value, index, "add", lexer_1.default.TokenType.AddExpression); }
+    Expressions.addExpr = addExpr;
+    function subExpr(value, index) { return leftRightExpr(value, index, "sub", lexer_1.default.TokenType.SubExpression); }
+    Expressions.subExpr = subExpr;
+    function mulExpr(value, index) { return leftRightExpr(value, index, "mul", lexer_1.default.TokenType.MulExpression); }
+    Expressions.mulExpr = mulExpr;
+    function divExpr(value, index) { return leftRightExpr(value, index, "div", lexer_1.default.TokenType.DivExpression); }
+    Expressions.divExpr = divExpr;
+    function modExpr(value, index) { return leftRightExpr(value, index, "mod", lexer_1.default.TokenType.ModExpression); }
+    Expressions.modExpr = modExpr;
+    function inExpr(value, index) {
+        // return leftRightExpr(value, index, "in", Lexer.TokenType.InExpression); 
+        var expr = 'in';
+        var tokenType = lexer_1.default.TokenType.InExpression;
+        var rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        var start = index;
+        index = rws;
+        if (!utils_1.default.equals(value, index, expr))
+            return;
+        index += expr.length;
+        rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        index = rws;
+        var token = boolCommonExpr(value, index);
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, index, token.value, tokenType);
+    }
+    Expressions.inExpr = inExpr;
+    function notExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "not"))
+            return;
+        var start = index;
+        index += 3;
+        var rws = lexer_1.default.RWS(value, index);
+        if (rws === index)
+            return;
+        index = rws;
+        var token = boolCommonExpr(value, index);
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, token.next, token, lexer_1.default.TokenType.NotExpression);
+    }
+    Expressions.notExpr = notExpr;
+    function boolParenExpr(value, index) {
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        var start = index;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var token = boolCommonExpr(value, index);
+        if (!token)
+            return;
+        index = lexer_1.default.BWS(value, token.next);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, token, lexer_1.default.TokenType.BoolParenExpression);
+    }
+    Expressions.boolParenExpr = boolParenExpr;
+    function parenExpr(value, index) {
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        var start = index;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var token = commonExpr(value, index);
+        if (!token)
+            return;
+        index = lexer_1.default.BWS(value, token.next);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, token.value, lexer_1.default.TokenType.ParenExpression);
+    }
+    Expressions.parenExpr = parenExpr;
+    function boolMethodCallExpr(value, index) {
+        return endsWithMethodCallExpr(value, index) ||
+            startsWithMethodCallExpr(value, index) ||
+            containsMethodCallExpr(value, index) ||
+            intersectsMethodCallExpr(value, index);
+    }
+    Expressions.boolMethodCallExpr = boolMethodCallExpr;
+    function methodCallExpr(value, index) {
+        return indexOfMethodCallExpr(value, index) ||
+            toLowerMethodCallExpr(value, index) ||
+            toUpperMethodCallExpr(value, index) ||
+            trimMethodCallExpr(value, index) ||
+            substringMethodCallExpr(value, index) ||
+            substringOfMethodCallExpr(value, index) ||
+            concatMethodCallExpr(value, index) ||
+            lengthMethodCallExpr(value, index) ||
+            yearMethodCallExpr(value, index) ||
+            monthMethodCallExpr(value, index) ||
+            dayMethodCallExpr(value, index) ||
+            hourMethodCallExpr(value, index) ||
+            minuteMethodCallExpr(value, index) ||
+            secondMethodCallExpr(value, index) ||
+            fractionalsecondsMethodCallExpr(value, index) ||
+            totalsecondsMethodCallExpr(value, index) ||
+            dateMethodCallExpr(value, index) ||
+            timeMethodCallExpr(value, index) ||
+            roundMethodCallExpr(value, index) ||
+            floorMethodCallExpr(value, index) ||
+            ceilingMethodCallExpr(value, index) ||
+            distanceMethodCallExpr(value, index) ||
+            geoLengthMethodCallExpr(value, index) ||
+            totalOffsetMinutesMethodCallExpr(value, index) ||
+            minDateTimeMethodCallExpr(value, index) ||
+            maxDateTimeMethodCallExpr(value, index) ||
+            nowMethodCallExpr(value, index);
+    }
+    Expressions.methodCallExpr = methodCallExpr;
+    function methodCallExprFactory(value, index, method, min, max) {
+        if (typeof min === "undefined")
+            min = 0;
+        if (typeof max === "undefined")
+            max = min;
+        if (!utils_1.default.equals(value, index, method))
+            return;
+        var start = index;
+        index += method.length;
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var parameters;
+        if (min > 0) {
+            parameters = [];
+            while (parameters.length < max) {
+                var expr = commonExpr(value, index);
+                if (parameters.length < min && !expr)
+                    return;
+                else if (expr) {
+                    parameters.push(expr.value);
+                    index = expr.next;
+                    index = lexer_1.default.BWS(value, index);
+                    var comma = lexer_1.default.COMMA(value, index);
+                    if (parameters.length < min && !comma)
+                        return;
+                    if (comma)
+                        index = comma;
+                    else
+                        break;
+                    index = lexer_1.default.BWS(value, index);
+                }
+                else
+                    break;
+            }
+        }
+        index = lexer_1.default.BWS(value, index);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, {
+            method: method,
+            parameters: parameters
+        }, lexer_1.default.TokenType.MethodCallExpression);
+    }
+    Expressions.methodCallExprFactory = methodCallExprFactory;
+    function containsMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "contains", 2); }
+    Expressions.containsMethodCallExpr = containsMethodCallExpr;
+    function startsWithMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "startswith", 2); }
+    Expressions.startsWithMethodCallExpr = startsWithMethodCallExpr;
+    function endsWithMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "endswith", 2); }
+    Expressions.endsWithMethodCallExpr = endsWithMethodCallExpr;
+    function lengthMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "length", 1); }
+    Expressions.lengthMethodCallExpr = lengthMethodCallExpr;
+    function indexOfMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "indexof", 2); }
+    Expressions.indexOfMethodCallExpr = indexOfMethodCallExpr;
+    function substringMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "substring", 2, 3); }
+    Expressions.substringMethodCallExpr = substringMethodCallExpr;
+    function substringOfMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "substringof", 2); }
+    Expressions.substringOfMethodCallExpr = substringOfMethodCallExpr;
+    function toLowerMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "tolower", 1); }
+    Expressions.toLowerMethodCallExpr = toLowerMethodCallExpr;
+    function toUpperMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "toupper", 1); }
+    Expressions.toUpperMethodCallExpr = toUpperMethodCallExpr;
+    function trimMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "trim", 1); }
+    Expressions.trimMethodCallExpr = trimMethodCallExpr;
+    function concatMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "concat", 2); }
+    Expressions.concatMethodCallExpr = concatMethodCallExpr;
+    function yearMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "year", 1); }
+    Expressions.yearMethodCallExpr = yearMethodCallExpr;
+    function monthMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "month", 1); }
+    Expressions.monthMethodCallExpr = monthMethodCallExpr;
+    function dayMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "day", 1); }
+    Expressions.dayMethodCallExpr = dayMethodCallExpr;
+    function hourMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "hour", 1); }
+    Expressions.hourMethodCallExpr = hourMethodCallExpr;
+    function minuteMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "minute", 1); }
+    Expressions.minuteMethodCallExpr = minuteMethodCallExpr;
+    function secondMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "second", 1); }
+    Expressions.secondMethodCallExpr = secondMethodCallExpr;
+    function fractionalsecondsMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "fractionalseconds", 1); }
+    Expressions.fractionalsecondsMethodCallExpr = fractionalsecondsMethodCallExpr;
+    function totalsecondsMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "totalseconds", 1); }
+    Expressions.totalsecondsMethodCallExpr = totalsecondsMethodCallExpr;
+    function dateMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "date", 1); }
+    Expressions.dateMethodCallExpr = dateMethodCallExpr;
+    function timeMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "time", 1); }
+    Expressions.timeMethodCallExpr = timeMethodCallExpr;
+    function totalOffsetMinutesMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "totaloffsetminutes", 1); }
+    Expressions.totalOffsetMinutesMethodCallExpr = totalOffsetMinutesMethodCallExpr;
+    function minDateTimeMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "mindatetime", 0); }
+    Expressions.minDateTimeMethodCallExpr = minDateTimeMethodCallExpr;
+    function maxDateTimeMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "maxdatetime", 0); }
+    Expressions.maxDateTimeMethodCallExpr = maxDateTimeMethodCallExpr;
+    function nowMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "now", 0); }
+    Expressions.nowMethodCallExpr = nowMethodCallExpr;
+    function roundMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "round", 1); }
+    Expressions.roundMethodCallExpr = roundMethodCallExpr;
+    function floorMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "floor", 1); }
+    Expressions.floorMethodCallExpr = floorMethodCallExpr;
+    function ceilingMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "ceiling", 1); }
+    Expressions.ceilingMethodCallExpr = ceilingMethodCallExpr;
+    function distanceMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "geo.distance", 2); }
+    Expressions.distanceMethodCallExpr = distanceMethodCallExpr;
+    function geoLengthMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "geo.length", 1); }
+    Expressions.geoLengthMethodCallExpr = geoLengthMethodCallExpr;
+    function intersectsMethodCallExpr(value, index) { return methodCallExprFactory(value, index, "geo.intersects", 2); }
+    Expressions.intersectsMethodCallExpr = intersectsMethodCallExpr;
+    function isofExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "isof"))
+            return;
+        var start = index;
+        index += 4;
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var expr = commonExpr(value, index);
+        if (expr) {
+            index = expr.next;
+            index = lexer_1.default.BWS(value, index);
+            var comma = lexer_1.default.COMMA(value, index);
+            if (!comma)
+                return;
+            index = comma;
+            index = lexer_1.default.BWS(value, index);
+        }
+        var typeName = nameOrIdentifier_1.default.qualifiedTypeName(value, index);
+        if (!typeName)
+            return;
+        index = typeName.next;
+        index = lexer_1.default.BWS(value, index);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, {
+            target: expr,
+            typename: typeName
+        }, lexer_1.default.TokenType.IsOfExpression);
+    }
+    Expressions.isofExpr = isofExpr;
+    function castExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "cast"))
+            return;
+        var start = index;
+        index += 4;
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var expr = commonExpr(value, index);
+        if (expr) {
+            index = expr.next;
+            index = lexer_1.default.BWS(value, index);
+            var comma = lexer_1.default.COMMA(value, index);
+            if (!comma)
+                return;
+            index = comma;
+            index = lexer_1.default.BWS(value, index);
+        }
+        var typeName = nameOrIdentifier_1.default.qualifiedTypeName(value, index);
+        if (!typeName)
+            return;
+        index = typeName.next;
+        index = lexer_1.default.BWS(value, index);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, {
+            target: expr,
+            typename: typeName
+        }, lexer_1.default.TokenType.CastExpression);
+    }
+    Expressions.castExpr = castExpr;
+    function negateExpr(value, index) {
+        if (value[index] !== 0x2d)
+            return;
+        var start = index;
+        index++;
+        index = lexer_1.default.BWS(value, index);
+        var expr = commonExpr(value, index);
+        if (!expr)
+            return;
+        return lexer_1.default.tokenize(value, start, expr.next, expr, lexer_1.default.TokenType.NegateExpression);
+    }
+    Expressions.negateExpr = negateExpr;
+    function firstMemberExpr(value, index) {
+        var token = inscopeVariableExpr(value, index);
+        var member;
+        var start = index;
+        if (token) {
+            if (value[token.next] === 0x2f) {
+                index = token.next + 1;
+                member = memberExpr(value, index);
+                if (!member)
+                    return;
+                return lexer_1.default.tokenize(value, start, member.next, [token, member], lexer_1.default.TokenType.FirstMemberExpression);
+            }
+        }
+        else
+            member = memberExpr(value, index);
+        token = token || member;
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, token.next, token, lexer_1.default.TokenType.FirstMemberExpression);
+    }
+    Expressions.firstMemberExpr = firstMemberExpr;
+    function memberExpr(value, index) {
+        var start = index;
+        var token = nameOrIdentifier_1.default.qualifiedEntityTypeName(value, index);
+        if (token) {
+            if (value[token.next] !== 0x2f)
+                return;
+            index = token.next + 1;
+        }
+        var next = propertyPathExpr(value, index) ||
+            boundFunctionExpr(value, index);
+        if (!next)
+            return;
+        return lexer_1.default.tokenize(value, start, next.next, token ? { name: token, value: next } : next, lexer_1.default.TokenType.MemberExpression);
+    }
+    Expressions.memberExpr = memberExpr;
+    function propertyPathExpr(value, index) {
+        var token = nameOrIdentifier_1.default.odataIdentifier(value, index);
+        var start = index;
+        if (token) {
+            index = token.next;
+            var nav = collectionPathExpr(value, token.next) ||
+                collectionNavigationExpr(value, token.next) ||
+                singleNavigationExpr(value, token.next) ||
+                complexPathExpr(value, token.next) ||
+                singlePathExpr(value, token.next);
+            if (nav) {
+                index = nav.next;
+                token = {
+                    current: lexer_1.default.clone(token),
+                    next: nav
+                };
+            }
+        }
+        else if (!token) {
+            token = nameOrIdentifier_1.default.streamProperty(value, index);
+            if (token)
+                index = token.next;
+        }
+        if (!token)
+            return;
+        return lexer_1.default.tokenize(value, start, index, token, lexer_1.default.TokenType.PropertyPathExpression);
+    }
+    Expressions.propertyPathExpr = propertyPathExpr;
+    function inscopeVariableExpr(value, index) {
+        return implicitVariableExpr(value, index) ||
+            (isLambdaPredicate ? lambdaVariableExpr(value, index) : undefined);
+    }
+    Expressions.inscopeVariableExpr = inscopeVariableExpr;
+    function implicitVariableExpr(value, index) {
+        if (utils_1.default.equals(value, index, "$it"))
+            return lexer_1.default.tokenize(value, index, index + 3, "$it", lexer_1.default.TokenType.ImplicitVariableExpression);
+    }
+    Expressions.implicitVariableExpr = implicitVariableExpr;
+    var isLambdaPredicate = false;
+    var hasLambdaVariableExpr = false;
+    function lambdaVariableExpr(value, index) {
+        var token = nameOrIdentifier_1.default.odataIdentifier(value, index, lexer_1.default.TokenType.LambdaVariableExpression);
+        if (token) {
+            hasLambdaVariableExpr = true;
+            return token;
+        }
+    }
+    Expressions.lambdaVariableExpr = lambdaVariableExpr;
+    function lambdaPredicateExpr(value, index) {
+        isLambdaPredicate = true;
+        var token = boolCommonExpr(value, index);
+        isLambdaPredicate = false;
+        if (token && hasLambdaVariableExpr) {
+            hasLambdaVariableExpr = false;
+            return lexer_1.default.tokenize(value, token.position, token.next, token, lexer_1.default.TokenType.LambdaPredicateExpression);
+        }
+    }
+    Expressions.lambdaPredicateExpr = lambdaPredicateExpr;
+    function anyExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "any"))
+            return;
+        var start = index;
+        index += 3;
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var variable = lambdaVariableExpr(value, index);
+        var predicate;
+        if (variable) {
+            index = variable.next;
+            index = lexer_1.default.BWS(value, index);
+            var colon = lexer_1.default.COLON(value, index);
+            if (!colon)
+                return;
+            index = colon;
+            index = lexer_1.default.BWS(value, index);
+            predicate = lambdaPredicateExpr(value, index);
+            if (!predicate)
+                return;
+            index = predicate.next;
+        }
+        index = lexer_1.default.BWS(value, index);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, {
+            variable: variable,
+            predicate: predicate
+        }, lexer_1.default.TokenType.AnyExpression);
+    }
+    Expressions.anyExpr = anyExpr;
+    function allExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "all"))
+            return;
+        var start = index;
+        index += 3;
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        index = open;
+        index = lexer_1.default.BWS(value, index);
+        var variable = lambdaVariableExpr(value, index);
+        if (!variable)
+            return;
+        index = variable.next;
+        index = lexer_1.default.BWS(value, index);
+        var colon = lexer_1.default.COLON(value, index);
+        if (!colon)
+            return;
+        index = colon;
+        index = lexer_1.default.BWS(value, index);
+        var predicate = lambdaPredicateExpr(value, index);
+        if (!predicate)
+            return;
+        index = predicate.next;
+        index = lexer_1.default.BWS(value, index);
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, {
+            variable: variable,
+            predicate: predicate
+        }, lexer_1.default.TokenType.AllExpression);
+    }
+    Expressions.allExpr = allExpr;
+    function collectionNavigationExpr(value, index) {
+        var start = index;
+        var entity, predicate, navigation, path;
+        if (value[index] === 0x2f) {
+            index++;
+            entity = nameOrIdentifier_1.default.qualifiedEntityTypeName(value, index);
+            if (!entity)
+                return;
+            index = entity.next;
+        }
+        predicate = keyPredicate(value, index);
+        if (predicate) {
+            index = predicate.next;
+            navigation = singleNavigationExpr(value, index);
+            if (navigation)
+                index = navigation.next;
+        }
+        else {
+            path = collectionPathExpr(value, index);
+            if (path)
+                index = path.next;
+        }
+        if (index > start) {
+            return lexer_1.default.tokenize(value, start, index, {
+                entity: entity,
+                predicate: predicate,
+                navigation: navigation,
+                path: path
+            }, lexer_1.default.TokenType.CollectionNavigationExpression);
+        }
+    }
+    Expressions.collectionNavigationExpr = collectionNavigationExpr;
+    function keyPredicate(value, index, metadataContext) {
+        return simpleKey(value, index, metadataContext) ||
+            compoundKey(value, index);
+    }
+    Expressions.keyPredicate = keyPredicate;
+    function simpleKey(value, index, metadataContext) {
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        var start = index;
+        index = open;
+        var token = keyPropertyValue(value, index);
+        if (!token)
+            return;
+        var close = lexer_1.default.CLOSE(value, token.next);
+        if (!close)
+            return;
+        var key;
+        if (typeof metadataContext === "object" &&
+            metadataContext.key &&
+            metadataContext.key.propertyRefs &&
+            metadataContext.key.propertyRefs[0] &&
+            metadataContext.key.propertyRefs[0].name) {
+            key = metadataContext.key.propertyRefs[0].name;
+        }
+        return lexer_1.default.tokenize(value, start, close, { key: key, value: token }, lexer_1.default.TokenType.SimpleKey);
+    }
+    Expressions.simpleKey = simpleKey;
+    function compoundKey(value, index) {
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        var start = index;
+        index = open;
+        var pair = keyValuePair(value, index);
+        if (!pair)
+            return;
+        var keys = [];
+        while (pair) {
+            keys.push(pair);
+            var comma = lexer_1.default.COMMA(value, pair.next);
+            if (comma)
+                pair = keyValuePair(value, comma);
+            else
+                pair = null;
+        }
+        index = keys[keys.length - 1].next;
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, keys, lexer_1.default.TokenType.CompoundKey);
+    }
+    Expressions.compoundKey = compoundKey;
+    function keyValuePair(value, index) {
+        var prop = nameOrIdentifier_1.default.primitiveKeyProperty(value, index) ||
+            keyPropertyAlias(value, index);
+        if (!prop)
+            return;
+        var eq = lexer_1.default.EQ(value, prop.next);
+        if (!eq)
+            return;
+        var val = keyPropertyValue(value, eq);
+        if (val)
+            return lexer_1.default.tokenize(value, index, val.next, {
+                key: prop,
+                value: val
+            }, lexer_1.default.TokenType.KeyValuePair);
+    }
+    Expressions.keyValuePair = keyValuePair;
+    function keyPropertyValue(value, index) {
+        var token = primitiveLiteral_1.default.primitiveLiteral(value, index);
+        if (token) {
+            token.type = lexer_1.default.TokenType.KeyPropertyValue;
+            return token;
+        }
+    }
+    Expressions.keyPropertyValue = keyPropertyValue;
+    function keyPropertyAlias(value, index) { return nameOrIdentifier_1.default.odataIdentifier(value, index, lexer_1.default.TokenType.KeyPropertyAlias); }
+    Expressions.keyPropertyAlias = keyPropertyAlias;
+    function singleNavigationExpr(value, index) {
+        if (value[index] !== 0x2f)
+            return;
+        var member = memberExpr(value, index + 1);
+        if (member)
+            return lexer_1.default.tokenize(value, index, member.next, member, lexer_1.default.TokenType.SingleNavigationExpression);
+    }
+    Expressions.singleNavigationExpr = singleNavigationExpr;
+    function collectionPathExpr(value, index) {
+        var token = countExpr(value, index);
+        if (!token) {
+            if (value[index] === 0x2f) {
+                token = boundFunctionExpr(value, index + 1) ||
+                    anyExpr(value, index + 1) ||
+                    allExpr(value, index + 1);
+            }
+        }
+        if (token)
+            return lexer_1.default.tokenize(value, index, token.next, token, lexer_1.default.TokenType.CollectionPathExpression);
+    }
+    Expressions.collectionPathExpr = collectionPathExpr;
+    function complexPathExpr(value, index) {
+        if (value[index] !== 0x2f)
+            return;
+        var start = index;
+        index++;
+        var token = nameOrIdentifier_1.default.qualifiedComplexTypeName(value, index);
+        if (token) {
+            if (value[token.next] !== 0x2f)
+                return;
+            index = token.next + 1;
+        }
+        var expr = propertyPathExpr(value, index) ||
+            boundFunctionExpr(value, index);
+        if (expr)
+            return lexer_1.default.tokenize(value, start, expr.next, token ? [token, expr] : [expr], lexer_1.default.TokenType.ComplexPathExpression);
+    }
+    Expressions.complexPathExpr = complexPathExpr;
+    function singlePathExpr(value, index) {
+        if (value[index] !== 0x2f)
+            return;
+        var boundFunction = boundFunctionExpr(value, index + 1);
+        if (boundFunction)
+            return lexer_1.default.tokenize(value, index, boundFunction.next, boundFunction, lexer_1.default.TokenType.SinglePathExpression);
+    }
+    Expressions.singlePathExpr = singlePathExpr;
+    function functionExpr(value, index) {
+        var namespaceNext = nameOrIdentifier_1.default.namespace(value, index);
+        if (namespaceNext === index || value[namespaceNext] !== 0x2e)
+            return;
+        var start = index;
+        index = namespaceNext + 1;
+        var token = nameOrIdentifier_1.default.odataIdentifier(value, index);
+        if (!token)
+            return;
+        token.position = start;
+        token.value.namespace = utils_1.default.stringify(value, start, namespaceNext);
+        token.raw = utils_1.default.stringify(value, start, token.next);
+        index = token.next;
+        var params = functionExprParameters(value, index);
+        if (!params)
+            return;
+        index = params.next;
+        var expr = collectionPathExpr(value, index) ||
+            collectionNavigationExpr(value, index) ||
+            singleNavigationExpr(value, index) ||
+            complexPathExpr(value, index) ||
+            singlePathExpr(value, index);
+        if (expr)
+            index = expr.next;
+        return lexer_1.default.tokenize(value, start, index, {
+            fn: token,
+            params: params,
+            expression: expr
+        }, lexer_1.default.TokenType.FunctionExpression);
+    }
+    Expressions.functionExpr = functionExpr;
+    function boundFunctionExpr(value, index) { return functionExpr(value, index); }
+    Expressions.boundFunctionExpr = boundFunctionExpr;
+    function functionExprParameters(value, index) {
+        var open = lexer_1.default.OPEN(value, index);
+        if (!open)
+            return;
+        var start = index;
+        index = open;
+        var params = [];
+        var expr = functionExprParameter(value, index);
+        while (expr) {
+            params.push(expr);
+            var comma = lexer_1.default.COMMA(value, expr.next);
+            if (comma) {
+                index = comma;
+                expr = functionExprParameter(value, index);
+                if (!expr)
+                    return;
+            }
+            else {
+                index = expr.next;
+                expr = null;
+            }
+        }
+        var close = lexer_1.default.CLOSE(value, index);
+        if (!close)
+            return;
+        index = close;
+        return lexer_1.default.tokenize(value, start, index, params, lexer_1.default.TokenType.FunctionExpressionParameters);
+    }
+    Expressions.functionExprParameters = functionExprParameters;
+    function functionExprParameter(value, index) {
+        var name = parameterName(value, index);
+        if (!name)
+            return;
+        var eq = lexer_1.default.EQ(value, name.next);
+        if (!name || !eq)
+            return;
+        var start = index;
+        index = eq;
+        var param = parameterAlias(value, index) ||
+            parameterValue(value, index);
+        if (!param)
+            return;
+        return lexer_1.default.tokenize(value, start, param.next, {
+            name: name,
+            value: param
+        }, lexer_1.default.TokenType.FunctionExpressionParameter);
+    }
+    Expressions.functionExprParameter = functionExprParameter;
+    function parameterName(value, index) { return nameOrIdentifier_1.default.odataIdentifier(value, index, lexer_1.default.TokenType.ParameterName); }
+    Expressions.parameterName = parameterName;
+    function parameterAlias(value, index) {
+        var at = lexer_1.default.AT(value, index);
+        if (!at)
+            return;
+        var id = nameOrIdentifier_1.default.odataIdentifier(value, at);
+        if (id)
+            return lexer_1.default.tokenize(value, index, id.next, id.value, lexer_1.default.TokenType.ParameterAlias);
+    }
+    Expressions.parameterAlias = parameterAlias;
+    function parameterValue(value, index) {
+        var token = json_1.default.arrayOrObject(value, index) ||
+            commonExpr(value, index);
+        if (token)
+            return lexer_1.default.tokenize(value, index, token.next, token.value, lexer_1.default.TokenType.ParameterValue);
+    }
+    Expressions.parameterValue = parameterValue;
+    function countExpr(value, index) {
+        if (utils_1.default.equals(value, index, "/$count"))
+            return lexer_1.default.tokenize(value, index, index + 7, "/$count", lexer_1.default.TokenType.CountExpression);
+    }
+    Expressions.countExpr = countExpr;
+    function refExpr(value, index) {
+        if (utils_1.default.equals(value, index, "/$ref"))
+            return lexer_1.default.tokenize(value, index, index + 5, "/$ref", lexer_1.default.TokenType.RefExpression);
+    }
+    Expressions.refExpr = refExpr;
+    function valueExpr(value, index) {
+        if (utils_1.default.equals(value, index, "/$value"))
+            return lexer_1.default.tokenize(value, index, index + 7, "/$value", lexer_1.default.TokenType.ValueExpression);
+    }
+    Expressions.valueExpr = valueExpr;
+    function rootExpr(value, index) {
+        if (!utils_1.default.equals(value, index, "$root/"))
+            return;
+        var start = index;
+        index += 6;
+        var entitySet = nameOrIdentifier_1.default.entitySetName(value, index);
+        var predicate, entity, token;
+        if (entitySet)
+            predicate = keyPredicate(value, entitySet.next);
+        if (!(entitySet && predicate)) {
+            entity = nameOrIdentifier_1.default.singletonEntity(value, index);
+            if (!entity)
+                return;
+            token = {
+                entity: entity
+            };
+        }
+        else
+            token = {
+                entitySet: entitySet,
+                keys: predicate
+            };
+        index = (predicate || entity).next;
+        var nav = singleNavigationExpr(value, index);
+        if (nav)
+            index = nav.next;
+        return lexer_1.default.tokenize(value, start, index, {
+            current: token,
+            next: nav
+        }, lexer_1.default.TokenType.RootExpression);
+    }
+    Expressions.rootExpr = rootExpr;
+})(Expressions = exports.Expressions || (exports.Expressions = {}));
+exports.default = Expressions;
+//# sourceMappingURL=expressions.js.map