{"version":3,"sources":["webpack:///./node_modules/sift/es5m/index.js"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","this","constructor","create","typeChecker","type","typeString","value","getClassName","toString","comparable","Date","getTime","isArray","map","toJSON","isObject","isVanillaObject","equals","a","length","i","length_1","keys","key","walkKeyPathValues","item","keyPath","next","depth","owner","currentKey","isNaN","Number","BaseOperation","params","owneryQuery","options","init","reset","done","keep","NamedBaseOperation","_super","name","_this","GroupOperation","children","length_2","childrenNext","length_3","childOperation","NamedGroupOperation","QueryOperation","apply","arguments","parent","NestedOperation","_nextNestedValue","createTester","compare","Function","RegExp","result","test","lastIndex","comparableA","EqualsOperation","_test","NopeOperation","numericalOperationCreator","createNumericalOperation","numericalOperation","typeofParams","createNamedOperation","parentQuery","operationCreator","operations","Error","containsOperation","query","charAt","createNestedOperation","nestedQuery","_a","createQueryOperations","selfOperations","nestedOperations","createQueryOperation","_b","assign","_c","ops","push","op","split","createOperationTester","operation","createQueryTester","$Ne","$ElemMatch","_queryOperation","$Size","$Not","$Or","_ops","success","$In","$Nor","_testers","toLowerCase","length_4","$Nin","$Exists","$And","$eq","$ne","$elemMatch","$nin","$in","$lt","$lte","$gt","$gte","$exists","$regex","pattern","$options","$and","ownerQuery","$all","$size"],"mappings":"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","file":"js/chunk-vendors~6548b66e.0608ef75.js","sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nfunction __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\n\nvar typeChecker = function (type) {\n    var typeString = \"[object \" + type + \"]\";\n    return function (value) {\n        return getClassName(value) === typeString;\n    };\n};\nvar getClassName = function (value) { return Object.prototype.toString.call(value); };\nvar comparable = function (value) {\n    if (value instanceof Date) {\n        return value.getTime();\n    }\n    else if (isArray(value)) {\n        return value.map(comparable);\n    }\n    else if (value && typeof value.toJSON === \"function\") {\n        return value.toJSON();\n    }\n    return value;\n};\nvar isArray = typeChecker(\"Array\");\nvar isObject = typeChecker(\"Object\");\nvar isFunction = typeChecker(\"Function\");\nvar isVanillaObject = function (value) {\n    return (value &&\n        (value.constructor === Object ||\n            value.constructor === Array ||\n            value.constructor.toString() === \"function Object() { [native code] }\" ||\n            value.constructor.toString() === \"function Array() { [native code] }\") &&\n        !value.toJSON);\n};\nvar equals = function (a, b) {\n    if (a == null && a == b) {\n        return true;\n    }\n    if (a === b) {\n        return true;\n    }\n    if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {\n        return false;\n    }\n    if (isArray(a)) {\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (var i = 0, length_1 = a.length; i < length_1; i++) {\n            if (!equals(a[i], b[i]))\n                return false;\n        }\n        return true;\n    }\n    else if (isObject(a)) {\n        if (Object.keys(a).length !== Object.keys(b).length) {\n            return false;\n        }\n        for (var key in a) {\n            if (!equals(a[key], b[key]))\n                return false;\n        }\n        return true;\n    }\n    return false;\n};\n\n/**\n * Walks through each value given the context - used for nested operations. E.g:\n * { \"person.address\": { $eq: \"blarg\" }}\n */\nvar walkKeyPathValues = function (item, keyPath, next, depth, key, owner) {\n    var currentKey = keyPath[depth];\n    // if array, then try matching. Might fall through for cases like:\n    // { $eq: [1, 2, 3] }, [ 1, 2, 3 ].\n    if (isArray(item) && isNaN(Number(currentKey))) {\n        for (var i = 0, length_1 = item.length; i < length_1; i++) {\n            // if FALSE is returned, then terminate walker. For operations, this simply\n            // means that the search critera was met.\n            if (!walkKeyPathValues(item[i], keyPath, next, depth, i, item)) {\n                return false;\n            }\n        }\n    }\n    if (depth === keyPath.length || item == null) {\n        return next(item, key, owner);\n    }\n    return walkKeyPathValues(item[currentKey], keyPath, next, depth + 1, currentKey, item);\n};\nvar BaseOperation = /** @class */ (function () {\n    function BaseOperation(params, owneryQuery, options) {\n        this.params = params;\n        this.owneryQuery = owneryQuery;\n        this.options = options;\n        this.init();\n    }\n    BaseOperation.prototype.init = function () { };\n    BaseOperation.prototype.reset = function () {\n        this.done = false;\n        this.keep = false;\n    };\n    return BaseOperation;\n}());\nvar NamedBaseOperation = /** @class */ (function (_super) {\n    __extends(NamedBaseOperation, _super);\n    function NamedBaseOperation(params, owneryQuery, options, name) {\n        var _this = _super.call(this, params, owneryQuery, options) || this;\n        _this.name = name;\n        return _this;\n    }\n    return NamedBaseOperation;\n}(BaseOperation));\nvar GroupOperation = /** @class */ (function (_super) {\n    __extends(GroupOperation, _super);\n    function GroupOperation(params, owneryQuery, options, children) {\n        var _this = _super.call(this, params, owneryQuery, options) || this;\n        _this.children = children;\n        return _this;\n    }\n    /**\n     */\n    GroupOperation.prototype.reset = function () {\n        this.keep = false;\n        this.done = false;\n        for (var i = 0, length_2 = this.children.length; i < length_2; i++) {\n            this.children[i].reset();\n        }\n    };\n    /**\n     */\n    GroupOperation.prototype.childrenNext = function (item, key, owner) {\n        var done = true;\n        var keep = true;\n        for (var i = 0, length_3 = this.children.length; i < length_3; i++) {\n            var childOperation = this.children[i];\n            childOperation.next(item, key, owner);\n            if (!childOperation.keep) {\n                keep = false;\n            }\n            if (childOperation.done) {\n                if (!childOperation.keep) {\n                    break;\n                }\n            }\n            else {\n                done = false;\n            }\n        }\n        this.done = done;\n        this.keep = keep;\n    };\n    return GroupOperation;\n}(BaseOperation));\nvar NamedGroupOperation = /** @class */ (function (_super) {\n    __extends(NamedGroupOperation, _super);\n    function NamedGroupOperation(params, owneryQuery, options, children, name) {\n        var _this = _super.call(this, params, owneryQuery, options, children) || this;\n        _this.name = name;\n        return _this;\n    }\n    return NamedGroupOperation;\n}(GroupOperation));\nvar QueryOperation = /** @class */ (function (_super) {\n    __extends(QueryOperation, _super);\n    function QueryOperation() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     */\n    QueryOperation.prototype.next = function (item, key, parent) {\n        this.childrenNext(item, key, parent);\n    };\n    return QueryOperation;\n}(GroupOperation));\nvar NestedOperation = /** @class */ (function (_super) {\n    __extends(NestedOperation, _super);\n    function NestedOperation(keyPath, params, owneryQuery, options, children) {\n        var _this = _super.call(this, params, owneryQuery, options, children) || this;\n        _this.keyPath = keyPath;\n        /**\n         */\n        _this._nextNestedValue = function (value, key, owner) {\n            _this.childrenNext(value, key, owner);\n            return !_this.done;\n        };\n        return _this;\n    }\n    /**\n     */\n    NestedOperation.prototype.next = function (item, key, parent) {\n        walkKeyPathValues(item, this.keyPath, this._nextNestedValue, 0, key, parent);\n    };\n    return NestedOperation;\n}(GroupOperation));\nvar createTester = function (a, compare) {\n    if (a instanceof Function) {\n        return a;\n    }\n    if (a instanceof RegExp) {\n        return function (b) {\n            var result = typeof b === \"string\" && a.test(b);\n            a.lastIndex = 0;\n            return result;\n        };\n    }\n    var comparableA = comparable(a);\n    return function (b) { return compare(comparableA, comparable(b)); };\n};\nvar EqualsOperation = /** @class */ (function (_super) {\n    __extends(EqualsOperation, _super);\n    function EqualsOperation() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    EqualsOperation.prototype.init = function () {\n        this._test = createTester(this.params, this.options.compare);\n    };\n    EqualsOperation.prototype.next = function (item, key, parent) {\n        if (!Array.isArray(parent) || parent.hasOwnProperty(key)) {\n            if (this._test(item, key, parent)) {\n                this.done = true;\n                this.keep = true;\n            }\n        }\n    };\n    return EqualsOperation;\n}(BaseOperation));\nvar createEqualsOperation = function (params, owneryQuery, options) { return new EqualsOperation(params, owneryQuery, options); };\nvar NopeOperation = /** @class */ (function (_super) {\n    __extends(NopeOperation, _super);\n    function NopeOperation() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NopeOperation.prototype.next = function () {\n        this.done = true;\n        this.keep = false;\n    };\n    return NopeOperation;\n}(BaseOperation));\nvar numericalOperationCreator = function (createNumericalOperation) { return function (params, owneryQuery, options, name) {\n    if (params == null) {\n        return new NopeOperation(params, owneryQuery, options);\n    }\n    return createNumericalOperation(params, owneryQuery, options, name);\n}; };\nvar numericalOperation = function (createTester) {\n    return numericalOperationCreator(function (params, owneryQuery, options) {\n        var typeofParams = typeof comparable(params);\n        var test = createTester(params);\n        return new EqualsOperation(function (b) {\n            return typeof comparable(b) === typeofParams && test(b);\n        }, owneryQuery, options);\n    });\n};\nvar createNamedOperation = function (name, params, parentQuery, options) {\n    var operationCreator = options.operations[name];\n    if (!operationCreator) {\n        throw new Error(\"Unsupported operation: \" + name);\n    }\n    return operationCreator(params, parentQuery, options, name);\n};\nvar containsOperation = function (query) {\n    for (var key in query) {\n        if (key.charAt(0) === \"$\")\n            return true;\n    }\n    return false;\n};\nvar createNestedOperation = function (keyPath, nestedQuery, owneryQuery, options) {\n    if (containsOperation(nestedQuery)) {\n        var _a = createQueryOperations(nestedQuery, options), selfOperations = _a[0], nestedOperations = _a[1];\n        if (nestedOperations.length) {\n            throw new Error(\"Property queries must contain only operations, or exact objects.\");\n        }\n        return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, selfOperations);\n    }\n    return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [\n        new EqualsOperation(nestedQuery, owneryQuery, options)\n    ]);\n};\nvar createQueryOperation = function (query, owneryQuery, _a) {\n    if (owneryQuery === void 0) { owneryQuery = null; }\n    var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;\n    var options = {\n        compare: compare || equals,\n        operations: Object.assign({}, operations || {})\n    };\n    var _c = createQueryOperations(query, options), selfOperations = _c[0], nestedOperations = _c[1];\n    var ops = [];\n    if (selfOperations.length) {\n        ops.push(new NestedOperation([], query, owneryQuery, options, selfOperations));\n    }\n    ops.push.apply(ops, nestedOperations);\n    if (ops.length === 1) {\n        return ops[0];\n    }\n    return new QueryOperation(query, owneryQuery, options, ops);\n};\nvar createQueryOperations = function (query, options) {\n    var selfOperations = [];\n    var nestedOperations = [];\n    if (!isVanillaObject(query)) {\n        selfOperations.push(new EqualsOperation(query, query, options));\n        return [selfOperations, nestedOperations];\n    }\n    for (var key in query) {\n        if (key.charAt(0) === \"$\") {\n            var op = createNamedOperation(key, query[key], query, options);\n            // probably just a flag for another operation (like $options)\n            if (op != null) {\n                selfOperations.push(op);\n            }\n        }\n        else {\n            nestedOperations.push(createNestedOperation(key.split(\".\"), query[key], query, options));\n        }\n    }\n    return [selfOperations, nestedOperations];\n};\nvar createOperationTester = function (operation) { return function (item, key, owner) {\n    operation.reset();\n    operation.next(item, key, owner);\n    return operation.keep;\n}; };\nvar createQueryTester = function (query, options) {\n    if (options === void 0) { options = {}; }\n    return createOperationTester(createQueryOperation(query, null, options));\n};\n\nvar $Ne = /** @class */ (function (_super) {\n    __extends($Ne, _super);\n    function $Ne() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Ne.prototype.init = function () {\n        this._test = createTester(this.params, this.options.compare);\n    };\n    $Ne.prototype.reset = function () {\n        _super.prototype.reset.call(this);\n        this.keep = true;\n    };\n    $Ne.prototype.next = function (item) {\n        if (this._test(item)) {\n            this.done = true;\n            this.keep = false;\n        }\n    };\n    return $Ne;\n}(NamedBaseOperation));\n// https://docs.mongodb.com/manual/reference/operator/query/elemMatch/\nvar $ElemMatch = /** @class */ (function (_super) {\n    __extends($ElemMatch, _super);\n    function $ElemMatch() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $ElemMatch.prototype.init = function () {\n        this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);\n    };\n    $ElemMatch.prototype.reset = function () {\n        _super.prototype.reset.call(this);\n        this._queryOperation.reset();\n    };\n    $ElemMatch.prototype.next = function (item) {\n        if (isArray(item)) {\n            for (var i = 0, length_1 = item.length; i < length_1; i++) {\n                // reset query operation since item being tested needs to pass _all_ query\n                // operations for it to be a success\n                this._queryOperation.reset();\n                // check item\n                this._queryOperation.next(item[i], i, item);\n                this.keep = this.keep || this._queryOperation.keep;\n            }\n            this.done = true;\n        }\n        else {\n            this.done = false;\n            this.keep = false;\n        }\n    };\n    return $ElemMatch;\n}(NamedBaseOperation));\nvar $Not = /** @class */ (function (_super) {\n    __extends($Not, _super);\n    function $Not() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Not.prototype.init = function () {\n        this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);\n    };\n    $Not.prototype.reset = function () {\n        this._queryOperation.reset();\n    };\n    $Not.prototype.next = function (item, key, owner) {\n        this._queryOperation.next(item, key, owner);\n        this.done = this._queryOperation.done;\n        this.keep = !this._queryOperation.keep;\n    };\n    return $Not;\n}(NamedBaseOperation));\nvar $Size = /** @class */ (function (_super) {\n    __extends($Size, _super);\n    function $Size() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Size.prototype.init = function () { };\n    $Size.prototype.next = function (item) {\n        if (isArray(item) && item.length === this.params) {\n            this.done = true;\n            this.keep = true;\n        }\n        // if (parent && parent.length === this.params) {\n        //   this.done = true;\n        //   this.keep = true;\n        // }\n    };\n    return $Size;\n}(NamedBaseOperation));\nvar $Or = /** @class */ (function (_super) {\n    __extends($Or, _super);\n    function $Or() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Or.prototype.init = function () {\n        var _this = this;\n        this._ops = this.params.map(function (op) {\n            return createQueryOperation(op, null, _this.options);\n        });\n    };\n    $Or.prototype.reset = function () {\n        this.done = false;\n        this.keep = false;\n        for (var i = 0, length_2 = this._ops.length; i < length_2; i++) {\n            this._ops[i].reset();\n        }\n    };\n    $Or.prototype.next = function (item, key, owner) {\n        var done = false;\n        var success = false;\n        for (var i = 0, length_3 = this._ops.length; i < length_3; i++) {\n            var op = this._ops[i];\n            op.next(item, key, owner);\n            if (op.keep) {\n                done = true;\n                success = op.keep;\n                break;\n            }\n        }\n        this.keep = success;\n        this.done = done;\n    };\n    return $Or;\n}(NamedBaseOperation));\nvar $Nor = /** @class */ (function (_super) {\n    __extends($Nor, _super);\n    function $Nor() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Nor.prototype.next = function (item, key, owner) {\n        _super.prototype.next.call(this, item, key, owner);\n        this.keep = !this.keep;\n    };\n    return $Nor;\n}($Or));\nvar $In = /** @class */ (function (_super) {\n    __extends($In, _super);\n    function $In() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $In.prototype.init = function () {\n        var _this = this;\n        this._testers = this.params.map(function (value) {\n            if (containsOperation(value)) {\n                throw new Error(\"cannot nest $ under \" + _this.constructor.name.toLowerCase());\n            }\n            return createTester(value, _this.options.compare);\n        });\n    };\n    $In.prototype.next = function (item, key, owner) {\n        var done = false;\n        var success = false;\n        for (var i = 0, length_4 = this._testers.length; i < length_4; i++) {\n            var test = this._testers[i];\n            if (test(item)) {\n                done = true;\n                success = true;\n                break;\n            }\n        }\n        this.keep = success;\n        this.done = done;\n    };\n    return $In;\n}(NamedBaseOperation));\nvar $Nin = /** @class */ (function (_super) {\n    __extends($Nin, _super);\n    function $Nin() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Nin.prototype.next = function (item, key, owner) {\n        _super.prototype.next.call(this, item, key, owner);\n        this.keep = !this.keep;\n    };\n    return $Nin;\n}($In));\nvar $Exists = /** @class */ (function (_super) {\n    __extends($Exists, _super);\n    function $Exists() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    $Exists.prototype.next = function (item, key, owner) {\n        if (owner.hasOwnProperty(key) === this.params) {\n            this.done = true;\n            this.keep = true;\n        }\n    };\n    return $Exists;\n}(NamedBaseOperation));\nvar $And = /** @class */ (function (_super) {\n    __extends($And, _super);\n    function $And(params, owneryQuery, options, name) {\n        return _super.call(this, params, owneryQuery, options, params.map(function (query) { return createQueryOperation(query, owneryQuery, options); }), name) || this;\n    }\n    $And.prototype.next = function (item, key, owner) {\n        this.childrenNext(item, key, owner);\n    };\n    return $And;\n}(NamedGroupOperation));\nvar $eq = function (params, owneryQuery, options) {\n    return new EqualsOperation(params, owneryQuery, options);\n};\nvar $ne = function (params, owneryQuery, options, name) { return new $Ne(params, owneryQuery, options, name); };\nvar $or = function (params, owneryQuery, options, name) { return new $Or(params, owneryQuery, options, name); };\nvar $nor = function (params, owneryQuery, options, name) { return new $Nor(params, owneryQuery, options, name); };\nvar $elemMatch = function (params, owneryQuery, options, name) { return new $ElemMatch(params, owneryQuery, options, name); };\nvar $nin = function (params, owneryQuery, options, name) { return new $Nin(params, owneryQuery, options, name); };\nvar $in = function (params, owneryQuery, options, name) { return new $In(params, owneryQuery, options, name); };\nvar $lt = numericalOperation(function (params) { return function (b) { return b < params; }; });\nvar $lte = numericalOperation(function (params) { return function (b) { return b <= params; }; });\nvar $gt = numericalOperation(function (params) { return function (b) { return b > params; }; });\nvar $gte = numericalOperation(function (params) { return function (b) { return b >= params; }; });\nvar $mod = function (_a, owneryQuery, options) {\n    var mod = _a[0], equalsValue = _a[1];\n    return new EqualsOperation(function (b) { return comparable(b) % mod === equalsValue; }, owneryQuery, options);\n};\nvar $exists = function (params, owneryQuery, options, name) { return new $Exists(params, owneryQuery, options, name); };\nvar $regex = function (pattern, owneryQuery, options) {\n    return new EqualsOperation(new RegExp(pattern, owneryQuery.$options), owneryQuery, options);\n};\nvar $not = function (params, owneryQuery, options, name) { return new $Not(params, owneryQuery, options, name); };\nvar typeAliases = {\n    number: function (v) { return typeof v === \"number\"; },\n    string: function (v) { return typeof v === \"string\"; },\n    bool: function (v) { return typeof v === \"boolean\"; },\n    array: function (v) { return Array.isArray(v); },\n    null: function (v) { return v === null; },\n    timestamp: function (v) { return v instanceof Date; }\n};\nvar $type = function (clazz, owneryQuery, options) {\n    return new EqualsOperation(function (b) {\n        if (typeof clazz === \"string\") {\n            if (!typeAliases[clazz]) {\n                throw new Error(\"Type alias does not exist\");\n            }\n            return typeAliases[clazz](b);\n        }\n        return b != null ? b instanceof clazz || b.constructor === clazz : false;\n    }, owneryQuery, options);\n};\nvar $and = function (params, ownerQuery, options, name) { return new $And(params, ownerQuery, options, name); };\nvar $all = $and;\nvar $size = function (params, ownerQuery, options) { return new $Size(params, ownerQuery, options, \"$size\"); };\nvar $options = function () { return null; };\nvar $where = function (params, ownerQuery, options) {\n    var test;\n    if (isFunction(params)) {\n        test = params;\n    }\n    else if (!process.env.CSP_ENABLED) {\n        test = new Function(\"obj\", \"return \" + params);\n    }\n    else {\n        throw new Error(\"In CSP mode, sift does not support strings in \\\"$where\\\" condition\");\n    }\n    return new EqualsOperation(function (b) { return test.bind(b)(b); }, ownerQuery, options);\n};\n\nvar defaultOperations = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    $Size: $Size,\n    $eq: $eq,\n    $ne: $ne,\n    $or: $or,\n    $nor: $nor,\n    $elemMatch: $elemMatch,\n    $nin: $nin,\n    $in: $in,\n    $lt: $lt,\n    $lte: $lte,\n    $gt: $gt,\n    $gte: $gte,\n    $mod: $mod,\n    $exists: $exists,\n    $regex: $regex,\n    $not: $not,\n    $type: $type,\n    $and: $and,\n    $all: $all,\n    $size: $size,\n    $options: $options,\n    $where: $where\n});\n\nvar createDefaultQueryOperation = function (query, ownerQuery, _a) {\n    var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;\n    return createQueryOperation(query, ownerQuery, {\n        compare: compare,\n        operations: Object.assign({}, defaultOperations, operations || {})\n    });\n};\nvar createDefaultQueryTester = function (query, options) {\n    if (options === void 0) { options = {}; }\n    var op = createDefaultQueryOperation(query, null, options);\n    return createOperationTester(op);\n};\n\nexport default createDefaultQueryTester;\nexport { $Size, $all, $and, $elemMatch, $eq, $exists, $gt, $gte, $in, $lt, $lte, $mod, $ne, $nin, $nor, $not, $options, $or, $regex, $size, $type, $where, EqualsOperation, createDefaultQueryOperation, createEqualsOperation, createOperationTester, createQueryOperation, createQueryTester };\n//# sourceMappingURL=index.js.map\n"],"sourceRoot":""}