breeze-client 2.2.1-cjs → 2.2.2

package/esm2022/src/predicate.mjs

@@ -0,0 +1,1259 @@
+import { core } from './core';
+import { EntityType, DataProperty } from './entity-metadata';
+import { DataType } from './data-type';
+import { EntityAspect } from './entity-aspect';
+/**
+Used to define a 'where' predicate for an [[EntityQuery]].  Predicates are immutable, which means that any
+method that would modify a Predicate actually returns a new Predicate.
+**/
+export class Predicate {
+    /**
+    Predicate constructor
+    >     let p1 = new Predicate("CompanyName", "StartsWith", "B");
+    >     let query = new EntityQuery("Customers").where(p1);
+  
+    or
+    >     let p2 = new Predicate("Region", FilterQueryOp.Equals, null);
+    >     let query = new EntityQuery("Customers").where(p2);
+    @param property - A property name, a nested property name or an expression involving a property name.
+    @param operator -
+    @param value - This will be treated as either a property expression or a literal depending on context.  In general,
+    if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.
+    In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'
+    property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any
+    literal based on context, if this fails you can force this inference by making the value argument an object with a
+    'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.
+    **/
+    constructor(...args) {
+        if (args.length === 0)
+            return;
+        if (!(this instanceof Predicate)) {
+            return new Predicate(...args);
+        }
+        return Predicate.create(...args);
+    }
+    /**
+    Same as using the ctor.
+    >      // so
+    >      let p = Predicate.create(a, b, c);
+    >      // is the same as
+    >      let p = new Predicate(a, b, c);
+    @param property -  A property name, a nested property name or an expression involving a property name.
+    @param operator - the filter query operator.
+    @param value - This will be treated as either a property expression or a literal depending on context.  In general,
+    if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.
+    In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'
+    property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any
+    literal based on context, if this fails you can force this inference by making the value argument an object with a
+    'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.
+    **/
+    static create(...args) {
+        // can be called from std javascript without new ( legacy )
+        // empty ctor is used by all subclasses.
+        if (args.length === 0)
+            return new Predicate();
+        if (args.length === 1) {
+            // possibilities:
+            //      Predicate([ aPredicate ]) or  Predicate(["freight", ">", 100]) - an array
+            //      Predicate(aPredicate) - a predicate
+            //      Predicate( "freight gt 100" }  // passthru ( i.e. maybe an odata string) - a string
+            //      Predicate( { freight: { ">": 100 } }) - an object
+            let arg = arguments[0];
+            if (Array.isArray(arg)) {
+                if (arg.length === 1) {
+                    // recurse
+                    return new Predicate(arg[0]);
+                }
+                else {
+                    return createPredicateFromArray(arg);
+                }
+            }
+            else if (arg instanceof Predicate) {
+                return arg;
+            }
+            else if (typeof arg === 'string') {
+                return new PassthruPredicate(arg);
+            }
+            else {
+                return createPredicateFromObject(arg);
+            }
+        }
+        else {
+            // 2 possibilities
+            //      Predicate("freight", ">", 100");
+            //      Predicate("orders", "any", "freight",  ">", 950);
+            return createPredicateFromArray(args);
+        }
+    }
+    /** @hidden @internal */
+    _validate(entityType, usesNameOnServer) {
+        // noop here;
+    }
+    /**
+    Creates a 'composite' Predicate by 'and'ing a set of specified Predicates together.
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = Predicate.and(p1, p2, p3);
+  
+    or
+    >      let preds = [p1, p2, p3];
+    >      let newPred = Predicate.and(preds);
+    @param predicates - multiple Predicates or an array of Predicate.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    static and(...args) {
+        let pred = new AndOrPredicate("and", args);
+        // TODO removed below
+        // return undefined if empty
+        // return pred.op && pred;
+        return pred;
+    }
+    /**
+    Creates a 'composite' Predicate by 'or'ing a set of specified Predicates together.
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = Predicate.or(p1, p2, p3);
+  
+    or
+    >      let preds = [p1, p2, p3];
+    >      let newPred = Predicate.or(preds);
+    @param predicates - multiple Predicates or an array of Predicate.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    static or(...args) {
+        let pred = new AndOrPredicate("or", args);
+        // return pred.op && pred;
+        return pred;
+    }
+    /**
+    Creates a 'composite' Predicate by 'negating' a specified predicate.
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = Predicate.not(p1);
+  
+    This can also be accomplished using the 'instance' version of the 'not' method
+    >      let not_p1 = p1.not();
+  
+    Both of which would be the same as
+    >      let not_p1 = Predicate.create("Freight", "le", 100);
+    **/
+    static not(pred) {
+        return pred.not();
+    }
+    // TODO: determine if/where this is used.
+    // static extendBinaryPredicateFn(opMap: IOpMap, visitorFn: any) {
+    //   let baseVisitorFn = toFunctionVisitor.binaryPredicate;
+    //   for (let op in (opMap || {})) {
+    //     let config = opMap[op];
+    //     config.visitorFn = visitorFn;
+    //     updateAliasMap(BinaryPredicate.prototype.aliasMap, op, opMap[op]);
+    //   }
+    //   if (!toFunctionVisitor.isExtended) {
+    //     toFunctionVisitor.binaryPredicate = function (context, expr1Val, expr2Val) {
+    //       let visitorFn = this.aliasMap[this.op.key].visitorFn;
+    //       if (visitorFn) {
+    //         return visitorFn(context, expr1Val, expr2Val);
+    //       } else {
+    //         return baseVisitorFn(context, expr1Val, expr2Val);
+    //       }
+    //     };
+    //     toFunctionVisitor.isExtended = true;
+    //   }
+    // };
+    static extendFuncMap(funcMap) {
+        for (let func in (funcMap || {})) {
+            let config = funcMap[func];
+            FnExpr._funcMap[func] = config;
+        }
+    }
+    ;
+    /**
+    'And's this Predicate with one or more other Predicates and returns a new 'composite' Predicate
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = p1.and(p2, p3);
+  
+    or
+    >      let preds = [p2, p3];
+    >      let newPred = p1.and(preds);
+  
+    The 'and' method is also used to write "fluent" expressions
+    >      let p4 = Predicate.create("ShipCity", "startswith", "F")
+    >        .and("Size", "gt", 2000);
+    @param predicates - multiple Predicates or an array of Predicates.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    and(...args) {
+        return new AndOrPredicate("and", argsForAndOrPredicates(this, args));
+    }
+    /**
+    'Or's this Predicate with one or more other Predicates and returns a new 'composite' Predicate
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = p1.or(p2, p3);
+  
+    or
+    >      let preds = [p2, p3];
+    >      let newPred = p1.or(preds);
+  
+    The 'or' method is also used to write "fluent" expressions
+    >      let p4 = Predicate.create("ShipCity", "startswith", "F")
+    >        .or("Size", "gt", 2000);
+    @param predicates - multiple Predicates or an array of Predicates.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    or(...args) {
+        return new AndOrPredicate("or", argsForAndOrPredicates(this, args));
+    }
+    /**
+    Returns the 'negated' version of this Predicate
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = p1.not();
+  
+    This can also be accomplished using the 'static' version of the 'not' method
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = Predicate.not(p1);
+  
+    which would be the same as
+    >      let not_p1 = Predicate.create("Freight", "le", 100);
+    **/
+    not() {
+        return new UnaryPredicate("not", this);
+    }
+    //
+    toJSON() {
+        // toJSON ( part of js standard - takes a single parameter
+        // that is either "" or the name of the property being serialized.
+        return this.toJSONExt({ entityType: this._entityType });
+    }
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    toJSONExt(context) {
+        return this.visit(context, toJSONVisitor);
+    }
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    toFunction(context) {
+        return this.visit(context, toFunctionVisitor);
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    visit(context, visitor) {
+        if (core.isEmpty(context)) {
+            context = { entityType: undefined };
+        }
+        else if (context instanceof EntityType) {
+            context = { entityType: context };
+        }
+        else if (!core.hasOwnProperty(context, "entityType")) {
+            throw new Error("All visitor methods must be called with a context object containing at least an 'entityType' property");
+        }
+        if (visitor) {
+            context.visitor = visitor;
+        }
+        let tVisitor = visitor || context.visitor;
+        let fn = tVisitor[this.visitorMethodName];
+        if (fn == null) {
+            throw new Error("Unable to locate method: " + this.visitorMethodName + " on visitor");
+        }
+        let entityType = context.entityType;
+        // don't bother validating if already done so ( or if no _validate method
+        if (this._validate && (entityType == null || this._entityType !== entityType)) {
+            // don't need to capture return value because validation fn doesn't have one.
+            // TODO: this was old code
+            // this._validate(entityType, context.usesNameOnServer);
+            this._validate(entityType, context.toNameOnServer);
+            this._entityType = entityType;
+        }
+        return fn.call(this, context);
+    }
+    /** @hidden @internal */
+    _initialize(visitorMethodName, opMap = {}) {
+        this.visitorMethodName = visitorMethodName;
+        let aliasMap = this.aliasMap = {};
+        for (let op in opMap) {
+            updateAliasMap(aliasMap, op, opMap[op]);
+        }
+    }
+    /** @hidden @internal */
+    _resolveOp(op, okIfNotFound) {
+        let opStr = (typeof op === "string") ? op : op.operator;
+        let result = this.aliasMap[opStr.toLowerCase()];
+        if (!result && !okIfNotFound) {
+            throw new Error("Unable to resolve operator: " + opStr);
+        }
+        return result;
+    }
+}
+function createPredicateFromArray(arr) {
+    // TODO: assert that length of the array should be > 3
+    // Needs to handle:
+    //      [ "freight", ">", 100"];
+    //      [ "orders", "any", "freight",  ">", 950 ]
+    //      [ "orders", "and", anotherPred ]
+    //      [ "orders", "and", [ "freight, ">", 950 ]]
+    let json = {};
+    let value = {};
+    json[arr[0]] = value;
+    let op = arr[1];
+    op = op.operator || op; // incoming op will be either a string or a FilterQueryOp
+    if (arr.length === 3) {
+        value[op] = arr[2];
+    }
+    else {
+        value[op] = createPredicateFromArray(arr.splice(2));
+    }
+    return createPredicateFromObject(json);
+}
+function createPredicateFromObject(obj) {
+    if (obj instanceof Predicate)
+        return obj;
+    if (typeof obj !== 'object') {
+        throw new Error("Unable to convert to a Predicate: " + obj);
+    }
+    let keys = Object.keys(obj);
+    let preds = keys.map(function (key) {
+        return createPredicateFromKeyValue(key, obj[key]);
+    });
+    return (preds.length === 1) ? preds[0] : new AndOrPredicate("and", preds);
+}
+function createPredicateFromKeyValue(key, value) {
+    // { and: [a,b] } key='and', value = [a,b]
+    if (AndOrPredicate.prototype._resolveOp(key, true)) {
+        return new AndOrPredicate(key, value);
+    }
+    // { not: a }  key= 'not', value = a
+    if (UnaryPredicate.prototype._resolveOp(key, true)) {
+        return new UnaryPredicate(key, value);
+    }
+    if ((typeof value !== 'object') || value == null || core.isDate(value)) {
+        // { foo: bar } key='foo', value = bar ( where bar is a literal i.e. a string, a number, a boolean or a date.
+        return new BinaryPredicate("eq", key, value);
+    }
+    else if (core.hasOwnProperty(value, 'value')) {
+        // { foo: { value: bar, dataType: xxx} } key='foo', value = bar ( where bar is an object representing a literal
+        return new BinaryPredicate("eq", key, value);
+    }
+    if (Array.isArray(value)) {
+        throw new Error("Unable to resolve predicate after the phrase: " + key);
+    }
+    let expr = key;
+    let keys = Object.keys(value);
+    let preds = keys.map(function (op) {
+        // { a: { any: b } op = 'any', expr=a, value[op] = b
+        if (AnyAllPredicate.prototype._resolveOp(op, true)) {
+            return new AnyAllPredicate(op, expr, value[op]);
+        }
+        if (BinaryPredicate.prototype._resolveOp(op, true)) {
+            // { a: { ">": b }} op = ">", expr=a, value[op] = b
+            return new BinaryPredicate(op, expr, value[op]);
+        }
+        else if (core.hasOwnProperty(value[op], 'value')) {
+            // { a: { ">": { value: b, dataType: 'Int32' }} expr = a value[op] = { value: b, dataType: 'Int32' }
+            return new BinaryPredicate("eq", expr, value[op]);
+        }
+        let msg = core.formatString("Unable to resolve predicate after the phrase: '%1' for operator: '%2'  and value: '%3'", expr, op, value[op]);
+        throw new Error(msg);
+    });
+    return (preds.length === 1) ? preds[0] : new AndOrPredicate("and", preds);
+}
+function argsForAndOrPredicates(obj, args) {
+    let preds = args[0];
+    if (preds instanceof Predicate) {
+        preds = core.arraySlice(args);
+    }
+    else if (!Array.isArray(preds)) {
+        preds = [new Predicate(core.arraySlice(args))];
+    }
+    return [obj].concat(preds);
+}
+function updateAliasMap(aliasMap, opStr, op) {
+    let key = opStr.toLowerCase();
+    op.key = key;
+    aliasMap[key] = op;
+    op.aliases && op.aliases.forEach((alias) => {
+        aliasMap[alias.toLowerCase()] = op;
+    });
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden @internal
+*/
+class PassthruPredicate extends Predicate {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}
+Error['x'] = PassthruPredicate.prototype._initialize('passthruPredicate');
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class UnaryPredicate extends Predicate {
+    pred;
+    constructor(op, ...args) {
+        super();
+        this.op = this._resolveOp(op);
+        this.pred = new Predicate(args);
+    }
+    _validate(entityType, usesNameOnServer) {
+        this.pred._validate(entityType, usesNameOnServer);
+    }
+}
+Error['x'] = UnaryPredicate.prototype._initialize('unaryPredicate', {
+    'not': { aliases: ['!', '~'] },
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class BinaryPredicate extends Predicate {
+    expr1Source;
+    expr2Source;
+    expr1;
+    expr2;
+    constructor(op, expr1, expr2) {
+        super();
+        // 5 public props op, expr1Source, expr2Source, expr1, expr2
+        this.op = this._resolveOp(op);
+        this.expr1Source = expr1;
+        this.expr2Source = expr2;
+        // this.expr1 and this.expr2 won't be
+        // determined until validate is run
+    }
+    _validate(entityType, usesNameOnServer) {
+        let expr1Context = { entityType: entityType, usesNameOnServer: usesNameOnServer };
+        this.expr1 = createExpr(this.expr1Source, expr1Context);
+        if (this.expr1 == null) {
+            throw new Error("Unable to validate 1st expression: " + this.expr1Source);
+        }
+        if (this.expr1 instanceof LitExpr) {
+            // lhs must be either a property or a function.
+            throw new Error("The left hand side of a binary predicate cannot be a literal expression, it must be a valid property or functional predicate expression: " + this.expr1Source);
+        }
+        if (this.op.key === 'in' && !Array.isArray(this.expr2Source)) {
+            throw new Error("The 'in' operator requires that its right hand argument be an array");
+        }
+        let expr2Context = core.extend(expr1Context, { isRHS: true, dataType: this.expr1.dataType });
+        this.expr2 = createExpr(this.expr2Source, expr2Context);
+        if (this.expr2 == null) {
+            throw new Error("Unable to validate 2nd expression: " + this.expr2Source);
+        }
+        if (this.expr1.dataType == null) {
+            this.expr1.dataType = this.expr2.dataType;
+        }
+    }
+}
+Error['x'] = BinaryPredicate.prototype._initialize('binaryPredicate', {
+    'eq': {
+        aliases: ["==", "equals", "equal"]
+    },
+    'ne': {
+        aliases: ["!=", "~=", "notequals", "notequal"]
+    },
+    'lt': {
+        aliases: ["<", "lessthan"]
+    },
+    'le': {
+        aliases: ["<=", "lessthanorequal"]
+    },
+    'gt': {
+        aliases: [">", "greaterthan"]
+    },
+    'ge': {
+        aliases: [">=", "greaterthanorequal"]
+    },
+    'startswith': {
+        isFunction: true
+    },
+    'endswith': {
+        isFunction: true
+    },
+    'contains': {
+        aliases: ["substringof"],
+        isFunction: true
+    },
+    'in': {}
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class AndOrPredicate extends Predicate {
+    preds;
+    constructor(op, preds) {
+        super();
+        this.op = this._resolveOp(op);
+        if (preds.length === 1 && Array.isArray(preds[0])) {
+            preds = preds[0];
+        }
+        this.preds = preds.filter(function (pred) {
+            return pred != null;
+        }).map(function (pred) {
+            return new Predicate(pred);
+        });
+        // TODO: this was removed - test if really needed.
+        // if (this.preds.length === 0) {
+        //   // marker for an empty predicate
+        //   this.op = null;
+        // }
+        if (this.preds.length === 1) {
+            return this.preds[0]; // HACK: this.preds[0] is actually NOT a AndOrPredicate but some other kind of pred.
+        }
+    }
+    _validate(entityType, usesNameOnServer) {
+        this.preds.forEach((pred) => {
+            pred._validate(entityType, usesNameOnServer);
+        });
+    }
+}
+Error['x'] = AndOrPredicate.prototype._initialize("andOrPredicate", {
+    'and': { aliases: ['&&'] },
+    'or': { aliases: ['||'] }
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class AnyAllPredicate extends Predicate {
+    /** @internal */
+    expr;
+    exprSource;
+    pred;
+    // 4 public props: op, exprSource, expr, pred
+    constructor(op, expr, pred) {
+        super();
+        this.op = this._resolveOp(op);
+        this.exprSource = expr;
+        // this.expr will not be resolved until validate is called
+        this.pred = new Predicate(pred);
+    }
+    _validate(entityType, usesNameOnServer) {
+        this.expr = createExpr(this.exprSource, { entityType: entityType, usesNameOnServer: usesNameOnServer });
+        // can't really know the predicateEntityType unless the original entity type was known.
+        if (entityType == null || entityType.isAnonymous) {
+            this.expr.dataType = undefined;
+        }
+        this.pred._validate(this.expr.dataType, usesNameOnServer);
+    }
+}
+Error['x'] = AnyAllPredicate.prototype._initialize("anyAllPredicate", {
+    'any': { aliases: ['some'] },
+    'all': { aliases: ["every"] }
+});
+/** @hidden */
+export class PredicateExpression {
+    visitorMethodName;
+    visit; // TODO
+    dataType;
+    constructor(visitorMethodName) {
+        this.visitorMethodName = visitorMethodName;
+        // give expressions the Predicate prototype method
+        this.visit = Predicate.prototype.visit;
+    }
+    // default impls - may/will be overridden be subclass expressions
+    _validate(entityType, usesNameOnServer) {
+        // noop;
+    }
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class LitExpr extends PredicateExpression {
+    value;
+    hasExplicitDataType;
+    // 2 public props: value, dataType
+    constructor(value, dataType, hasExplicitDataType) {
+        super("litExpr");
+        // dataType may come is an a string
+        let dt1 = resolveDataType(dataType);
+        // if the DataType comes in as Undefined this means
+        // that we should NOT attempt to parse it but just leave it alone
+        // for now - this is usually because it is part of a Func expr.
+        // TODO: cast as DataType seems to be needed by early version of TypeDoc - may be able to remove later
+        let dt2 = (dt1 || DataType.fromValue(value));
+        if (dt2.parse) {
+            if (Array.isArray(value)) {
+                this.value = value.map((v) => { return dt2.parse(v, typeof v); });
+            }
+            else {
+                this.value = dt2.parse(value, typeof value);
+            }
+        }
+        else {
+            this.value = value;
+        }
+        this.dataType = dt2;
+        this.hasExplicitDataType = !!hasExplicitDataType;
+    }
+    toString() {
+        return " LitExpr - value: " + this.value.toString() + " dataType: " + this.dataType.toString();
+    }
+}
+function resolveDataType(dataType) {
+    if (dataType == null)
+        return dataType;
+    // if (DataType.contains(dataType)) {
+    if (dataType instanceof DataType) {
+        return dataType;
+    }
+    if (typeof dataType === 'string') {
+        let dt = DataType.fromName(dataType);
+        if (dt)
+            return dt;
+        throw new Error("Unable to resolve a dataType named: " + dataType);
+    }
+    throw new Error("The dataType parameter passed into this literal expression is not a 'DataType'" + dataType);
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+export class PropExpr extends PredicateExpression {
+    propertyPath;
+    // two public props: propertyPath, dateType
+    constructor(propertyPath) {
+        super('propExpr');
+        this.propertyPath = propertyPath;
+        //this.dataType = DataType.Undefined;
+        // this.dataType resolved after validate ( if not on an anon type }
+    }
+    toString() {
+        return " PropExpr - " + this.propertyPath;
+    }
+    _validate(entityType, usesNameOnServer) {
+        if (entityType == null || entityType.isAnonymous)
+            return;
+        let props = entityType.getPropertiesOnPath(this.propertyPath, null, false);
+        if (!props) {
+            let msg = core.formatString("Unable to resolve propertyPath.  EntityType: '%1'   PropertyPath: '%2'", entityType.name, this.propertyPath);
+            throw new Error(msg);
+        }
+        // get the last property
+        let prop = props[props.length - 1];
+        if (prop instanceof DataProperty) {
+            this.dataType = prop.dataType;
+        }
+        else {
+            this.dataType = prop.entityType;
+        }
+    }
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden @dynamic
+*/
+export class FnExpr extends PredicateExpression {
+    fnName;
+    exprs;
+    localFn; // TODO:
+    constructor(fnName, exprs) {
+        super('fnExpr');
+        // 4 public props: fnName, exprs, localFn, dataType
+        this.fnName = fnName;
+        this.exprs = exprs;
+        let qf = FnExpr._funcMap[fnName];
+        if (qf == null) {
+            throw new Error("Unknown function: " + fnName);
+        }
+        this.localFn = qf.fn;
+        this.dataType = qf.dataType;
+    }
+    toString() {
+        let exprStr = this.exprs.map(function (expr) {
+            expr.toString();
+        }).toString();
+        return "FnExpr - " + this.fnName + "(" + exprStr + ")";
+    }
+    _validate(entityType, usesNameOnServer) {
+        this.exprs.forEach(function (expr) {
+            expr._validate(entityType, usesNameOnServer);
+        });
+    }
+    static _funcMap = {
+        toupper: {
+            fn: function (source) {
+                return source.toUpperCase();
+            }, dataType: DataType.String
+        },
+        tolower: {
+            fn: function (source) {
+                return source.toLowerCase();
+            }, dataType: DataType.String
+        },
+        substring: {
+            fn: function (source, pos, length) {
+                return source.substring(pos, length);
+            }, dataType: DataType.String
+        },
+        substringof: {
+            fn: function (find, source) {
+                return source.indexOf(find) >= 0;
+            }, dataType: DataType.Boolean
+        },
+        length: {
+            fn: function (source) {
+                return source.length;
+            }, dataType: DataType.Int32
+        },
+        trim: {
+            fn: function (source) {
+                return source.trim();
+            }, dataType: DataType.String
+        },
+        concat: {
+            fn: function (s1, s2) {
+                return s1.concat(s2);
+            }, dataType: DataType.String
+        },
+        replace: {
+            fn: function (source, find, replace) {
+                return source.replace(find, replace);
+            }, dataType: DataType.String
+        },
+        startswith: {
+            fn: function (source, find) {
+                return core.stringStartsWith(source, find);
+            }, dataType: DataType.Boolean
+        },
+        endswith: {
+            fn: function (source, find) {
+                return core.stringEndsWith(source, find);
+            }, dataType: DataType.Boolean
+        },
+        indexof: {
+            fn: function (source, find) {
+                return source.indexOf(find);
+            }, dataType: DataType.Int32
+        },
+        round: {
+            fn: function (source) {
+                return Math.round(source);
+            }, dataType: DataType.Int32
+        },
+        ceiling: {
+            fn: function (source) {
+                return Math.ceil(source);
+            }, dataType: DataType.Int32
+        },
+        floor: {
+            fn: function (source) {
+                return Math.floor(source);
+            }, dataType: DataType.Int32
+        },
+        second: {
+            fn: function (source) {
+                return source.getSeconds();
+            }, dataType: DataType.Int32
+        },
+        minute: {
+            fn: function (source) {
+                return source.getMinutes();
+            }, dataType: DataType.Int32
+        },
+        hour: {
+            fn: function (source) {
+                return source.getHours();
+            }, dataType: DataType.Int32
+        },
+        day: {
+            fn: function (source) {
+                return source.getDate();
+            }, dataType: DataType.Int32
+        },
+        month: {
+            fn: function (source) {
+                return source.getMonth() + 1;
+            }, dataType: DataType.Int32
+        },
+        year: {
+            fn: function (source) {
+                return source.getFullYear();
+            }, dataType: DataType.Int32
+        }
+    };
+}
+// TODO: add dataTypes for the args next - will help to infer other dataTypes.
+let RX_IDENTIFIER = /^[a-z_][\w.$]*$/i;
+// comma delimited expressions ignoring commas inside of both single and double quotes.
+let RX_COMMA_DELIM1 = /('[^']*'|[^,]+)/g;
+let RX_COMMA_DELIM2 = /("[^"]*"|[^,]+)/g;
+let DELIM = String.fromCharCode(191);
+function createExpr(source, exprContext) {
+    let entityType = exprContext.entityType;
+    // the right hand side of an 'in' clause
+    if (Array.isArray(source)) {
+        if (!exprContext.isRHS) {
+            throw new Error("Array expressions are only permitted on the right hand side of a BinaryPredicate");
+        }
+        return new LitExpr(source, exprContext.dataType);
+    }
+    if (!(typeof source === 'string')) {
+        if (source != null && typeof source === 'object' && !source.toISOString) {
+            // source is an object but not a Date-like thing such as a JS or MomentJS Date
+            if (source.value === undefined) {
+                throw new Error("Unable to resolve an expression for: " + source + " on entityType: " + (entityType ? entityType.name : 'null'));
+            }
+            if (source.isProperty) {
+                return new PropExpr(source.value);
+            }
+            else {
+                // we want to insure that any LitExpr created this way is tagged with 'hasExplicitDataType: true'
+                // because we want to insure that if we roundtrip thru toJSON that we don't
+                // accidentally reinterpret this node as a PropExpr.
+                // return new LitExpr(source.value, source.dataType || context.dataType, !!source.dataType);
+                return new LitExpr(source.value, source.dataType || exprContext.dataType, true);
+            }
+        }
+        else {
+            return new LitExpr(source, exprContext.dataType);
+        }
+    }
+    if (exprContext.isRHS) {
+        if (entityType == null || entityType.isAnonymous) {
+            // if entityType is unknown then assume that the rhs is a literal
+            return new LitExpr(source, exprContext.dataType);
+        }
+        else {
+            return parseLitOrPropExpr(source, exprContext);
+        }
+    }
+    else {
+        let regex = /\([^()]*\)/;
+        let m;
+        let tokens = [];
+        let i = 0;
+        while (m = regex.exec(source)) {
+            let token = m[0];
+            tokens.push(token);
+            let repl = DELIM + i++;
+            source = source.replace(token, repl);
+        }
+        let expr = parseExpr(source, tokens, exprContext);
+        expr._validate(entityType, exprContext.usesNameOnServer);
+        return expr;
+    }
+}
+function parseExpr(source, tokens, exprContext) {
+    let parts = source.split(DELIM);
+    if (parts.length === 1) {
+        return parseLitOrPropExpr(parts[0], exprContext);
+    }
+    else {
+        return parseFnExpr(source, parts, tokens, exprContext);
+    }
+}
+function parseLitOrPropExpr(value, exprContext) {
+    value = value.trim();
+    // value is either a string, a quoted string, a number, a bool value, or a date
+    // if a string ( not a quoted string) then this represents a property name ( 1st ) or a lit string ( 2nd)
+    let firstChar = value.substr(0, 1);
+    let isQuoted = (firstChar === "'" || firstChar === '"') && value.length > 1 && value.substr(value.length - 1) === firstChar;
+    if (isQuoted) {
+        let unquotedValue = value.substr(1, value.length - 2);
+        return new LitExpr(unquotedValue, exprContext.dataType || DataType.String);
+    }
+    else {
+        let entityType = exprContext.entityType;
+        // TODO: get rid of isAnonymous below when we get the chance.
+        if (entityType == null || entityType.isAnonymous) {
+            // this fork will only be reached on the LHS of an BinaryPredicate -
+            // a RHS expr cannot get here with an anon type
+            return new PropExpr(value);
+        }
+        else {
+            let mayBeIdentifier = RX_IDENTIFIER.test(value);
+            if (mayBeIdentifier) {
+                // if (entityType.getProperty(value, false) != null) {
+                if (entityType.getPropertiesOnPath(value, null, false) != null) {
+                    return new PropExpr(value);
+                }
+            }
+        }
+        // we don't really know the datatype here because even though it comes in as a string
+        // its usually a string BUT it might be a number  i.e. the "1" or the "2" from an expr
+        // like "toUpper(substring(companyName, 1, 2))"
+        return new LitExpr(value, exprContext.dataType);
+    }
+}
+function parseFnExpr(source, parts, tokens, exprContext) {
+    try {
+        let fnName = parts[0].trim().toLowerCase();
+        let argSource = tokens[parts[1]].trim();
+        if (argSource.substr(0, 1) === "(") {
+            argSource = argSource.substr(1, argSource.length - 2);
+        }
+        let commaMatchStr = source.indexOf("'") >= 0 ? RX_COMMA_DELIM1 : RX_COMMA_DELIM2;
+        let args = argSource.match(commaMatchStr);
+        let newContext = core.extend({}, exprContext);
+        // a dataType of Undefined on a context basically means not to try parsing
+        // the value if the expr is a literal
+        newContext.dataType = DataType.Undefined;
+        newContext.isFnArg = true;
+        let exprs = args.map(function (a) {
+            return parseExpr(a, tokens, newContext);
+        });
+        return new FnExpr(fnName, exprs);
+    }
+    catch (e) {
+        // TODO: removed old code here
+        // return null;
+        // and replaced with 
+        throw e;
+    }
+}
+// toFunctionVisitor
+let toFunctionVisitor = {
+    isExtended: false,
+    passthruPredicate: function () {
+        throw new Error("Cannot execute an PassthruPredicate expression against the local cache: " + this.value);
+    },
+    unaryPredicate: function (context) {
+        let predFn = this.pred.visit(context);
+        switch (this.op.key) {
+            case "not":
+                return function (entity) {
+                    return !predFn(entity);
+                };
+            default:
+                throw new Error("Invalid unary operator:" + this.op.key);
+        }
+    },
+    binaryPredicate: function (context) {
+        let expr1Fn = this.expr1.visit(context);
+        let expr2Fn = this.expr2.visit(context);
+        let dataType = this.expr1.dataType || this.expr2.dataType;
+        let lqco = context.entityType.metadataStore.localQueryComparisonOptions;
+        let predFn = getBinaryPredicateFn(this, dataType, lqco);
+        if (predFn == null) {
+            throw new Error("Invalid binaryPredicate operator:" + this.op.key);
+        }
+        return function (entity) {
+            return predFn(expr1Fn(entity), expr2Fn(entity));
+        };
+    },
+    andOrPredicate: function (context) {
+        let predFns = this.preds.map((pred) => {
+            return pred.visit(context);
+        });
+        switch (this.op.key) {
+            case "and":
+                return function (entity) {
+                    let result = predFns.reduce(function (prev, cur) {
+                        return prev && cur(entity);
+                    }, true);
+                    return result;
+                };
+            case "or":
+                return function (entity) {
+                    let result = predFns.reduce(function (prev, cur) {
+                        return prev || cur(entity);
+                    }, false);
+                    return result;
+                };
+            default:
+                throw new Error("Invalid boolean operator:" + this.op.key);
+        }
+    },
+    anyAllPredicate: function (context) {
+        let exprFn = this.expr.visit(context);
+        let newContext = core.extend({}, context);
+        newContext.entityType = this.expr.dataType;
+        let predFn = this.pred.visit(newContext);
+        let anyAllPredFn = getAnyAllPredicateFn(this.op);
+        return function (entity) {
+            return anyAllPredFn(exprFn(entity), predFn);
+        };
+    },
+    litExpr: function () {
+        let value = this.value;
+        return function (entity) {
+            return value;
+        };
+    },
+    propExpr: function () {
+        let propertyPath = this.propertyPath;
+        let properties = propertyPath.split('.');
+        if (properties.length === 1) {
+            return function (entity) {
+                return entity.getProperty(propertyPath);
+            };
+        }
+        else {
+            return function (entity) {
+                return EntityAspect.getPropertyPathValue(entity, properties);
+            };
+        }
+    },
+    fnExpr: function (context) {
+        let exprFns = this.exprs.map(function (expr) {
+            return expr.visit(context);
+        });
+        let that = this;
+        return function (entity) {
+            let values = exprFns.map(function (exprFn) {
+                let value = exprFn(entity);
+                return value;
+            });
+            let result = that.localFn.apply(null, values);
+            return result;
+        };
+    }
+};
+function getAnyAllPredicateFn(op) {
+    switch (op.key) {
+        case "any":
+            return function (v1, v2) {
+                return v1.some(function (v) {
+                    return v2(v);
+                });
+            };
+        case "all":
+            return function (v1, v2) {
+                return v1.every(function (v) {
+                    return v2(v);
+                });
+            };
+        default:
+            throw new Error("Unknown operator: " + op.key);
+    }
+}
+function getBinaryPredicateFn(binaryPredicate, dataType, lqco) {
+    let op = binaryPredicate.op;
+    let mc = DataType.getComparableFn(dataType);
+    let predFn;
+    switch (op.key) {
+        case 'eq':
+            predFn = function (v1, v2) {
+                if (v1 && typeof v1 === 'string') {
+                    return stringEquals(v1, v2, lqco);
+                }
+                else {
+                    return mc(v1) === mc(v2);
+                }
+            };
+            break;
+        case 'ne':
+            predFn = function (v1, v2) {
+                if (v1 && typeof v1 === 'string') {
+                    return !stringEquals(v1, v2, lqco);
+                }
+                else {
+                    return mc(v1) !== mc(v2);
+                }
+            };
+            break;
+        case 'gt':
+            predFn = function (v1, v2) {
+                return mc(v1) > mc(v2);
+            };
+            break;
+        case 'ge':
+            predFn = function (v1, v2) {
+                return mc(v1) >= mc(v2);
+            };
+            break;
+        case 'lt':
+            predFn = function (v1, v2) {
+                return mc(v1) < mc(v2);
+            };
+            break;
+        case 'le':
+            predFn = function (v1, v2) {
+                return mc(v1) <= mc(v2);
+            };
+            break;
+        case 'startswith':
+            predFn = function (v1, v2) {
+                return stringStartsWith(v1, v2, lqco);
+            };
+            break;
+        case 'endswith':
+            predFn = function (v1, v2) {
+                return stringEndsWith(v1, v2, lqco);
+            };
+            break;
+        case 'contains':
+            predFn = function (v1, v2) {
+                return stringContains(v1, v2, lqco);
+            };
+            break;
+        case 'in':
+            predFn = function (v1, v2) {
+                v1 = mc(v1);
+                v2 = v2.map(function (v) { return mc(v); });
+                return v2.indexOf(v1) >= 0;
+            };
+            break;
+        default:
+            return null;
+    }
+    return predFn;
+}
+function stringEquals(a, b, lqco) {
+    if (b == null)
+        return false;
+    if (typeof b !== 'string') {
+        b = b.toString();
+    }
+    if (lqco.usesSql92CompliantStringComparison) {
+        a = (a || "").trim();
+        b = (b || "").trim();
+    }
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return a === b;
+}
+function stringStartsWith(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return core.stringStartsWith(a, b);
+}
+function stringEndsWith(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return core.stringEndsWith(a, b);
+}
+function stringContains(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return a.indexOf(b) >= 0;
+}
+// toJSONVisitor
+let toJSONVisitor = {
+    passthruPredicate: function () {
+        return this.value;
+    },
+    unaryPredicate: function (context) {
+        let predVal = this.pred.visit(context);
+        let json = {};
+        json[this.op.key] = predVal;
+        return json;
+    },
+    binaryPredicate: function (context) {
+        let expr1Val = this.expr1.visit(context);
+        let expr2Val = this.expr2.visit(context);
+        let json = {};
+        if (this.expr2 instanceof PropExpr) {
+            expr2Val = { value: expr2Val, isProperty: true };
+        }
+        if (this.op.key === "eq") {
+            json[expr1Val] = expr2Val;
+        }
+        else {
+            let value = {};
+            json[expr1Val] = value;
+            value[this.op.key] = expr2Val;
+        }
+        return json;
+    },
+    andOrPredicate: function (context) {
+        let predVals = this.preds.map(function (pred) {
+            return pred.visit(context);
+        });
+        if (!predVals || !predVals.length) {
+            return {};
+        }
+        let json;
+        // normalizeAnd clauses if possible.
+        // passthru predicate will appear as string and their 'ands' can't be 'normalized'
+        if (this.op.key === 'and' && predVals.length === 2 && !predVals.some((v) => v.or || typeof (v) === 'string')) {
+            // normalize 'and' clauses - will return null if can't be combined.
+            json = predVals.reduce(combine);
+        }
+        if (json == null) {
+            json = {};
+            json[this.op.key] = predVals;
+        }
+        return json;
+    },
+    anyAllPredicate: function (context) {
+        let exprVal = this.expr.visit(context);
+        let newContext = core.extend({}, context);
+        newContext.entityType = this.expr.dataType;
+        let predVal = this.pred.visit(newContext);
+        let json = {};
+        let value = {};
+        value[this.op.key] = predVal;
+        json[exprVal] = value;
+        return json;
+    },
+    litExpr: function (context) {
+        // special handling for DateOnly because it serializes improperly
+        const value = (this.dataType === DataType.DateOnly) ? DataType.toDateOnlyString(this.value) : this.value;
+        if (this.hasExplicitDataType || context.useExplicitDataType) {
+            return { value: value, dataType: this.dataType.name };
+        }
+        else {
+            return value;
+        }
+    },
+    propExpr: function (context) {
+        if (context.toNameOnServer) {
+            if (!context.entityType) {
+                console.warn(`No EntityType for propertyPath "${this.propertyPath}".  ${core.strings.TO_TYPE}`);
+                return this.propertyPath;
+            }
+            return context.entityType.clientPropertyPathToServer(this.propertyPath);
+        }
+        else {
+            return this.propertyPath;
+        }
+    },
+    fnExpr: function (context) {
+        let exprVals = this.exprs.map(function (expr) {
+            return expr.visit(context);
+        });
+        return this.fnName + "(" + exprVals.join(",") + ")";
+    }
+};
+function combine(j1, j2) {
+    let ok = Object.keys(j2).every(function (key) {
+        if (j1.hasOwnProperty(key)) {
+            if (typeof (j2[key]) !== 'object') {
+                // exit and indicate that we can't combine
+                return false;
+            }
+            if (combine(j1[key], j2[key]) == null) {
+                return false;
+            }
+        }
+        else if (typeof (j1) !== 'object') {
+            // cannot assign to j1[key]
+            return false;
+        }
+        else {
+            j1[key] = j2[key];
+        }
+        return true;
+    });
+    return ok ? j1 : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"predicate.js","sourceRoot":"","sources":["../../../src/predicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAkB,YAAY,EAAG,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAE,QAAQ,EAAG,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAU,MAAM,iBAAiB,CAAC;AA8CvD;;;GAGG;AACH,MAAM,OAAO,SAAS;IASpB;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,GAAG,IAAW;QACxB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAC9B,IAAI,CAAC,CAAC,IAAI,YAAY,SAAS,CAAC,EAAE;YAChC,OAAO,IAAI,SAAS,CAAC,GAAQ,IAAI,CAAC,CAAC;SACpC;QACD,OAAO,SAAS,CAAC,MAAM,CAAC,GAAQ,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,IAAW;QAC1B,2DAA2D;QAE3D,wCAAwC;QACxC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,SAAS,EAAE,CAAC;QAC9C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YACrB,iBAAiB;YACjB,iFAAiF;YACjF,2CAA2C;YAC3C,2FAA2F;YAC3F,yDAAyD;YACzD,IAAI,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;YACvB,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACtB,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;oBACpB,UAAU;oBACV,OAAO,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC9B;qBAAM;oBACL,OAAO,wBAAwB,CAAC,GAAG,CAAC,CAAC;iBACtC;aACF;iBAAM,IAAI,GAAG,YAAY,SAAS,EAAE;gBACnC,OAAO,GAAG,CAAC;aACZ;iBAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;gBAClC,OAAO,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC;aACnC;iBAAM;gBACL,OAAO,yBAAyB,CAAC,GAAG,CAAC,CAAC;aACvC;SACF;aAAM;YACL,kBAAkB;YAClB,wCAAwC;YACxC,yDAAyD;YACzD,OAAO,wBAAwB,CAAC,IAAI,CAAC,CAAC;SACvC;IACH,CAAC;IAED,wBAAwB;IACxB,SAAS,CAAC,UAAkC,EAAE,gBAA0B;QACtE,aAAa;IACf,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,GAAG,CAAC,GAAG,IAAW;QACvB,IAAI,IAAI,GAAG,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC3C,qBAAqB;QACrB,4BAA4B;QAC5B,0BAA0B;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,IAAW;QACtB,IAAI,IAAI,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC1C,0BAA0B;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,GAAG,CAAC,IAAe;QACxB,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,yCAAyC;IACzC,kEAAkE;IAClE,2DAA2D;IAC3D,oCAAoC;IACpC,8BAA8B;IAC9B,oCAAoC;IACpC,yEAAyE;IACzE,MAAM;IACN,yCAAyC;IACzC,mFAAmF;IACnF,8DAA8D;IAC9D,yBAAyB;IACzB,yDAAyD;IACzD,iBAAiB;IACjB,6DAA6D;IAC7D,UAAU;IACV,SAAS;IACT,2CAA2C;IAC3C,MAAM;IACN,KAAK;IAEL,MAAM,CAAC,aAAa,CAAE,OAA2E;QAC/F,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE;YAChC,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YAC3B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;SAChC;IACH,CAAC;IAAA,CAAC;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,CAAC,GAAG,IAAW;QAChB,OAAO,IAAI,cAAc,CAAC,KAAK,EAAE,sBAAsB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,EAAE,CAAC,GAAG,IAAW;QACf,OAAO,IAAI,cAAc,CAAC,IAAI,EAAE,sBAAsB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,GAAG;QACD,OAAO,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,EAAE;IACF,MAAM;QACJ,0DAA0D;QAC1D,kEAAkE;QAClE,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;MAGE;IACF,SAAS,CAAC,OAAqB;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED;;;MAGE;IACF,UAAU,CAAC,OAAqB;QAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAChD,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;MAGE;IACF,KAAK,CAAC,OAAqB,EAAE,OAAiB;QAC5C,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACzB,OAAO,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;SACrC;aAAM,IAAI,OAAO,YAAY,UAAU,EAAE;YACxC,OAAO,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;SACnC;aAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE;YACtD,MAAM,IAAI,KAAK,CAAC,uGAAuG,CAAC,CAAC;SAC1H;QAED,IAAI,OAAO,EAAE;YACX,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;SAC3B;QACD,IAAI,QAAQ,GAAG,OAAO,IAAI,OAAO,CAAC,OAAQ,CAAC;QAC3C,IAAI,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC1C,IAAI,EAAE,IAAI,IAAI,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,IAAI,CAAC,iBAAiB,GAAG,aAAa,CAAC,CAAC;SACvF;QAED,IAAI,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACpC,yEAAyE;QACzE,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,UAAU,CAAC,EAAE;YAC7E,6EAA6E;YAC7E,0BAA0B;YAC1B,wDAAwD;YACxD,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;YACnD,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;SAC/B;QAED,OAAO,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IAED,wBAAwB;IACxB,WAAW,CAAC,iBAAyB,EAAE,QAAwE,EAAE;QAC/G,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,IAAI,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QAClC,KAAK,IAAI,EAAE,IAAI,KAAK,EAAG;YACrB,cAAc,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,CAAO,CAAC,CAAC;SAC/C;IACH,CAAC;IAED,wBAAwB;IACxB,UAAU,CAAC,EAAoB,EAAE,YAAsB;QACrD,IAAI,KAAK,GAAG,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC;QACxD,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,MAAM,IAAI,CAAC,YAAY,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,KAAK,CAAC,CAAC;SACzD;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CAEF;AAED,SAAS,wBAAwB,CAAC,GAAU;IAC1C,sDAAsD;IACtD,mBAAmB;IACnB,gCAAgC;IAChC,iDAAiD;IACjD,wCAAwC;IACxC,kDAAkD;IAClD,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACrB,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB,EAAE,GAAG,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAE,yDAAyD;IAClF,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;QACpB,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;KACpB;SAAM;QACL,KAAK,CAAC,EAAE,CAAC,GAAG,wBAAwB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;KACrD;IACD,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,yBAAyB,CAAC,GAAW;IAC5C,IAAI,GAAG,YAAY,SAAS;QAAE,OAAO,GAAG,CAAC;IAEzC,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,oCAAoC,GAAG,GAAG,CAAC,CAAC;KAC7D;IACD,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG;QAChC,OAAO,2BAA2B,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IACH,OAAO,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,2BAA2B,CAAC,GAAW,EAAE,KAAU;IAC1D,0CAA0C;IAC1C,IAAI,cAAc,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE;QAClD,OAAO,IAAI,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KACvC;IAED,oCAAoC;IACpC,IAAI,cAAc,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE;QAClD,OAAO,IAAI,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KACvC;IAED,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;QACtE,6GAA6G;QAC7G,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;KAC9C;SAAM,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE;QAC9C,+GAA+G;QAC/G,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;KAC9C;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,gDAAgD,GAAG,GAAG,CAAC,CAAC;KACzE;IAED,IAAI,IAAI,GAAG,GAAG,CAAC;IACf,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE;QAE/B,oDAAoD;QACpD,IAAI,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;YAClD,OAAO,IAAI,eAAe,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;SACjD;QAED,IAAI,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;YAClD,mDAAmD;YACnD,OAAO,IAAI,eAAe,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;SACjD;aAAM,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE;YAClD,oGAAoG;YACpG,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;SACnD;QAED,IAAI,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,wFAAwF,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3I,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;IAEvB,CAAC,CAAC,CAAC;IAEH,OAAO,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,sBAAsB,CAAC,GAAO,EAAE,IAAW;IAClD,IAAI,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,IAAI,KAAK,YAAY,SAAS,EAAE;QAC9B,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;KAC/B;SAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;QAChC,KAAK,GAAG,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;KAChD;IACD,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED,SAAS,cAAc,CAAC,QAAe,EAAE,KAAa,EAAE,EAAM;IAC5D,IAAI,GAAG,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAC9B,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC;IACb,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;IAEnB,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;QAC9C,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC;IACrC,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;EAGE;AACF,MAAM,iBAAkB,SAAQ,SAAS;IACvC,KAAK,CAAM;IACX,YAAY,KAAU;QACpB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CAGF;AACD,KAAK,CAAC,GAAG,CAAC,GAAG,iBAAiB,CAAC,SAAS,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC;AAE1E;;;EAGE;AACF,MAAM,OAAO,cAAe,SAAQ,SAAS;IAC3C,IAAI,CAAY;IAChB,YAAY,EAAoB,EAAE,GAAG,IAAW;QAC9C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,SAAS,CAAC,UAAsB,EAAE,gBAA0B;QAC1D,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;IACpD,CAAC;CACF;AAED,KAAK,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,SAAS,CAAC,WAAW,CAAC,gBAAgB,EAAE;IAClE,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;CAC/B,CAAC,CAAC;AAEH;;;EAGE;AACF,MAAM,OAAO,eAAgB,SAAQ,SAAS;IAC5C,WAAW,CAAM;IACjB,WAAW,CAAM;IACjB,KAAK,CAAuB;IAC5B,KAAK,CAAuB;IAC5B,YAAY,EAAoB,EAAE,KAAU,EAAE,KAAU;QACtD,KAAK,EAAE,CAAC;QACR,4DAA4D;QAC5D,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,qCAAqC;QACrC,mCAAmC;IACrC,CAAC;IAGD,SAAS,CAAC,UAAsB,EAAE,gBAA0B;QAC1D,IAAI,YAAY,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;QAClF,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QACxD,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,qCAAqC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;SAC3E;QACD,IAAI,IAAI,CAAC,KAAK,YAAY,OAAO,EAAE;YACjC,+CAA+C;YAC/C,MAAM,IAAI,KAAK,CAAC,2IAA2I,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;SACjL;QAED,IAAI,IAAI,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC5D,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;SACxF;QACD,IAAI,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7F,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QACxD,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,qCAAqC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;SAC3E;QAED,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,EAAE;YAC/B,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;SAC3C;IACH,CAAC;CAGF;AAED,KAAK,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,WAAW,CAAC,iBAAiB,EAAE;IACpE,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC;KACnC;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC;KAC/C;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC;KAC3B;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC;KACnC;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,GAAG,EAAE,aAAa,CAAC;KAC9B;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,IAAI,EAAE,oBAAoB,CAAC;KACtC;IACD,YAAY,EAAE;QACZ,UAAU,EAAE,IAAI;KACjB;IACD,UAAU,EAAE;QACV,UAAU,EAAE,IAAI;KACjB;IACD,UAAU,EAAE;QACV,OAAO,EAAE,CAAC,aAAa,CAAC;QACxB,UAAU,EAAE,IAAI;KACjB;IACD,IAAI,EAAE,EAEL;CACF,CAAC,CAAC;AAEH;;;EAGE;AACF,MAAM,OAAO,cAAe,SAAQ,SAAS;IAC3C,KAAK,CAAc;IACnB,YAAY,EAAoB,EAAE,KAAY;QAC5C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;YACjD,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;SAClB;QACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,UAAU,IAAI;YACtC,OAAO,IAAI,IAAI,IAAI,CAAC;QACtB,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,IAAI;YACnB,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,kDAAkD;QAClD,iCAAiC;QACjC,qCAAqC;QACrC,oBAAoB;QACpB,IAAI;QACJ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAmB,CAAC,CAAC,oFAAoF;SAC7H;IACH,CAAC;IAED,SAAS,CAAC,UAAsB,EAAE,gBAA0B;QAC1D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YAC1B,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED,KAAK,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,SAAS,CAAC,WAAW,CAAC,gBAAgB,EAAE;IAClE,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;CAC1B,CAAE,CAAC;AAEJ;;;EAGE;AACF,MAAM,OAAO,eAAgB,SAAQ,SAAS;IAC5C,gBAAgB;IAChB,IAAI,CAAsB;IAC1B,UAAU,CAAS;IACnB,IAAI,CAAY;IAChB,6CAA6C;IAC7C,YAAY,EAAoB,EAAE,IAAY,EAAE,IAAS;QACvD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,0DAA0D;QAC1D,IAAI,CAAC,IAAI,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,SAAS,CAAC,UAAsB,EAAE,gBAAyB;QACzD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAuB,CAAC,CAAC;QAC7H,uFAAuF;QACvF,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW,EAAE;YAChD,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;SAChC;QACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,QAAkC,EAAE,gBAAgB,CAAC,CAAC;IACtF,CAAC;CAEF;AAED,KAAK,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,WAAW,CAAC,iBAAiB,EAAE;IACpE,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE;IAC5B,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE;CAC9B,CAAC,CAAC;AAEH,cAAc;AACd,MAAM,OAAO,mBAAmB;IAC9B,iBAAiB,CAAS;IAC1B,KAAK,CAAW,CAAC,OAAO;IACxB,QAAQ,CAA6B;IACrC,YAAY,iBAAyB;QACnC,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,kDAAkD;QAClD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC;IACzC,CAAC;IAED,iEAAiE;IACjE,SAAS,CAAC,UAAkC,EAAE,gBAA0B;QACtE,QAAQ;IACV,CAAC;CACF;AAED;;;EAGE;AACF,MAAM,OAAO,OAAQ,SAAQ,mBAAmB;IAC9C,KAAK,CAAM;IACX,mBAAmB,CAAU;IAC7B,kCAAkC;IAClC,YAAY,KAAU,EAAE,QAAuC,EAAE,mBAA6B;QAC5F,KAAK,CAAC,SAAS,CAAC,CAAC;QACjB,mCAAmC;QACnC,IAAI,GAAG,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;QACpC,mDAAmD;QACnD,iEAAiE;QACjE,+DAA+D;QAC/D,sGAAsG;QACtG,IAAI,GAAG,GAAG,CAAC,GAAG,IAAI,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAa,CAAC;QAEzD,IAAI,GAAG,CAAC,KAAK,EAAE;YACb,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACxB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,GAAG,CAAC,KAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACpE;iBAAM;gBACL,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC;aAC7C;SACF;aAAM;YACL,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;SACpB;QACD,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QACpB,IAAI,CAAC,mBAAmB,GAAG,CAAC,CAAC,mBAAmB,CAAC;IACnD,CAAC;IAED,QAAQ;QACN,OAAO,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IACjG,CAAC;CAEF;AAED,SAAS,eAAe,CAAC,QAA4B;IACnD,IAAI,QAAQ,IAAI,IAAI;QAAE,OAAO,QAAQ,CAAC;IACtC,qCAAqC;IACrC,IAAI,QAAQ,YAAY,QAAQ,EAAE;QAChC,OAAO,QAAQ,CAAC;KACjB;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;QAChC,IAAI,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAa,CAAC;QACjD,IAAI,EAAE;YAAE,OAAO,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,sCAAsC,GAAG,QAAQ,CAAC,CAAC;KACpE;IAED,MAAM,IAAI,KAAK,CAAC,gFAAgF,GAAG,QAAQ,CAAC,CAAC;AAC/G,CAAC;AAED;;;EAGE;AACF,MAAM,OAAO,QAAS,SAAQ,mBAAmB;IAC/C,YAAY,CAAS;IACrB,2CAA2C;IAC3C,YAAY,YAAoB;QAC9B,KAAK,CAAC,UAAU,CAAC,CAAC;QAClB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,qCAAqC;QACrC,mEAAmE;IACrE,CAAC;IAED,QAAQ;QACN,OAAO,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC;IAC5C,CAAC;IAED,SAAS,CAAC,UAAkC,EAAE,gBAA0B;QAEtE,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW;YAAE,OAAO;QACzD,IAAI,KAAK,GAAG,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAE3E,IAAI,CAAC,KAAK,EAAE;YACV,IAAI,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,wEAAwE,EAAE,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;YAC1I,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;SACtB;QACD,wBAAwB;QACxB,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACnC,IAAI,IAAI,YAAY,YAAY,EAAE;YAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;SAC/B;aAAM;YACL,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC;SACjC;IACH,CAAC;CAEF;AAED;;;EAGE;AACF,MAAM,OAAO,MAAO,SAAQ,mBAAmB;IAC7C,MAAM,CAAS;IACf,KAAK,CAAwB;IAC7B,OAAO,CAAM,CAAC,QAAQ;IACtB,YAAY,MAAc,EAAE,KAA4B;QACtD,KAAK,CAAC,QAAQ,CAAC,CAAC;QAChB,mDAAmD;QACnD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACjC,IAAI,EAAE,IAAI,IAAI,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,MAAM,CAAC,CAAC;SAChD;QACD,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,QAAQ,CAAC;IAC9B,CAAC;IAED,QAAQ;QACN,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,IAAI;YACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,OAAO,GAAG,GAAG,CAAC;IACzD,CAAC;IAED,SAAS,CAAC,UAAkC,EAAE,gBAA0B;QACtE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,IAAI;YAC/B,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,QAAQ,GAAG;QAChB,OAAO,EAAE;YACP,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;YAC9B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,OAAO,EAAE;YACP,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;YAC9B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,SAAS,EAAE;YACT,EAAE,EAAE,UAAU,MAAc,EAAE,GAAW,EAAE,MAAc;gBACvD,OAAO,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;YACvC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,WAAW,EAAE;YACX,EAAE,EAAE,UAAU,IAAY,EAAE,MAAc;gBACxC,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO;SAC9B;QACD,MAAM,EAAE;YACN,EAAE,EAAE,UAAU,MAAW;gBACvB,OAAO,MAAM,CAAC,MAAM,CAAC;YACvB,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC;YACvB,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,MAAM,EAAE;YACN,EAAE,EAAE,UAAU,EAAU,EAAE,EAAU;gBAClC,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACvB,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,OAAO,EAAE;YACP,EAAE,EAAE,UAAU,MAAc,EAAE,IAAY,EAAE,OAAe;gBACzD,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACvC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC7B;QACD,UAAU,EAAE;YACV,EAAE,EAAE,UAAU,MAAc,EAAE,IAAY;gBACxC,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC7C,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO;SAC9B;QACD,QAAQ,EAAE;YACR,EAAE,EAAE,UAAU,MAAc,EAAE,IAAY;gBACxC,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC3C,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO;SAC9B;QACD,OAAO,EAAE;YACP,EAAE,EAAE,UAAU,MAAW,EAAE,IAAS;gBAClC,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC9B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,KAAK,EAAE;YACL,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC5B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,OAAO,EAAE;YACP,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC3B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,KAAK,EAAE;YACL,EAAE,EAAE,UAAU,MAAc;gBAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC5B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,MAAM,EAAE;YACN,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;YAC7B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,MAAM,EAAE;YACN,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;YAC7B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC3B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,GAAG,EAAE;YACH,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,OAAO,EAAE,CAAC;YAC1B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,KAAK,EAAE;YACL,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC/B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,UAAU,MAAY;gBACxB,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;YAC9B,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;SAC5B;KACF,CAAC;;AAIJ,8EAA8E;AAG9E,IAAI,aAAa,GAAG,kBAAkB,CAAC;AACvC,uFAAuF;AACvF,IAAI,eAAe,GAAG,kBAAkB,CAAC;AACzC,IAAI,eAAe,GAAG,kBAAkB,CAAC;AACzC,IAAI,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;AAErC,SAAS,UAAU,CAAC,MAAW,EAAE,WAA8B;IAC7D,IAAI,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;IAExC,wCAAwC;IACxC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,kFAAkF,CAAC,CAAC;SACrG;QACD,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,QAAS,CAAC,CAAC;KACnD;IAED,IAAI,CAAC,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,EAAE;QACjC,IAAI,MAAM,IAAI,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE;YACvE,8EAA8E;YAC9E,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;gBAC9B,MAAM,IAAI,KAAK,CAAC,uCAAuC,GAAG,MAAM,GAAG,kBAAkB,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;aAClI;YACD,IAAI,MAAM,CAAC,UAAU,EAAE;gBACrB,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;aACnC;iBAAM;gBACL,iGAAiG;gBACjG,2EAA2E;gBAC3E,oDAAoD;gBACpD,4FAA4F;gBAC5F,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,IAAI,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;aACjF;SACF;aAAM;YACL,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;SAClD;KACF;IAED,IAAI,WAAW,CAAC,KAAK,EAAE;QACrB,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW,EAAE;YAChD,iEAAiE;YACjE,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;SAClD;aAAM;YACL,OAAO,kBAAkB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;SAChD;KACF;SAAM;QACL,IAAI,KAAK,GAAG,YAAY,CAAC;QACzB,IAAI,CAAyB,CAAC;QAC9B,IAAI,MAAM,GAAa,EAAE,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YAC7B,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,IAAI,IAAI,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;SACtC;QAED,IAAI,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC;KACb;AACH,CAAC;AAED,SAAS,SAAS,CAAC,MAAc,EAAE,MAAgB,EAAE,WAA8B;IACjF,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;KAClD;SAAM;QACL,OAAO,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;KACxD;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAa,EAAE,WAA8B;IACvE,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IACrB,+EAA+E;IAC/E,yGAAyG;IACzG,IAAI,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnC,IAAI,QAAQ,GAAG,CAAC,SAAS,KAAK,GAAG,IAAI,SAAS,KAAK,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC;IAC5H,IAAI,QAAQ,EAAE;QACZ,IAAI,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACtD,OAAO,IAAI,OAAO,CAAC,aAAa,EAAE,WAAW,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;KAC5E;SAAM;QACL,IAAI,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;QACxC,6DAA6D;QAC7D,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW,EAAE;YAChD,oEAAoE;YACpE,+CAA+C;YAC/C,OAAO,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC5B;aAAM;YACL,IAAI,eAAe,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChD,IAAI,eAAe,EAAE;gBACnB,sDAAsD;gBACtD,IAAI,UAAU,CAAC,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;oBAC9D,OAAO,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;iBAC5B;aACF;SACF;QACD,qFAAqF;QACrF,sFAAsF;QACtF,+CAA+C;QAC/C,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;KACjD;AACH,CAAC;AAED,SAAS,WAAW,CAAC,MAAc,EAAE,KAAe,EAAE,MAAgB,EAAE,WAA8B;IACpG,IAAI;QACF,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAE3C,IAAI,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAY,CAAC;QAClD,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,GAAG,EAAE;YAClC,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;SACvD;QACD,IAAI,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC;QACjF,IAAI,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAC1C,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,WAAW,CAAsB,CAAC;QACnE,0EAA0E;QAC1E,qCAAqC;QACrC,UAAU,CAAC,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC;QACzC,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC;QAC1B,IAAI,KAAK,GAAG,IAAK,CAAC,GAAG,CAAC,UAAU,CAAC;YAC/B,OAAO,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;KAClC;IAAC,OAAO,CAAC,EAAE;QACV,8BAA8B;QAC9B,eAAe;QACf,qBAAqB;QACrB,MAAM,CAAC,CAAC;KACT;AACH,CAAC;AAED,oBAAoB;AAEpB,IAAI,iBAAiB,GAAG;IAEtB,UAAU,EAAE,KAAK;IAEjB,iBAAiB,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,0EAA0E,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3G,CAAC;IAED,cAAc,EAAE,UAAgC,OAAqB;QACnE,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtC,QAAQ,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE;YACnB,KAAK,KAAK;gBACR,OAAO,UAAU,MAAW;oBAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACzB,CAAC,CAAC;YACJ;gBACE,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;SAC5D;IACH,CAAC;IAED,eAAe,EAAE,UAAiC,OAAqB;QACrE,IAAI,OAAO,GAAG,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,OAAO,GAAG,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAM,CAAC,QAAQ,CAAC;QAC5D,IAAI,IAAI,GAAG,OAAO,CAAC,UAAW,CAAC,aAAa,CAAC,2BAA2B,CAAC;QACzE,IAAI,MAAM,GAAG,oBAAoB,CAAC,IAAI,EAAE,QAAoB,EAAE,IAAI,CAAC,CAAC;QACpE,IAAI,MAAM,IAAI,IAAI,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;SACpE;QACD,OAAO,UAAU,MAAc;YAC7B,OAAO,MAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QACnD,CAAC,CAAC;IACJ,CAAC;IAED,cAAc,EAAE,UAAgC,OAAqB;QACnE,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACpC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,QAAQ,IAAI,CAAC,EAAG,CAAC,GAAG,EAAE;YACpB,KAAK,KAAK;gBACR,OAAO,UAAU,MAAW;oBAC1B,IAAI,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,GAAG;wBAC7C,OAAO,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;oBAC7B,CAAC,EAAE,IAAI,CAAC,CAAC;oBACT,OAAO,MAAM,CAAC;gBAChB,CAAC,CAAC;YACJ,KAAK,IAAI;gBACP,OAAO,UAAU,MAAW;oBAC1B,IAAI,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,GAAG;wBAC7C,OAAO,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;oBAC7B,CAAC,EAAE,KAAK,CAAC,CAAC;oBACV,OAAO,MAAM,CAAC;gBAChB,CAAC,CAAC;YACJ;gBACE,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,IAAI,CAAC,EAAG,CAAC,GAAG,CAAC,CAAC;SAC/D;IACH,CAAC;IAED,eAAe,EAAE,UAAiC,OAAqB;QACrE,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAiB,CAAC;QAC1D,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAsB,CAAC;QACzD,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACzC,IAAI,YAAY,GAAG,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjD,OAAO,UAAU,MAAW;YAC1B,OAAO,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;QAC9C,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,EAAE;QACP,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACvB,OAAO,UAAU,MAAW;YAC1B,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IAED,QAAQ,EAAE;QACR,IAAI,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACrC,IAAI,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,UAAU,MAAW;gBAC1B,OAAO,MAAM,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YAC1C,CAAC,CAAC;SACH;aAAM;YACL,OAAO,UAAU,MAAc;gBAC7B,OAAO,YAAY,CAAC,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;YAC/D,CAAC,CAAC;SACH;IACH,CAAC;IAED,MAAM,EAAE,UAAwB,OAA0B;QACxD,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,IAAI;YACzC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,IAAI,GAAG,IAAI,CAAC;QAChB,OAAO,UAAU,MAAW;YAC1B,IAAI,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,MAAM;gBACvC,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC3B,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;YACH,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC9C,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;IACJ,CAAC;CAEF,CAAC;AAEF,SAAS,oBAAoB,CAAC,EAAM;IAClC,QAAQ,EAAE,CAAC,GAAG,EAAE;QACd,KAAK,KAAK;YACR,OAAO,UAAU,EAAE,EAAE,EAAE;gBACrB,OAAO,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;oBACxB,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;gBACf,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;QACJ,KAAK,KAAK;YACR,OAAO,UAAU,EAAE,EAAE,EAAE;gBACrB,OAAO,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC;oBACzB,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;gBACf,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;QACJ;YACE,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;KAClD;AACH,CAAC;AAED,SAAS,oBAAoB,CAAC,eAAgC,EAAE,QAAkB,EAAE,IAAiC;IACnH,IAAI,EAAE,GAAG,eAAe,CAAC,EAAE,CAAC;IAC5B,IAAI,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAC5C,IAAI,MAAqC,CAAC;IAC1C,QAAQ,EAAE,CAAC,GAAG,EAAE;QACd,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE;oBAChC,OAAO,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;iBACnC;qBAAM;oBACL,OAAO,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;iBAC1B;YACH,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE;oBAChC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;iBACpC;qBAAM;oBACL,OAAO,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;iBAC1B;YACH,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YACzB,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;YAC1B,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YACzB,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;YAC1B,CAAC,CAAC;YACF,MAAM;QACR,KAAK,YAAY;YACf,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,gBAAgB,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YACxC,CAAC,CAAC;YACF,MAAM;QACR,KAAK,UAAU;YACb,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC,CAAC;YACF,MAAM;QACR,KAAK,UAAU;YACb,MAAM,GAAG,UAAU,EAAE,EAAE,EAAE;gBACvB,OAAO,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC,CAAC;YACF,MAAM;QACR,KAAK,IAAI;YACP,MAAM,GAAG,UAAU,EAAO,EAAE,EAAS;gBACnC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;gBACZ,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5C,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC,CAAC;YACF,MAAM;QACR;YACE,OAAO,IAAI,CAAC;KACf;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,YAAY,CAAC,CAAM,EAAE,CAAM,EAAE,IAAiC;IACrE,IAAI,CAAC,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IAC5B,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC;KAClB;IACD,IAAI,IAAI,CAAC,kCAAkC,EAAE;QAC3C,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACrB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;KACtB;IACD,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;QACzB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAC5B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;KAC7B;IACD,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAED,SAAS,gBAAgB,CAAC,CAAM,EAAE,CAAM,EAAE,IAAiC;IACzE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;QACzB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAC5B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;KAC7B;IACD,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACrC,CAAC;AAED,SAAS,cAAc,CAAC,CAAM,EAAE,CAAM,EAAE,IAAiC;IACvE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;QACzB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAC5B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;KAC7B;IACD,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,cAAc,CAAC,CAAM,EAAE,CAAM,EAAE,IAAiC;IACvE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;QACzB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAC5B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;KAC7B;IACD,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED,gBAAgB;AAEhB,IAAI,aAAa,GAAG;IAElB,iBAAiB,EAAE;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,cAAc,EAAE,UAAgC,OAAqB;QACnE,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvC,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,eAAe,EAAE,UAAiC,OAAqB;QACrE,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,IAAI,CAAC,KAAK,YAAY,QAAQ,EAAE;YAClC,QAAQ,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAClD;QACD,IAAI,IAAI,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,EAAE;YACxB,IAAI,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;SAC3B;aAAM;YACL,IAAI,KAAK,GAAG,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;YACvB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC;SAC/B;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,cAAc,EAAE,UAAgC,OAAqB;QACnE,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,IAAI;YAC1C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACjC,OAAO,EAAE,CAAC;SACX;QACD,IAAI,IAAwB,CAAC;QAC7B,oCAAoC;QACpC,kFAAkF;QAClF,IAAI,IAAI,CAAC,EAAG,CAAC,GAAG,KAAK,KAAK,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,OAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,EAAE;YAC5G,mEAAmE;YACnE,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;SACjC;QACD,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,IAAI,GAAG,EAAE,CAAC;YACV,IAAI,CAAC,IAAI,CAAC,EAAG,CAAC,GAAI,CAAC,GAAG,QAAQ,CAAC;SAChC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,eAAe,EAAE,UAAiC,OAAqB;QACrE,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvC,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAiB,CAAC;QAC1D,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAsB,CAAC;QACzD,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,UAAyB,OAAqB;QACrD,iEAAiE;QACjE,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;QACzG,IAAI,IAAI,CAAC,mBAAmB,IAAI,OAAO,CAAC,mBAAmB,EAAE;YAC3D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;SACvD;aAAM;YACL,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,QAAQ,EAAE,UAA0B,OAAqB;QACvD,IAAI,OAAO,CAAC,cAAc,EAAE;YAC1B,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;gBACvB,OAAO,CAAC,IAAI,CAAC,mCAAmC,IAAI,CAAC,YAAY,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;gBAChG,OAAO,IAAI,CAAC,YAAY,CAAC;aAC1B;YACD,OAAO,OAAO,CAAC,UAAW,CAAC,0BAA0B,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC1E;aAAM;YACL,OAAO,IAAI,CAAC,YAAY,CAAC;SAC1B;IACH,CAAC;IAED,MAAM,EAAE,UAAwB,OAAqB;QACnD,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,IAAI;YAC1C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IACtD,CAAC;CAEF,CAAC;AAEF,SAAS,OAAO,CAAC,EAAU,EAAE,EAAU;IACrC,IAAI,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,GAAG;QAC1C,IAAI,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YAC1B,IAAI,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,QAAQ,EAAE;gBACjC,0CAA0C;gBAC1C,OAAO,KAAK,CAAC;aACd;YACD,IAAI,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,EAAE;gBACrC,OAAO,KAAK,CAAC;aACd;SACF;aAAM,IAAI,OAAO,CAAC,EAAE,CAAC,KAAK,QAAQ,EAAE;YACnC,2BAA2B;YAC3B,OAAO,KAAK,CAAC;SACd;aAAM;YACL,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;SACnB;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACxB,CAAC","sourcesContent":["import { core } from './core';\r\nimport { EntityType, StructuralType, DataProperty  } from './entity-metadata';\r\nimport { QueryOp } from './entity-query';\r\nimport { DataType  } from './data-type';\r\nimport { EntityAspect, Entity } from './entity-aspect';\r\nimport { LocalQueryComparisonOptions } from './local-query-comparison-options';\r\n\r\nexport interface Op {\r\n  key: string;\r\n  aliases?: string[];\r\n  isFunction?: boolean;\r\n}\r\n\r\n/** @hidden @internal */\r\nexport interface OpMap {\r\n  [key: string]: Op;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface Visitor {\r\n\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface VisitContext {\r\n  entityType?: EntityType;\r\n  // usesNameOnServer?: boolean;\r\n  toNameOnServer?: boolean;\r\n  useExplicitDataType?: boolean;\r\n  visitor?: Visitor;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface ExpressionContext {\r\n  entityType?: EntityType;\r\n  usesNameOnServer?: boolean;\r\n  dataType?: DataType | string;\r\n  isRHS?: boolean;\r\n  isFnArg?: boolean;\r\n}\r\n\r\n/**\r\nUsed to define a 'where' predicate for an [[EntityQuery]].  Predicates are immutable, which means that any\r\nmethod that would modify a Predicate actually returns a new Predicate.\r\n**/\r\nexport class Predicate {\r\n  declare op: Op;\r\n  /** @hidden @internal */\r\n  declare _entityType?: EntityType;\r\n  /** @hidden @internal */\r\n  declare aliasMap: OpMap;\r\n  declare visitorMethodName: string;\r\n\r\n\r\n  /**\r\n  Predicate constructor\r\n  >     let p1 = new Predicate(\"CompanyName\", \"StartsWith\", \"B\");\r\n  >     let query = new EntityQuery(\"Customers\").where(p1);\r\n\r\n  or\r\n  >     let p2 = new Predicate(\"Region\", FilterQueryOp.Equals, null);\r\n  >     let query = new EntityQuery(\"Customers\").where(p2);\r\n  @param property - A property name, a nested property name or an expression involving a property name.\r\n  @param operator - \r\n  @param value - This will be treated as either a property expression or a literal depending on context.  In general,\r\n  if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.\r\n  In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'\r\n  property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any\r\n  literal based on context, if this fails you can force this inference by making the value argument an object with a\r\n  'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.\r\n  **/\r\n  constructor(...args: any[]) {\r\n    if (args.length === 0) return;\r\n    if (!(this instanceof Predicate)) {\r\n      return new Predicate(...<any>args);\r\n    }\r\n    return Predicate.create(...<any>args);\r\n  }\r\n\r\n  /**\r\n  Same as using the ctor.\r\n  >      // so \r\n  >      let p = Predicate.create(a, b, c);\r\n  >      // is the same as \r\n  >      let p = new Predicate(a, b, c); \r\n  @param property -  A property name, a nested property name or an expression involving a property name.\r\n  @param operator - the filter query operator.\r\n  @param value - This will be treated as either a property expression or a literal depending on context.  In general,\r\n  if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.\r\n  In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'\r\n  property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any\r\n  literal based on context, if this fails you can force this inference by making the value argument an object with a\r\n  'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.\r\n  **/\r\n  static create(...args: any[]) {\r\n    // can be called from std javascript without new ( legacy )\r\n\r\n    // empty ctor is used by all subclasses.\r\n    if (args.length === 0) return new Predicate();\r\n    if (args.length === 1) {\r\n      // possibilities:\r\n      //      Predicate([ aPredicate ]) or  Predicate([\"freight\", \">\", 100]) - an array\r\n      //      Predicate(aPredicate) - a predicate\r\n      //      Predicate( \"freight gt 100\" }  // passthru ( i.e. maybe an odata string) - a string\r\n      //      Predicate( { freight: { \">\": 100 } }) - an object\r\n      let arg = arguments[0];\r\n      if (Array.isArray(arg)) {\r\n        if (arg.length === 1) {\r\n          // recurse\r\n          return new Predicate(arg[0]);\r\n        } else {\r\n          return createPredicateFromArray(arg);\r\n        }\r\n      } else if (arg instanceof Predicate) {\r\n        return arg;\r\n      } else if (typeof arg === 'string') {\r\n        return new PassthruPredicate(arg);\r\n      } else {\r\n        return createPredicateFromObject(arg);\r\n      }\r\n    } else {\r\n      // 2 possibilities\r\n      //      Predicate(\"freight\", \">\", 100\");\r\n      //      Predicate(\"orders\", \"any\", \"freight\",  \">\", 950);\r\n      return createPredicateFromArray(args);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    // noop here;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'and'ing a set of specified Predicates together.\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = Predicate.and(p1, p2, p3);\r\n\r\n  or\r\n  >      let preds = [p1, p2, p3];\r\n  >      let newPred = Predicate.and(preds);\r\n  @param predicates - multiple Predicates or an array of Predicate. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  static and(...args: any[]) {\r\n    let pred = new AndOrPredicate(\"and\", args);\r\n    // TODO removed below\r\n    // return undefined if empty\r\n    // return pred.op && pred;\r\n    return pred;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'or'ing a set of specified Predicates together.\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = Predicate.or(p1, p2, p3);\r\n\r\n  or\r\n  >      let preds = [p1, p2, p3];\r\n  >      let newPred = Predicate.or(preds);\r\n  @param predicates - multiple Predicates or an array of Predicate.\r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  static or(...args: any[]) {\r\n    let pred = new AndOrPredicate(\"or\", args);\r\n    // return pred.op && pred;\r\n    return pred;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'negating' a specified predicate.\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = Predicate.not(p1);\r\n\r\n  This can also be accomplished using the 'instance' version of the 'not' method\r\n  >      let not_p1 = p1.not();\r\n\r\n  Both of which would be the same as\r\n  >      let not_p1 = Predicate.create(\"Freight\", \"le\", 100);\r\n  **/\r\n  static not(pred: Predicate) {\r\n    return pred.not();\r\n  }\r\n\r\n  // TODO: determine if/where this is used.\r\n  // static extendBinaryPredicateFn(opMap: IOpMap, visitorFn: any) {\r\n  //   let baseVisitorFn = toFunctionVisitor.binaryPredicate;\r\n  //   for (let op in (opMap || {})) {\r\n  //     let config = opMap[op];\r\n  //     config.visitorFn = visitorFn;\r\n  //     updateAliasMap(BinaryPredicate.prototype.aliasMap, op, opMap[op]);\r\n  //   }\r\n  //   if (!toFunctionVisitor.isExtended) {\r\n  //     toFunctionVisitor.binaryPredicate = function (context, expr1Val, expr2Val) {\r\n  //       let visitorFn = this.aliasMap[this.op.key].visitorFn;\r\n  //       if (visitorFn) {\r\n  //         return visitorFn(context, expr1Val, expr2Val);\r\n  //       } else {\r\n  //         return baseVisitorFn(context, expr1Val, expr2Val);\r\n  //       }\r\n  //     };\r\n  //     toFunctionVisitor.isExtended = true;\r\n  //   }\r\n  // };\r\n\r\n  static extendFuncMap (funcMap: {[key: string]: {fn: (...args: any[]) => any, dataType: DataType}}): void {\r\n    for (let func in (funcMap || {})) {\r\n      let config = funcMap[func];\r\n      FnExpr._funcMap[func] = config;\r\n    }\r\n  };\r\n\r\n  /**\r\n  'And's this Predicate with one or more other Predicates and returns a new 'composite' Predicate\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = p1.and(p2, p3);\r\n\r\n  or\r\n  >      let preds = [p2, p3];\r\n  >      let newPred = p1.and(preds);\r\n\r\n  The 'and' method is also used to write \"fluent\" expressions\r\n  >      let p4 = Predicate.create(\"ShipCity\", \"startswith\", \"F\")\r\n  >        .and(\"Size\", \"gt\", 2000);\r\n  @param predicates - multiple Predicates or an array of Predicates. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  and(...args: any[]) {\r\n    return new AndOrPredicate(\"and\", argsForAndOrPredicates(this, args));\r\n  }\r\n\r\n  /**\r\n  'Or's this Predicate with one or more other Predicates and returns a new 'composite' Predicate\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = p1.or(p2, p3);\r\n\r\n  or\r\n  >      let preds = [p2, p3];\r\n  >      let newPred = p1.or(preds);\r\n\r\n  The 'or' method is also used to write \"fluent\" expressions\r\n  >      let p4 = Predicate.create(\"ShipCity\", \"startswith\", \"F\")\r\n  >        .or(\"Size\", \"gt\", 2000);\r\n  @param predicates - multiple Predicates or an array of Predicates. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  or(...args: any[]) {\r\n    return new AndOrPredicate(\"or\", argsForAndOrPredicates(this, args));\r\n  }\r\n\r\n  /**\r\n  Returns the 'negated' version of this Predicate\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = p1.not();\r\n\r\n  This can also be accomplished using the 'static' version of the 'not' method\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = Predicate.not(p1);\r\n\r\n  which would be the same as\r\n  >      let not_p1 = Predicate.create(\"Freight\", \"le\", 100);\r\n  **/\r\n  not() {\r\n    return new UnaryPredicate(\"not\", this);\r\n  }\r\n\r\n  //\r\n  toJSON() {\r\n    // toJSON ( part of js standard - takes a single parameter\r\n    // that is either \"\" or the name of the property being serialized.\r\n    return this.toJSONExt({ entityType: this._entityType });\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  toJSONExt(context: VisitContext) {\r\n    return this.visit(context, toJSONVisitor);\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  toFunction(context: VisitContext) {\r\n    return this.visit(context, toFunctionVisitor);\r\n  }\r\n\r\n  toString() {\r\n    return JSON.stringify(this);\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  visit(context: VisitContext, visitor?: Visitor) {\r\n    if (core.isEmpty(context)) {\r\n      context = { entityType: undefined };\r\n    } else if (context instanceof EntityType) {\r\n      context = { entityType: context };\r\n    } else if (!core.hasOwnProperty(context, \"entityType\")) {\r\n      throw new Error(\"All visitor methods must be called with a context object containing at least an 'entityType' property\");\r\n    }\r\n\r\n    if (visitor) {\r\n      context.visitor = visitor;\r\n    }\r\n    let tVisitor = visitor || context.visitor!;\r\n    let fn = tVisitor[this.visitorMethodName];\r\n    if (fn == null) {\r\n      throw new Error(\"Unable to locate method: \" + this.visitorMethodName + \" on visitor\");\r\n    }\r\n\r\n    let entityType = context.entityType;\r\n    // don't bother validating if already done so ( or if no _validate method\r\n    if (this._validate && (entityType == null || this._entityType !== entityType)) {\r\n      // don't need to capture return value because validation fn doesn't have one.\r\n      // TODO: this was old code\r\n      // this._validate(entityType, context.usesNameOnServer);\r\n      this._validate(entityType, context.toNameOnServer);\r\n      this._entityType = entityType;\r\n    }\r\n\r\n    return fn.call(this, context);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _initialize(visitorMethodName: string, opMap: { [key: string]: { aliases?: string[], isFunction?: boolean }} = {}) {\r\n    this.visitorMethodName = visitorMethodName;\r\n    let aliasMap = this.aliasMap = {};\r\n    for (let op in opMap ) {\r\n      updateAliasMap(aliasMap, op, opMap[op] as Op);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _resolveOp(op: string | QueryOp, okIfNotFound?: boolean) {\r\n    let opStr = (typeof op === \"string\") ? op : op.operator;\r\n    let result = this.aliasMap[opStr.toLowerCase()];\r\n    if (!result && !okIfNotFound) {\r\n      throw new Error(\"Unable to resolve operator: \" + opStr);\r\n    }\r\n    return result;\r\n  }\r\n\r\n}\r\n\r\nfunction createPredicateFromArray(arr: any[]) {\r\n  // TODO: assert that length of the array should be > 3\r\n  // Needs to handle:\r\n  //      [ \"freight\", \">\", 100\"];\r\n  //      [ \"orders\", \"any\", \"freight\",  \">\", 950 ]\r\n  //      [ \"orders\", \"and\", anotherPred ]\r\n  //      [ \"orders\", \"and\", [ \"freight, \">\", 950 ]]\r\n  let json = {};\r\n  let value = {};\r\n  json[arr[0]] = value;\r\n  let op = arr[1];\r\n  op = op.operator || op;  // incoming op will be either a string or a FilterQueryOp\r\n  if (arr.length === 3) {\r\n    value[op] = arr[2];\r\n  } else {\r\n    value[op] = createPredicateFromArray(arr.splice(2));\r\n  }\r\n  return createPredicateFromObject(json);\r\n}\r\n\r\nfunction createPredicateFromObject(obj: Object) {\r\n  if (obj instanceof Predicate) return obj;\r\n\r\n  if (typeof obj !== 'object') {\r\n    throw new Error(\"Unable to convert to a Predicate: \" + obj);\r\n  }\r\n  let keys = Object.keys(obj);\r\n  let preds = keys.map(function (key) {\r\n    return createPredicateFromKeyValue(key, obj[key]);\r\n  });\r\n  return (preds.length === 1) ? preds[0] : new AndOrPredicate(\"and\", preds);\r\n}\r\n\r\nfunction createPredicateFromKeyValue(key: string, value: any): Predicate {\r\n  // { and: [a,b] } key='and', value = [a,b]\r\n  if (AndOrPredicate.prototype._resolveOp(key, true)) {\r\n    return new AndOrPredicate(key, value);\r\n  }\r\n\r\n  // { not: a }  key= 'not', value = a\r\n  if (UnaryPredicate.prototype._resolveOp(key, true)) {\r\n    return new UnaryPredicate(key, value);\r\n  }\r\n\r\n  if ((typeof value !== 'object') || value == null || core.isDate(value)) {\r\n    // { foo: bar } key='foo', value = bar ( where bar is a literal i.e. a string, a number, a boolean or a date.\r\n    return new BinaryPredicate(\"eq\", key, value);\r\n  } else if (core.hasOwnProperty(value, 'value')) {\r\n    // { foo: { value: bar, dataType: xxx} } key='foo', value = bar ( where bar is an object representing a literal\r\n    return new BinaryPredicate(\"eq\", key, value);\r\n  }\r\n\r\n  if (Array.isArray(value)) {\r\n    throw new Error(\"Unable to resolve predicate after the phrase: \" + key);\r\n  }\r\n\r\n  let expr = key;\r\n  let keys = Object.keys(value);\r\n  let preds = keys.map(function (op) {\r\n\r\n    // { a: { any: b } op = 'any', expr=a, value[op] = b\r\n    if (AnyAllPredicate.prototype._resolveOp(op, true)) {\r\n      return new AnyAllPredicate(op, expr, value[op]);\r\n    }\r\n\r\n    if (BinaryPredicate.prototype._resolveOp(op, true)) {\r\n      // { a: { \">\": b }} op = \">\", expr=a, value[op] = b\r\n      return new BinaryPredicate(op, expr, value[op]);\r\n    } else if (core.hasOwnProperty(value[op], 'value')) {\r\n      // { a: { \">\": { value: b, dataType: 'Int32' }} expr = a value[op] = { value: b, dataType: 'Int32' }\r\n      return new BinaryPredicate(\"eq\", expr, value[op]);\r\n    }\r\n\r\n    let msg = core.formatString(\"Unable to resolve predicate after the phrase: '%1' for operator: '%2'  and value: '%3'\", expr, op, value[op]);\r\n    throw new Error(msg);\r\n\r\n  });\r\n\r\n  return (preds.length === 1) ? preds[0] : new AndOrPredicate(\"and\", preds);\r\n}\r\n\r\nfunction argsForAndOrPredicates(obj: {}, args: any[]) {\r\n  let preds = args[0];\r\n  if (preds instanceof Predicate) {\r\n    preds = core.arraySlice(args);\r\n  } else if (!Array.isArray(preds)) {\r\n    preds = [new Predicate(core.arraySlice(args))];\r\n  }\r\n  return [obj].concat(preds);\r\n}\r\n\r\nfunction updateAliasMap(aliasMap: OpMap, opStr: string, op: Op) {\r\n  let key = opStr.toLowerCase();\r\n  op.key = key;\r\n  aliasMap[key] = op;\r\n\r\n  op.aliases && op.aliases.forEach((alias: any) => {\r\n    aliasMap[alias.toLowerCase()] = op;\r\n  });\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden @internal \r\n*/\r\nclass PassthruPredicate extends Predicate {\r\n  value: any;\r\n  constructor(value: any) {\r\n    super();\r\n    this.value = value;\r\n  }\r\n\r\n  // _validate = core.noop;\r\n}\r\nError['x'] = PassthruPredicate.prototype._initialize('passthruPredicate');\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class UnaryPredicate extends Predicate {\r\n  pred: Predicate;\r\n  constructor(op: string | QueryOp, ...args: any[]) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    this.pred = new Predicate(args);\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    this.pred._validate(entityType, usesNameOnServer);\r\n  }\r\n}\r\n\r\nError['x'] = UnaryPredicate.prototype._initialize('unaryPredicate', {\r\n  'not': { aliases: ['!', '~'] },\r\n});\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class BinaryPredicate extends Predicate {\r\n  expr1Source: any;\r\n  expr2Source: any;\r\n  expr1?: PredicateExpression;\r\n  expr2?: PredicateExpression;\r\n  constructor(op: string | QueryOp, expr1: any, expr2: any) {\r\n    super();\r\n    // 5 public props op, expr1Source, expr2Source, expr1, expr2\r\n    this.op = this._resolveOp(op);\r\n    this.expr1Source = expr1;\r\n    this.expr2Source = expr2;\r\n    // this.expr1 and this.expr2 won't be\r\n    // determined until validate is run\r\n  }\r\n\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    let expr1Context = { entityType: entityType, usesNameOnServer: usesNameOnServer };\r\n    this.expr1 = createExpr(this.expr1Source, expr1Context);\r\n    if (this.expr1 == null) {\r\n      throw new Error(\"Unable to validate 1st expression: \" + this.expr1Source);\r\n    }\r\n    if (this.expr1 instanceof LitExpr) {\r\n      // lhs must be either a property or a function.\r\n      throw new Error(\"The left hand side of a binary predicate cannot be a literal expression, it must be a valid property or functional predicate expression: \" + this.expr1Source);\r\n    }\r\n\r\n    if (this.op.key === 'in' && !Array.isArray(this.expr2Source)) {\r\n      throw new Error(\"The 'in' operator requires that its right hand argument be an array\");\r\n    }\r\n    let expr2Context = core.extend(expr1Context, { isRHS: true, dataType: this.expr1.dataType });\r\n    this.expr2 = createExpr(this.expr2Source, expr2Context);\r\n    if (this.expr2 == null) {\r\n      throw new Error(\"Unable to validate 2nd expression: \" + this.expr2Source);\r\n    }\r\n\r\n    if (this.expr1.dataType == null) {\r\n      this.expr1.dataType = this.expr2.dataType;\r\n    }\r\n  }\r\n\r\n\r\n}\r\n\r\nError['x'] = BinaryPredicate.prototype._initialize('binaryPredicate', {\r\n  'eq': {\r\n    aliases: [\"==\", \"equals\", \"equal\"]\r\n  },\r\n  'ne': {\r\n    aliases: [\"!=\", \"~=\", \"notequals\", \"notequal\"]\r\n  },\r\n  'lt': {\r\n    aliases: [\"<\", \"lessthan\"]\r\n  },\r\n  'le': {\r\n    aliases: [\"<=\", \"lessthanorequal\"]\r\n  },\r\n  'gt': {\r\n    aliases: [\">\", \"greaterthan\"]\r\n  },\r\n  'ge': {\r\n    aliases: [\">=\", \"greaterthanorequal\"]\r\n  },\r\n  'startswith': {\r\n    isFunction: true\r\n  },\r\n  'endswith': {\r\n    isFunction: true\r\n  },\r\n  'contains': {\r\n    aliases: [\"substringof\"],\r\n    isFunction: true\r\n  },\r\n  'in': {\r\n\r\n  }\r\n});\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden\r\n*/\r\nexport class AndOrPredicate extends Predicate {\r\n  preds: Predicate[];\r\n  constructor(op: string | QueryOp, preds: any[]) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    if (preds.length === 1 && Array.isArray(preds[0])) {\r\n      preds = preds[0];\r\n    }\r\n    this.preds = preds.filter(function (pred) {\r\n      return pred != null;\r\n    }).map(function (pred) {\r\n      return new Predicate(pred);\r\n    });\r\n    // TODO: this was removed - test if really needed.\r\n    // if (this.preds.length === 0) {\r\n    //   // marker for an empty predicate\r\n    //   this.op = null;\r\n    // }\r\n    if (this.preds.length === 1) {\r\n      return this.preds[0] as AndOrPredicate; // HACK: this.preds[0] is actually NOT a AndOrPredicate but some other kind of pred.\r\n    }\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    this.preds.forEach((pred) => {\r\n      pred._validate(entityType, usesNameOnServer);\r\n    });\r\n  }\r\n}\r\n\r\nError['x'] = AndOrPredicate.prototype._initialize(\"andOrPredicate\", {\r\n  'and': { aliases: ['&&'] },\r\n  'or': { aliases: ['||'] }\r\n} );\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class AnyAllPredicate extends Predicate {\r\n  /** @internal */\r\n  expr: PredicateExpression;\r\n  exprSource: string;\r\n  pred: Predicate;\r\n  // 4 public props: op, exprSource, expr, pred\r\n  constructor(op: string | QueryOp, expr: string, pred: any) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    this.exprSource = expr;\r\n    // this.expr will not be resolved until validate is called\r\n    this.pred = new Predicate(pred);\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer: boolean) {\r\n    this.expr = createExpr(this.exprSource, { entityType: entityType, usesNameOnServer: usesNameOnServer } as ExpressionContext);\r\n    // can't really know the predicateEntityType unless the original entity type was known.\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      this.expr.dataType = undefined;\r\n    }\r\n    this.pred._validate(this.expr.dataType as EntityType | undefined, usesNameOnServer);\r\n  }\r\n\r\n}\r\n\r\nError['x'] = AnyAllPredicate.prototype._initialize(\"anyAllPredicate\", {\r\n  'any': { aliases: ['some'] },\r\n  'all': { aliases: [\"every\"] }\r\n});\r\n\r\n/** @hidden */\r\nexport class PredicateExpression {\r\n  visitorMethodName: string;\r\n  visit: Function; // TODO\r\n  dataType?: DataType | StructuralType;\r\n  constructor(visitorMethodName: string) {\r\n    this.visitorMethodName = visitorMethodName;\r\n    // give expressions the Predicate prototype method\r\n    this.visit = Predicate.prototype.visit;\r\n  }\r\n\r\n  // default impls - may/will be overridden be subclass expressions\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    // noop;\r\n  }\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class LitExpr extends PredicateExpression {\r\n  value: any;\r\n  hasExplicitDataType: boolean;\r\n  // 2 public props: value, dataType\r\n  constructor(value: any, dataType: string | DataType | undefined, hasExplicitDataType?: boolean) {\r\n    super(\"litExpr\");\r\n    // dataType may come is an a string\r\n    let dt1 = resolveDataType(dataType);\r\n    // if the DataType comes in as Undefined this means\r\n    // that we should NOT attempt to parse it but just leave it alone\r\n    // for now - this is usually because it is part of a Func expr.\r\n    // TODO: cast as DataType seems to be needed by early version of TypeDoc - may be able to remove later\r\n    let dt2 = (dt1 || DataType.fromValue(value)) as DataType;\r\n\r\n    if (dt2.parse) {\r\n      if (Array.isArray(value)) {\r\n        this.value = value.map((v) => { return dt2.parse!(v, typeof v); });\r\n      } else {\r\n        this.value = dt2.parse(value, typeof value);\r\n      }\r\n    } else {\r\n      this.value = value;\r\n    }\r\n    this.dataType = dt2;\r\n    this.hasExplicitDataType = !!hasExplicitDataType;\r\n  }\r\n\r\n  toString() {\r\n    return \" LitExpr - value: \" + this.value.toString() + \" dataType: \" + this.dataType.toString();\r\n  }\r\n\r\n}\r\n\r\nfunction resolveDataType(dataType?: DataType | string) {\r\n  if (dataType == null) return dataType;\r\n  // if (DataType.contains(dataType)) {\r\n  if (dataType instanceof DataType) {\r\n    return dataType;\r\n  }\r\n  if (typeof dataType === 'string') {\r\n    let dt = DataType.fromName(dataType) as DataType;\r\n    if (dt) return dt;\r\n    throw new Error(\"Unable to resolve a dataType named: \" + dataType);\r\n  }\r\n\r\n  throw new Error(\"The dataType parameter passed into this literal expression is not a 'DataType'\" + dataType);\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class PropExpr extends PredicateExpression {\r\n  propertyPath: string;\r\n  // two public props: propertyPath, dateType\r\n  constructor(propertyPath: string) {\r\n    super('propExpr');\r\n    this.propertyPath = propertyPath;\r\n    //this.dataType = DataType.Undefined;\r\n    // this.dataType resolved after validate ( if not on an anon type }\r\n  }\r\n\r\n  toString() {\r\n    return \" PropExpr - \" + this.propertyPath;\r\n  }\r\n\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n\r\n    if (entityType == null || entityType.isAnonymous) return;\r\n    let props = entityType.getPropertiesOnPath(this.propertyPath, null, false);\r\n\r\n    if (!props) {\r\n      let msg = core.formatString(\"Unable to resolve propertyPath.  EntityType: '%1'   PropertyPath: '%2'\", entityType.name, this.propertyPath);\r\n      throw new Error(msg);\r\n    }\r\n    // get the last property\r\n    let prop = props[props.length - 1];\r\n    if (prop instanceof DataProperty) {\r\n      this.dataType = prop.dataType;\r\n    } else {\r\n      this.dataType = prop.entityType;\r\n    }\r\n  }\r\n\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden @dynamic\r\n*/\r\nexport class FnExpr extends PredicateExpression {\r\n  fnName: string;\r\n  exprs: PredicateExpression[];\r\n  localFn: any; // TODO:\r\n  constructor(fnName: string, exprs: PredicateExpression[]) {\r\n    super('fnExpr');\r\n    // 4 public props: fnName, exprs, localFn, dataType\r\n    this.fnName = fnName;\r\n    this.exprs = exprs;\r\n    let qf = FnExpr._funcMap[fnName];\r\n    if (qf == null) {\r\n      throw new Error(\"Unknown function: \" + fnName);\r\n    }\r\n    this.localFn = qf.fn;\r\n    this.dataType = qf.dataType;\r\n  }\r\n\r\n  toString() {\r\n    let exprStr = this.exprs.map(function (expr) {\r\n      expr.toString();\r\n    }).toString();\r\n    return \"FnExpr - \" + this.fnName + \"(\" + exprStr + \")\";\r\n  }\r\n\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    this.exprs.forEach(function (expr) {\r\n      expr._validate(entityType, usesNameOnServer);\r\n    });\r\n  }\r\n\r\n  static _funcMap = {\r\n    toupper: {\r\n      fn: function (source: string) {\r\n        return source.toUpperCase();\r\n      }, dataType: DataType.String\r\n    },\r\n    tolower: {\r\n      fn: function (source: string) {\r\n        return source.toLowerCase();\r\n      }, dataType: DataType.String\r\n    },\r\n    substring: {\r\n      fn: function (source: string, pos: number, length: number) {\r\n        return source.substring(pos, length);\r\n      }, dataType: DataType.String\r\n    },\r\n    substringof: {\r\n      fn: function (find: string, source: string) {\r\n        return source.indexOf(find) >= 0;\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    length: {\r\n      fn: function (source: any) {\r\n        return source.length;\r\n      }, dataType: DataType.Int32\r\n    },\r\n    trim: {\r\n      fn: function (source: string) {\r\n        return source.trim();\r\n      }, dataType: DataType.String\r\n    },\r\n    concat: {\r\n      fn: function (s1: string, s2: string) {\r\n        return s1.concat(s2);\r\n      }, dataType: DataType.String\r\n    },\r\n    replace: {\r\n      fn: function (source: string, find: string, replace: string) {\r\n        return source.replace(find, replace);\r\n      }, dataType: DataType.String\r\n    },\r\n    startswith: {\r\n      fn: function (source: string, find: string) {\r\n        return core.stringStartsWith(source, find);\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    endswith: {\r\n      fn: function (source: string, find: string) {\r\n        return core.stringEndsWith(source, find);\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    indexof: {\r\n      fn: function (source: any, find: any) {\r\n        return source.indexOf(find);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    round: {\r\n      fn: function (source: number) {\r\n        return Math.round(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    ceiling: {\r\n      fn: function (source: number) {\r\n        return Math.ceil(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    floor: {\r\n      fn: function (source: number) {\r\n        return Math.floor(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    second: {\r\n      fn: function (source: Date) {\r\n        return source.getSeconds();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    minute: {\r\n      fn: function (source: Date) {\r\n        return source.getMinutes();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    hour: {\r\n      fn: function (source: Date) {\r\n        return source.getHours();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    day: {\r\n      fn: function (source: Date) {\r\n        return source.getDate();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    month: {\r\n      fn: function (source: Date) {\r\n        return source.getMonth() + 1;\r\n      }, dataType: DataType.Int32\r\n    },\r\n    year: {\r\n      fn: function (source: Date) {\r\n        return source.getFullYear();\r\n      }, dataType: DataType.Int32\r\n    }\r\n  };\r\n\r\n}\r\n\r\n// TODO: add dataTypes for the args next - will help to infer other dataTypes.\r\n\r\n\r\nlet RX_IDENTIFIER = /^[a-z_][\\w.$]*$/i;\r\n// comma delimited expressions ignoring commas inside of both single and double quotes.\r\nlet RX_COMMA_DELIM1 = /('[^']*'|[^,]+)/g;\r\nlet RX_COMMA_DELIM2 = /(\"[^\"]*\"|[^,]+)/g;\r\nlet DELIM = String.fromCharCode(191);\r\n\r\nfunction createExpr(source: any, exprContext: ExpressionContext) {\r\n  let entityType = exprContext.entityType;\r\n\r\n  // the right hand side of an 'in' clause\r\n  if (Array.isArray(source)) {\r\n    if (!exprContext.isRHS) {\r\n      throw new Error(\"Array expressions are only permitted on the right hand side of a BinaryPredicate\");\r\n    }\r\n    return new LitExpr(source, exprContext.dataType!);\r\n  }\r\n\r\n  if (!(typeof source === 'string')) {\r\n    if (source != null && typeof source === 'object' && !source.toISOString) {\r\n      // source is an object but not a Date-like thing such as a JS or MomentJS Date\r\n      if (source.value === undefined) {\r\n        throw new Error(\"Unable to resolve an expression for: \" + source + \" on entityType: \" + (entityType ? entityType.name : 'null'));\r\n      }\r\n      if (source.isProperty) {\r\n        return new PropExpr(source.value);\r\n      } else {\r\n        // we want to insure that any LitExpr created this way is tagged with 'hasExplicitDataType: true'\r\n        // because we want to insure that if we roundtrip thru toJSON that we don't\r\n        // accidentally reinterpret this node as a PropExpr.\r\n        // return new LitExpr(source.value, source.dataType || context.dataType, !!source.dataType);\r\n        return new LitExpr(source.value, source.dataType || exprContext.dataType, true);\r\n      }\r\n    } else {\r\n      return new LitExpr(source, exprContext.dataType);\r\n    }\r\n  }\r\n\r\n  if (exprContext.isRHS) {\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      // if entityType is unknown then assume that the rhs is a literal\r\n      return new LitExpr(source, exprContext.dataType);\r\n    } else {\r\n      return parseLitOrPropExpr(source, exprContext);\r\n    }\r\n  } else {\r\n    let regex = /\\([^()]*\\)/;\r\n    let m: RegExpExecArray | null;\r\n    let tokens: string[] = [];\r\n    let i = 0;\r\n    while (m = regex.exec(source)) {\r\n      let token = m[0];\r\n      tokens.push(token);\r\n      let repl = DELIM + i++;\r\n      source = source.replace(token, repl);\r\n    }\r\n\r\n    let expr = parseExpr(source, tokens, exprContext);\r\n    expr._validate(entityType, exprContext.usesNameOnServer);\r\n    return expr;\r\n  }\r\n}\r\n\r\nfunction parseExpr(source: string, tokens: string[], exprContext: ExpressionContext): PredicateExpression {\r\n  let parts = source.split(DELIM);\r\n  if (parts.length === 1) {\r\n    return parseLitOrPropExpr(parts[0], exprContext);\r\n  } else {\r\n    return parseFnExpr(source, parts, tokens, exprContext);\r\n  }\r\n}\r\n\r\nfunction parseLitOrPropExpr(value: string, exprContext: ExpressionContext): PredicateExpression {\r\n  value = value.trim();\r\n  // value is either a string, a quoted string, a number, a bool value, or a date\r\n  // if a string ( not a quoted string) then this represents a property name ( 1st ) or a lit string ( 2nd)\r\n  let firstChar = value.substr(0, 1);\r\n  let isQuoted = (firstChar === \"'\" || firstChar === '\"') && value.length > 1 && value.substr(value.length - 1) === firstChar;\r\n  if (isQuoted) {\r\n    let unquotedValue = value.substr(1, value.length - 2);\r\n    return new LitExpr(unquotedValue, exprContext.dataType || DataType.String);\r\n  } else {\r\n    let entityType = exprContext.entityType;\r\n    // TODO: get rid of isAnonymous below when we get the chance.\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      // this fork will only be reached on the LHS of an BinaryPredicate -\r\n      // a RHS expr cannot get here with an anon type\r\n      return new PropExpr(value);\r\n    } else {\r\n      let mayBeIdentifier = RX_IDENTIFIER.test(value);\r\n      if (mayBeIdentifier) {\r\n        // if (entityType.getProperty(value, false) != null) {\r\n        if (entityType.getPropertiesOnPath(value, null, false) != null) {\r\n          return new PropExpr(value);\r\n        }\r\n      }\r\n    }\r\n    // we don't really know the datatype here because even though it comes in as a string\r\n    // its usually a string BUT it might be a number  i.e. the \"1\" or the \"2\" from an expr\r\n    // like \"toUpper(substring(companyName, 1, 2))\"\r\n    return new LitExpr(value, exprContext.dataType);\r\n  }\r\n}\r\n\r\nfunction parseFnExpr(source: string, parts: string[], tokens: string[], exprContext: ExpressionContext) {\r\n  try {\r\n    let fnName = parts[0].trim().toLowerCase();\r\n\r\n    let argSource = tokens[parts[1]].trim() as string;\r\n    if (argSource.substr(0, 1) === \"(\") {\r\n      argSource = argSource.substr(1, argSource.length - 2);\r\n    }\r\n    let commaMatchStr = source.indexOf(\"'\") >= 0 ? RX_COMMA_DELIM1 : RX_COMMA_DELIM2;\r\n    let args = argSource.match(commaMatchStr);\r\n    let newContext = core.extend({}, exprContext) as ExpressionContext;\r\n    // a dataType of Undefined on a context basically means not to try parsing\r\n    // the value if the expr is a literal\r\n    newContext.dataType = DataType.Undefined;\r\n    newContext.isFnArg = true;\r\n    let exprs = args!.map(function (a) {\r\n      return parseExpr(a, tokens, newContext);\r\n    });\r\n    return new FnExpr(fnName, exprs);\r\n  } catch (e) {\r\n    // TODO: removed old code here\r\n    // return null;\r\n    // and replaced with \r\n    throw e;\r\n  }\r\n}\r\n\r\n// toFunctionVisitor\r\n\r\nlet toFunctionVisitor = {\r\n\r\n  isExtended: false,\r\n\r\n  passthruPredicate: function (this: PassthruPredicate) {\r\n    throw new Error(\"Cannot execute an PassthruPredicate expression against the local cache: \" + this.value);\r\n  },\r\n\r\n  unaryPredicate: function (this: UnaryPredicate, context: VisitContext) {\r\n    let predFn = this.pred.visit(context);\r\n    switch (this.op.key) {\r\n      case \"not\":\r\n        return function (entity: any) {\r\n          return !predFn(entity);\r\n        };\r\n      default:\r\n        throw new Error(\"Invalid unary operator:\" + this.op.key);\r\n    }\r\n  },\r\n\r\n  binaryPredicate: function (this: BinaryPredicate, context: VisitContext) {\r\n    let expr1Fn = this.expr1!.visit(context);\r\n    let expr2Fn = this.expr2!.visit(context);\r\n    let dataType = this.expr1!.dataType || this.expr2!.dataType;\r\n    let lqco = context.entityType!.metadataStore.localQueryComparisonOptions;\r\n    let predFn = getBinaryPredicateFn(this, dataType as DataType, lqco);\r\n    if (predFn == null) {\r\n      throw new Error(\"Invalid binaryPredicate operator:\" + this.op.key);\r\n    }\r\n    return function (entity: Entity) {\r\n      return predFn!(expr1Fn(entity), expr2Fn(entity));\r\n    };\r\n  },\r\n\r\n  andOrPredicate: function (this: AndOrPredicate, context: VisitContext) {\r\n    let predFns = this.preds.map((pred) => {\r\n      return pred.visit(context);\r\n    });\r\n    switch (this.op!.key) {\r\n      case \"and\":\r\n        return function (entity: any) {\r\n          let result = predFns.reduce(function (prev, cur) {\r\n            return prev && cur(entity);\r\n          }, true);\r\n          return result;\r\n        };\r\n      case \"or\":\r\n        return function (entity: any) {\r\n          let result = predFns.reduce(function (prev, cur) {\r\n            return prev || cur(entity);\r\n          }, false);\r\n          return result;\r\n        };\r\n      default:\r\n        throw new Error(\"Invalid boolean operator:\" + this.op!.key);\r\n    }\r\n  },\r\n\r\n  anyAllPredicate: function (this: AnyAllPredicate, context: VisitContext) {\r\n    let exprFn = this.expr.visit(context);\r\n    let newContext = core.extend({}, context) as VisitContext;\r\n    newContext.entityType = this.expr.dataType as EntityType;\r\n    let predFn = this.pred.visit(newContext);\r\n    let anyAllPredFn = getAnyAllPredicateFn(this.op);\r\n    return function (entity: any) {\r\n      return anyAllPredFn(exprFn(entity), predFn);\r\n    };\r\n  },\r\n\r\n  litExpr: function (this: LitExpr) {\r\n    let value = this.value;\r\n    return function (entity: any) {\r\n      return value;\r\n    };\r\n  },\r\n\r\n  propExpr: function (this: PropExpr) {\r\n    let propertyPath = this.propertyPath;\r\n    let properties = propertyPath.split('.');\r\n    if (properties.length === 1) {\r\n      return function (entity: any) {\r\n        return entity.getProperty(propertyPath);\r\n      };\r\n    } else {\r\n      return function (entity: Entity) {\r\n        return EntityAspect.getPropertyPathValue(entity, properties);\r\n      };\r\n    }\r\n  },\r\n\r\n  fnExpr: function (this: FnExpr, context: ExpressionContext) {\r\n    let exprFns = this.exprs.map(function (expr) {\r\n      return expr.visit(context);\r\n    });\r\n    let that = this;\r\n    return function (entity: any) {\r\n      let values = exprFns.map(function (exprFn) {\r\n        let value = exprFn(entity);\r\n        return value;\r\n      });\r\n      let result = that.localFn.apply(null, values);\r\n      return result;\r\n    };\r\n  }\r\n\r\n};\r\n\r\nfunction getAnyAllPredicateFn(op: Op): (v1: any[], v2: any) => boolean {\r\n  switch (op.key) {\r\n    case \"any\":\r\n      return function (v1, v2) {\r\n        return v1.some(function (v) {\r\n          return v2(v);\r\n        });\r\n      };\r\n    case \"all\":\r\n      return function (v1, v2) {\r\n        return v1.every(function (v) {\r\n          return v2(v);\r\n        });\r\n      };\r\n    default:\r\n      throw new Error(\"Unknown operator: \" + op.key);\r\n  }\r\n}\r\n\r\nfunction getBinaryPredicateFn(binaryPredicate: BinaryPredicate, dataType: DataType, lqco: LocalQueryComparisonOptions) {\r\n  let op = binaryPredicate.op;\r\n  let mc = DataType.getComparableFn(dataType);\r\n  let predFn: (v1: any, v2: any) => boolean;\r\n  switch (op.key) {\r\n    case 'eq':\r\n      predFn = function (v1, v2) {\r\n        if (v1 && typeof v1 === 'string') {\r\n          return stringEquals(v1, v2, lqco);\r\n        } else {\r\n          return mc(v1) === mc(v2);\r\n        }\r\n      };\r\n      break;\r\n    case 'ne':\r\n      predFn = function (v1, v2) {\r\n        if (v1 && typeof v1 === 'string') {\r\n          return !stringEquals(v1, v2, lqco);\r\n        } else {\r\n          return mc(v1) !== mc(v2);\r\n        }\r\n      };\r\n      break;\r\n    case 'gt':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) > mc(v2);\r\n      };\r\n      break;\r\n    case 'ge':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) >= mc(v2);\r\n      };\r\n      break;\r\n    case 'lt':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) < mc(v2);\r\n      };\r\n      break;\r\n    case 'le':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) <= mc(v2);\r\n      };\r\n      break;\r\n    case 'startswith':\r\n      predFn = function (v1, v2) {\r\n        return stringStartsWith(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'endswith':\r\n      predFn = function (v1, v2) {\r\n        return stringEndsWith(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'contains':\r\n      predFn = function (v1, v2) {\r\n        return stringContains(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'in':\r\n      predFn = function (v1: any, v2: any[]) {\r\n        v1 = mc(v1);\r\n        v2 = v2.map(function (v) { return mc(v); });\r\n        return v2.indexOf(v1) >= 0;\r\n      };\r\n      break;\r\n    default:\r\n      return null;\r\n  }\r\n  return predFn;\r\n}\r\n\r\nfunction stringEquals(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (b == null) return false;\r\n  if (typeof b !== 'string') {\r\n    b = b.toString();\r\n  }\r\n  if (lqco.usesSql92CompliantStringComparison) {\r\n    a = (a || \"\").trim();\r\n    b = (b || \"\").trim();\r\n  }\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return a === b;\r\n}\r\n\r\nfunction stringStartsWith(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return core.stringStartsWith(a, b);\r\n}\r\n\r\nfunction stringEndsWith(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return core.stringEndsWith(a, b);\r\n}\r\n\r\nfunction stringContains(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return a.indexOf(b) >= 0;\r\n}\r\n\r\n// toJSONVisitor\r\n\r\nlet toJSONVisitor = {\r\n\r\n  passthruPredicate: function (this: PassthruPredicate) {\r\n    return this.value;\r\n  },\r\n\r\n  unaryPredicate: function (this: UnaryPredicate, context: VisitContext) {\r\n    let predVal = this.pred.visit(context);\r\n    let json = {};\r\n    json[this.op.key] = predVal;\r\n    return json;\r\n  },\r\n\r\n  binaryPredicate: function (this: BinaryPredicate, context: VisitContext) {\r\n    let expr1Val = this.expr1!.visit(context);\r\n    let expr2Val = this.expr2!.visit(context);\r\n    let json = {};\r\n    if (this.expr2 instanceof PropExpr) {\r\n      expr2Val = { value: expr2Val, isProperty: true };\r\n    }\r\n    if (this.op.key === \"eq\") {\r\n      json[expr1Val] = expr2Val;\r\n    } else {\r\n      let value = {};\r\n      json[expr1Val] = value;\r\n      value[this.op.key] = expr2Val;\r\n    }\r\n    return json;\r\n  },\r\n\r\n  andOrPredicate: function (this: AndOrPredicate, context: VisitContext) {\r\n    let predVals = this.preds.map(function (pred) {\r\n      return pred.visit(context);\r\n    });\r\n    if (!predVals || !predVals.length) {\r\n      return {};\r\n    }\r\n    let json: Object | undefined;\r\n    // normalizeAnd clauses if possible.\r\n    // passthru predicate will appear as string and their 'ands' can't be 'normalized'\r\n    if (this.op!.key === 'and' && predVals.length === 2 && !predVals.some((v) => v.or || typeof(v) === 'string')) {\r\n      // normalize 'and' clauses - will return null if can't be combined.\r\n      json = predVals.reduce(combine);\r\n    }\r\n    if (json == null) {\r\n      json = {};\r\n      json[this.op!.key!] = predVals;\r\n    }\r\n    return json;\r\n  },\r\n\r\n  anyAllPredicate: function (this: AnyAllPredicate, context: VisitContext) {\r\n    let exprVal = this.expr.visit(context);\r\n    let newContext = core.extend({}, context) as VisitContext;\r\n    newContext.entityType = this.expr.dataType as EntityType;\r\n    let predVal = this.pred.visit(newContext);\r\n    let json = {};\r\n    let value = {};\r\n    value[this.op.key] = predVal;\r\n    json[exprVal] = value;\r\n    return json;\r\n  },\r\n\r\n  litExpr: function (this: LitExpr, context: VisitContext) {\r\n    // special handling for DateOnly because it serializes improperly\r\n    const value = (this.dataType === DataType.DateOnly) ? DataType.toDateOnlyString(this.value) : this.value;\r\n    if (this.hasExplicitDataType || context.useExplicitDataType) {\r\n      return { value: value, dataType: this.dataType.name };\r\n    } else {\r\n      return value;\r\n    }\r\n  },\r\n\r\n  propExpr: function (this: PropExpr, context: VisitContext) {\r\n    if (context.toNameOnServer) {\r\n      if (!context.entityType) {\r\n        console.warn(`No EntityType for propertyPath \"${this.propertyPath}\".  ${core.strings.TO_TYPE}`);\r\n        return this.propertyPath;\r\n      }\r\n      return context.entityType!.clientPropertyPathToServer(this.propertyPath);\r\n    } else {\r\n      return this.propertyPath;\r\n    }\r\n  },\r\n\r\n  fnExpr: function (this: FnExpr, context: VisitContext) {\r\n    let exprVals = this.exprs.map(function (expr) {\r\n      return expr.visit(context);\r\n    });\r\n    return this.fnName + \"(\" + exprVals.join(\",\") + \")\";\r\n  }\r\n\r\n};\r\n\r\nfunction combine(j1: Object, j2: Object) {\r\n  let ok = Object.keys(j2).every(function (key) {\r\n    if (j1.hasOwnProperty(key)) {\r\n      if (typeof (j2[key]) !== 'object') {\r\n        // exit and indicate that we can't combine\r\n        return false;\r\n      }\r\n      if (combine(j1[key], j2[key]) == null) {\r\n        return false;\r\n      }\r\n    } else if (typeof (j1) !== 'object') {\r\n      // cannot assign to j1[key]\r\n      return false;\r\n    } else {\r\n      j1[key] = j2[key];\r\n    }\r\n    return true;\r\n  });\r\n  return ok ? j1 : null;\r\n}\r\n\r\n\r\n\r\n\r\n"]}