sift - npm Package Compare versions

Comparing version 10.0.0 to 11.0.0

changelog.md

@@ -1,8 +0,10 @@
-## 10.0.0
+## 11.0.0
 
 - new custom operations syntax (see API readme)
 - null & undefined are not treated equally (change has been added to keep spec as functionality as possible to MongoDB)
-- `select` option is not supported anymore
-- `compare` option now expects `boolean` return value
+- `select` option has been removed
+- `compare` option now expects `boolean` return value instead of an integer
 - nested queries are no-longer supported
+- `expressions` option is now `operations`
+- `operations` parameter now expects new operations API
 
@@ -9,0 +11,0 @@ ## 9.0.0

index.d.ts

@@ -32,3 +32,2 @@ export type SupportedType =
   $where?: string | WhereFn<T>;
-  $options?: "i" | "g" | "m" | "u";
 };
@@ -35,0 +34,0 @@

lib/core.js

 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var utils_1 = require("./utils");
-var containsOperation = function(query) {
-  for (var key in query) {
-    if (key.charAt(0) === "$") return true;
-  }
-  return false;
+/**
+ * Walks through each value given the context - used for nested operations. E.g:
+ * { "person.address": { $eq: "blarg" }}
+ */
+var walkKeyPathValues = function (item, keyPath, next, depth, key, owner) {
+    var currentKey = keyPath[depth];
+    // if array, then try matching. Might fall through for cases like:
+    // { $eq: [1, 2, 3] }, [ 1, 2, 3 ].
+    if (utils_1.isArray(item) && isNaN(Number(currentKey))) {
+        for (var i = 0, length_1 = item.length; i < length_1; i++) {
+            // if FALSE is returned, then terminate walker. For operations, this simply
+            // means that the search critera was met.
+            if (!walkKeyPathValues(item[i], keyPath, next, depth, i, item)) {
+                return false;
+            }
+        }
+    }
+    if (depth === keyPath.length || item == null) {
+        return next(item, key, owner);
+    }
+    return walkKeyPathValues(item[currentKey], keyPath, next, depth + 1, currentKey, item);
 };
-var spreadValueArray = function(filter) {
-  return function(item, key, parent) {
-    if (!utils_1.isArray(item) || !item.length) {
-      return filter(item, key, parent);
+var BaseOperation = /** @class */ (function () {
+    function BaseOperation(params, owneryQuery, options) {
+        this.params = params;
+        this.owneryQuery = owneryQuery;
+        this.options = options;
+        this.init();
     }
-    for (var i = 0, length_1 = item.length; i < length_1; i++) {
-      if (filter(utils_1.get(item, i), key, parent)) {
-        return true;
-      }
+    BaseOperation.prototype.init = function () { };
+    BaseOperation.prototype.reset = function () {
+        this.done = false;
+        this.success = false;
+    };
+    return BaseOperation;
+}());
+exports.BaseOperation = BaseOperation;
+var GroupOperation = /** @class */ (function (_super) {
+    __extends(GroupOperation, _super);
+    function GroupOperation(params, owneryQuery, options, _children) {
+        var _this = _super.call(this, params, owneryQuery, options) || this;
+        _this._children = _children;
+        return _this;
     }
-    return false;
-  };
+    /**
+     */
+    GroupOperation.prototype.reset = function () {
+        this.success = false;
+        this.done = false;
+        for (var i = 0, length_2 = this._children.length; i < length_2; i++) {
+            this._children[i].reset();
+        }
+    };
+    /**
+     */
+    GroupOperation.prototype.childrenNext = function (item, key, owner) {
+        var done = true;
+        var success = true;
+        for (var i = 0, length_3 = this._children.length; i < length_3; i++) {
+            var childOperation = this._children[i];
+            childOperation.next(item, key, owner);
+            if (!childOperation.success) {
+                success = false;
+            }
+            if (childOperation.done) {
+                if (!childOperation.success) {
+                    break;
+                }
+            }
+            else {
+                done = false;
+            }
+        }
+        this.done = done;
+        this.success = success;
+    };
+    return GroupOperation;
+}(BaseOperation));
+exports.GroupOperation = GroupOperation;
+var QueryOperation = /** @class */ (function (_super) {
+    __extends(QueryOperation, _super);
+    function QueryOperation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     */
+    QueryOperation.prototype.next = function (item, key, parent) {
+        this.childrenNext(item, key, parent);
+    };
+    return QueryOperation;
+}(GroupOperation));
+exports.QueryOperation = QueryOperation;
+var NestedOperation = /** @class */ (function (_super) {
+    __extends(NestedOperation, _super);
+    function NestedOperation(keyPath, params, owneryQuery, options, children) {
+        var _this = _super.call(this, params, owneryQuery, options, children) || this;
+        _this.keyPath = keyPath;
+        /**
+         */
+        _this._nextNestedValue = function (value, key, owner) {
+            _this.childrenNext(value, key, owner);
+            return !_this.done;
+        };
+        return _this;
+    }
+    /**
+     */
+    NestedOperation.prototype.next = function (item, key, parent) {
+        walkKeyPathValues(item, this.keyPath, this._nextNestedValue, 0, key, parent);
+    };
+    return NestedOperation;
+}(GroupOperation));
+exports.NestedOperation = NestedOperation;
+exports.createTester = function (a, compare) {
+    if (a instanceof Function) {
+        return a;
+    }
+    if (a instanceof RegExp) {
+        return function (b) { return typeof b === "string" && a.test(b); };
+    }
+    var comparableA = utils_1.comparable(a);
+    return function (b) { return compare(comparableA, utils_1.comparable(b)); };
 };
-exports.spreadValueArray = spreadValueArray;
-var numericalOperation = function(createFilter) {
-  return function(params) {
-    var comparableParams = utils_1.comparable(params);
-    if (comparableParams == null) return utils_1.nope;
-    return spreadValueArray(createFilter(comparableParams));
-  };
+var EqualsOperation = /** @class */ (function (_super) {
+    __extends(EqualsOperation, _super);
+    function EqualsOperation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EqualsOperation.prototype.init = function () {
+        this._test = exports.createTester(this.params, this.options.compare);
+    };
+    EqualsOperation.prototype.next = function (item, key, parent) {
+        if (this._test(item, key, parent)) {
+            this.done = true;
+            this.success = true;
+        }
+    };
+    return EqualsOperation;
+}(BaseOperation));
+exports.EqualsOperation = EqualsOperation;
+var NopeOperation = /** @class */ (function (_super) {
+    __extends(NopeOperation, _super);
+    function NopeOperation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NopeOperation.prototype.next = function () {
+        this.done = true;
+        this.success = false;
+    };
+    return NopeOperation;
+}(BaseOperation));
+exports.NopeOperation = NopeOperation;
+exports.numericalOperationCreator = function (createNumericalOperation) { return function (params, owneryQuery, options) {
+    return params == null
+        ? new NopeOperation(params, owneryQuery, options)
+        : createNumericalOperation(params, owneryQuery, options);
+}; };
+var createOperation = function (name, params, parentQuery, options) {
+    var operationCreator = options.operations[name];
+    if (!operationCreator) {
+        throw new Error("Unsupported operation: " + name);
+    }
+    return operationCreator(params, parentQuery, options);
 };
-exports.numericalOperation = numericalOperation;
-var createRegexpTester = function(tester) {
-  return function(item) {
-    return typeof item === "string" && tester.test(item);
-  };
-};
-exports.createRegexpTester = createRegexpTester;
-var createTester = function(params, _a) {
-  var _b = _a.compare,
-    compare = _b === void 0 ? utils_1.equals : _b;
-  if (utils_1.isFunction(params)) {
-    return params;
-  }
-  if (params instanceof RegExp) {
-    return createRegexpTester(params);
-  }
-  var comparableParams = utils_1.comparable(params);
-  return function(item, key, parent) {
-    return compare(comparableParams, utils_1.comparable(item));
-  };
-};
-exports.createTester = createTester;
-var createNestedFilter = function(property, query, options) {
-  var filter = containsOperation(query)
-    ? createAndFilter(createQueryFilters(query, options))
-    : createTester(query, options);
-  var pathParts = property.split(".");
-  // If the query contains $ne, need to test all elements ANDed together
-  var inclusive = query && query.$ne != null;
-  return function(item, key, parent) {
-    return filterNested(filter, inclusive, item, pathParts, parent, 0);
-  };
-};
-exports.createNestedFilter = createNestedFilter;
-var filterNested = function(filter, inclusive, item, keyPath, parent, depth) {
-  var currentKey = keyPath[depth];
-  if (utils_1.isArray(item) && isNaN(Number(currentKey))) {
-    var allValid = void 0;
-    for (var i = 0, length_2 = item.length; i < length_2; i++) {
-      var include = filterNested(
-        filter,
-        inclusive,
-        utils_1.get(item, i),
-        keyPath,
-        parent,
-        depth
-      );
-      if (inclusive && allValid != null) {
-        allValid = allValid && include;
-      } else {
-        allValid = allValid || include;
-      }
+var containsOperation = function (query) {
+    for (var key in query) {
+        if (key.charAt(0) === "$")
+            return true;
     }
-    return allValid;
-  }
-  var child = utils_1.get(item, currentKey);
-  if (item && child == null) {
-    return filter(undefined, currentKey, item);
-  }
-  if (depth === keyPath.length - 1) {
-    return filter(child, currentKey, item);
-  }
-  return filterNested(filter, inclusive, child, keyPath, item, depth + 1);
+    return false;
 };
-var createQueryFilters = function(query, options) {
-  var filters = [];
-  if (!utils_1.isVanillaObject(query)) {
-    query = { $eq: query };
-  }
-  for (var property in query) {
-    var params = query[property];
-    // operation
-    if (property.charAt(0) === "$") {
-      filters.push(createOperationFilter(property, params, query, options));
-    } else {
-      filters.push(createNestedFilter(property, params, options));
+var createNestedOperation = function (keyPath, nestedQuery, owneryQuery, options) {
+    if (containsOperation(nestedQuery)) {
+        var _a = createQueryOperations(nestedQuery, options), selfOperations = _a[0], nestedOperations = _a[1];
+        if (nestedOperations.length) {
+            throw new Error("Property queries must contain only operations, or exact objects.");
+        }
+        return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, selfOperations);
     }
-  }
-  return filters;
+    return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [
+        new EqualsOperation(nestedQuery, owneryQuery, options)
+    ]);
 };
-exports.createQueryFilters = createQueryFilters;
-var createOperationFilter = function(operation, params, parentQuery, options) {
-  var createFilter = options.expressions[operation];
-  if (!createFilter) {
-    throw new Error("Unsupported operation " + operation);
-  }
-  return createFilter(params, options, parentQuery);
-};
-var createAndFilter = function(filters) {
-  return function(item, key, parent) {
-    for (var i = filters.length; i--; ) {
-      if (!filters[i](item, key, parent)) return false;
+exports.createQueryOperation = function (query, owneryQuery, options) {
+    var _a = createQueryOperations(query, options), selfOperations = _a[0], nestedOperations = _a[1];
+    var ops = __spreadArrays([
+        new NestedOperation([], query, owneryQuery, options, selfOperations)
+    ], nestedOperations);
+    if (ops.length === 1) {
+        return ops[0];
     }
-    return true;
-  };
+    return new QueryOperation(query, owneryQuery, options, ops);
 };
-exports.createAndFilter = createAndFilter;
-var createOrFilter = function(filters) {
-  return function(item, key, parent) {
-    for (var i = filters.length; i--; ) {
-      if (filters[i](item, key, parent)) return true;
+var createQueryOperations = function (query, options) {
+    var selfOperations = [];
+    var nestedOperations = [];
+    if (!utils_1.isVanillaObject(query)) {
+        query = { $eq: query };
     }
-    return false;
-  };
+    for (var key in query) {
+        if (key.charAt(0) === "$") {
+            var op = createOperation(key, query[key], query, options);
+            // probably just a flag for another operation (like $options)
+            if (op != null) {
+                selfOperations.push(op);
+            }
+        }
+        else {
+            nestedOperations.push(createNestedOperation(key.split("."), query[key], query, options));
+        }
+    }
+    return [selfOperations, nestedOperations];
 };
-exports.createOrFilter = createOrFilter;

lib/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+var operations_1 = require("./operations");
+var core_1 = require("./core");
+exports.EqualsOperation = core_1.EqualsOperation;
 var utils_1 = require("./utils");
-var defaultOperations = require("./operations");
-var core_1 = require("./core");
-var createFilter = function(query, _a) {
-  var _b = _a === void 0 ? {} : _a,
-    compare = _b.compare,
-    expressions = _b.expressions;
-  return core_1.createAndFilter(
-    core_1.createQueryFilters(query, {
-      compare: compare || utils_1.equals,
-      expressions: Object.assign({}, defaultOperations, expressions)
-    })
-  );
+var createRootTester = function (query, _a) {
+    var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
+    var operation = core_1.createQueryOperation(query, null, {
+        compare: compare || utils_1.equals,
+        operations: Object.assign({}, operations_1.creators, operations || {})
+    });
+    return function (item, key, owner) {
+        operation.reset();
+        operation.next(item, key, owner);
+        return operation.success;
+    };
 };
-exports.default = createFilter;
+exports.default = createRootTester;

lib/operations.js

 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("./core");
 var utils_1 = require("./utils");
-var core_1 = require("./core");
-var $eq = function(params, options) {
-  return core_1.spreadValueArray(core_1.createTester(params, options));
+var $Ne = /** @class */ (function (_super) {
+    __extends($Ne, _super);
+    function $Ne() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $Ne.prototype.init = function () {
+        this._test = core_1.createTester(this.params, this.options.compare);
+    };
+    $Ne.prototype.reset = function () {
+        _super.prototype.reset.call(this);
+        this.success = true;
+    };
+    $Ne.prototype.next = function (item) {
+        if (this._test(item)) {
+            this.done = true;
+            this.success = false;
+        }
+    };
+    return $Ne;
+}(core_1.BaseOperation));
+var $ElemMatch = /** @class */ (function (_super) {
+    __extends($ElemMatch, _super);
+    function $ElemMatch() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $ElemMatch.prototype.init = function () {
+        this._queryOperation = core_1.createQueryOperation(this.params, this.owneryQuery, this.options);
+    };
+    $ElemMatch.prototype.reset = function () {
+        this._queryOperation.reset();
+    };
+    $ElemMatch.prototype.next = function (item, key, owner) {
+        this._queryOperation.next(item, key, owner);
+        this.done = this._queryOperation.done;
+        this.success = this._queryOperation.success;
+    };
+    return $ElemMatch;
+}(core_1.BaseOperation));
+var $Not = /** @class */ (function (_super) {
+    __extends($Not, _super);
+    function $Not() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $Not.prototype.next = function (item, key, owner) {
+        _super.prototype.next.call(this, item, key, owner);
+        this.success = !this.success;
+    };
+    return $Not;
+}($ElemMatch));
+var $Or = /** @class */ (function (_super) {
+    __extends($Or, _super);
+    function $Or() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $Or.prototype.init = function () {
+        var _this = this;
+        this._ops = this.params.map(function (op) {
+            return core_1.createQueryOperation(op, null, _this.options);
+        });
+    };
+    $Or.prototype.reset = function () {
+        this.done = false;
+        this.success = false;
+        for (var i = 0, length_1 = this._ops.length; i < length_1; i++) {
+            this._ops[i].reset();
+        }
+    };
+    $Or.prototype.next = function (item, key, owner) {
+        var done = false;
+        var success = false;
+        for (var i = 0, length_2 = this._ops.length; i < length_2; i++) {
+            var op = this._ops[i];
+            op.next(item, key, owner);
+            if (op.success) {
+                done = true;
+                success = op.success;
+                break;
+            }
+        }
+        this.success = success;
+        this.done = done;
+    };
+    return $Or;
+}(core_1.BaseOperation));
+var $Nor = /** @class */ (function (_super) {
+    __extends($Nor, _super);
+    function $Nor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $Nor.prototype.next = function (item, key, owner) {
+        _super.prototype.next.call(this, item, key, owner);
+        this.success = !this.success;
+    };
+    return $Nor;
+}($Or));
+var $Exists = /** @class */ (function (_super) {
+    __extends($Exists, _super);
+    function $Exists() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    $Exists.prototype.next = function (item, key, owner) {
+        if (owner.hasOwnProperty(key) === this.params) {
+            this.done = true;
+            this.success = true;
+        }
+    };
+    return $Exists;
+}(core_1.BaseOperation));
+var $And = /** @class */ (function (_super) {
+    __extends($And, _super);
+    function $And(params, owneryQuery, options) {
+        return _super.call(this, params, owneryQuery, options, params.map(function (query) { return core_1.createQueryOperation(query, owneryQuery, options); })) || this;
+    }
+    $And.prototype.next = function (item, key, owner) {
+        this.childrenNext(item, key, owner);
+    };
+    return $And;
+}(core_1.GroupOperation));
+var $eq = function (params, owneryQuery, options) {
+    return new core_1.EqualsOperation(params, owneryQuery, options);
 };
-exports.$eq = $eq;
-var $ne = function(params, options) {
-  var filter = $eq(params, options);
-  return function(item, key, parent) {
-    return !filter(item, key, parent);
-  };
+var $ne = function (params, owneryQuery, options) {
+    return new $Ne(params, owneryQuery, options);
 };
-exports.$ne = $ne;
-var $gt = core_1.numericalOperation(function(params) {
-  return function(item) {
-    return utils_1.comparable(item) > params;
-  };
-});
-exports.$gt = $gt;
-var $gte = core_1.numericalOperation(function(params) {
-  return function(item) {
-    return utils_1.comparable(item) >= params;
-  };
-});
-exports.$gte = $gte;
-var $lt = core_1.numericalOperation(function(params) {
-  return function(item) {
-    return utils_1.comparable(item) < params;
-  };
-});
-exports.$lt = $lt;
-var $lte = core_1.numericalOperation(function(params) {
-  return function(item) {
-    return utils_1.comparable(item) <= params;
-  };
-});
-exports.$lte = $lte;
-var $mod = core_1.numericalOperation(function(_a) {
-  var mod = _a[0],
-    equalsValue = _a[1];
-  return function(item) {
-    return utils_1.comparable(item) % mod === equalsValue;
-  };
-});
-exports.$mod = $mod;
-var $exists = function(params) {
-  return core_1.spreadValueArray(function(item, key, parent) {
-    return parent.hasOwnProperty(key) === params;
-  });
+var $or = function (params, owneryQuery, options) {
+    return new $Or(params, owneryQuery, options);
 };
-exports.$exists = $exists;
-var $in = function(params, options) {
-  var filter = $or(params, options);
-  return function(item, key, parent) {
-    return filter(item, key, parent);
-  };
+var $nor = function (params, owneryQuery, options) {
+    return new $Nor(params, owneryQuery, options);
 };
-exports.$in = $in;
-var $nin = function(params, options) {
-  var filter = $in(params, options);
-  return function(item, key, value) {
-    return !filter(item, key, value);
-  };
+var $elemMatch = function (params, owneryQuery, options) {
+    return new $ElemMatch(params, owneryQuery, options);
 };
-exports.$nin = $nin;
-var $and = function(params, options) {
-  var filter = core_1.createAndFilter(
-    params.map(function(query) {
-      return core_1.createOrFilter(core_1.createQueryFilters(query, options));
-    })
-  );
-  return filter;
+var $nin = function (params, owneryQuery, options) {
+    return new $Nor(params, owneryQuery, options);
 };
-exports.$and = $and;
-var $options = function(params) {
-  return function(item) {
-    return true;
-  };
+var $in = function (params, owneryQuery, options) {
+    return new $Or(params, owneryQuery, options);
 };
-exports.$options = $options;
-var $not = function(query, options) {
-  var filter = core_1.createAndFilter(
-    core_1.createQueryFilters(query, options)
-  );
-  return function(item, key, parent) {
-    return !filter(item, key, parent);
-  };
+var $lt = core_1.numericalOperationCreator(function (params, owneryQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return b < params; }, owneryQuery, options);
+});
+var $lte = core_1.numericalOperationCreator(function (params, owneryQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return b <= params; }, owneryQuery, options);
+});
+var $gt = core_1.numericalOperationCreator(function (params, owneryQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return b > params; }, owneryQuery, options);
+});
+var $gte = core_1.numericalOperationCreator(function (params, owneryQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return b >= params; }, owneryQuery, options);
+});
+var $mod = function (_a, owneryQuery, options) {
+    var mod = _a[0], equalsValue = _a[1];
+    return new core_1.EqualsOperation(function (b) { return utils_1.comparable(b) % mod === equalsValue; }, owneryQuery, options);
 };
-exports.$not = $not;
-var $size = function(size) {
-  return function(item) {
-    return item && item.length === size;
-  };
+var $exists = function (params, owneryQuery, options) {
+    return new $Exists(params, owneryQuery, options);
 };
-exports.$size = $size;
-var $all = function(query, options) {
-  return $and(query, options);
+var $regex = function (pattern, owneryQuery, options) {
+    return new core_1.EqualsOperation(new RegExp(pattern, owneryQuery.$options), owneryQuery, options);
 };
-exports.$all = $all;
-var $type = function(clazz) {
-  return core_1.spreadValueArray(function(item) {
-    return item == undefined
-      ? false
-      : item instanceof clazz || item.constructor === clazz;
-  });
+var $not = function (params, owneryQuery, options) {
+    return new $Not(params, owneryQuery, options);
 };
-exports.$type = $type;
-var $regex = function(pattern, options, _a) {
-  var $options = _a.$options;
-  var tester =
-    pattern instanceof RegExp ? pattern : new RegExp(pattern, $options);
-  return core_1.spreadValueArray(core_1.createRegexpTester(tester));
+var $type = function (clazz, owneryQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return (b != null ? b instanceof clazz || b.constructor === clazz : false); }, owneryQuery, options);
 };
-exports.$regex = $regex;
-var $elemMatch = function(query, options) {
-  var filter = core_1.createAndFilter(
-    core_1.createQueryFilters(query, options)
-  );
-  return filter;
+var $and = function (params, ownerQuery, options) {
+    return new $And(params, ownerQuery, options);
 };
-exports.$elemMatch = $elemMatch;
-var $or = function(params, options) {
-  return core_1.createOrFilter(
-    params.map(function(query) {
-      return core_1.createAndFilter(core_1.createQueryFilters(query, options));
-    })
-  );
+var $all = $and;
+var $size = function (params, ownerQuery, options) {
+    return new core_1.EqualsOperation(function (b) { return b && b.length === params; }, ownerQuery, options);
 };
-exports.$or = $or;
-var $nor = function(params, options) {
-  var filter = $or(params, options);
-  return function(item, key, parent) {
-    return !filter(item, key, parent);
-  };
+var $options = function () { return null; };
+var $where = function (params, ownerQuery, options) {
+    var test;
+    if (utils_1.isFunction(params)) {
+        test = params;
+    }
+    else if (!process.env.CSP_ENABLED) {
+        test = new Function("obj", "return " + params);
+    }
+    else {
+        throw new Error("In CSP mode, sift does not support strings in \"$where\" condition");
+    }
+    return new core_1.EqualsOperation(function (b) { return test.bind(b)(b); }, ownerQuery, options);
 };
-exports.$nor = $nor;
-var $where = function(query) {
-  var tester;
-  if (utils_1.isFunction(query)) {
-    tester = query;
-  } else if (!process.env.CSP_ENABLED) {
-    tester = new Function("obj", "return " + query);
-  } else {
-    throw new Error(
-      'In CSP mode, sift does not support strings in "$where" condition'
-    );
-  }
-  return function(item) {
-    return tester.bind(item)(item);
-  };
+exports.creators = {
+    $lt: $lt,
+    $lte: $lte,
+    $mod: $mod,
+    $gt: $gt,
+    $gte: $gte,
+    $eq: $eq,
+    $or: $or,
+    $nor: $nor,
+    $and: $and,
+    $options: $options,
+    $regex: $regex,
+    $ne: $ne,
+    $nin: $nin,
+    $all: $all,
+    $size: $size,
+    $in: $in,
+    $type: $type,
+    $elemMatch: $elemMatch,
+    $exists: $exists,
+    $not: $not,
+    $where: $where
 };
-exports.$where = $where;

lib/utils.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var typeChecker = function(type) {
-  var typeString = "[object " + type + "]";
-  return function(value) {
-    return Object.prototype.toString.call(value) === typeString;
-  };
+exports.typeChecker = function (type) {
+    var typeString = "[object " + type + "]";
+    return function (value) {
+        return getClassName(value) === typeString;
+    };
 };
-var comparable = function(value) {
-  if (value instanceof Date) {
-    return value.getTime();
-  } else if (isArray(value)) {
-    return value.map(comparable);
-  } else if (value && typeof value.toJSON === "function") {
-    return value.toJSON();
-  }
-  return value;
+var getClassName = function (value) { return Object.prototype.toString.call(value); };
+exports.comparable = function (value) {
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    else if (exports.isArray(value)) {
+        return value.map(exports.comparable);
+    }
+    else if (value && typeof value.toJSON === "function") {
+        return value.toJSON();
+    }
+    return value;
 };
-exports.comparable = comparable;
-var get = function(object, key) {
-  return isFunction(object.get) ? object.get(key) : object[key];
+exports.isArray = exports.typeChecker("Array");
+exports.isObject = exports.typeChecker("Object");
+exports.isFunction = exports.typeChecker("Function");
+exports.isVanillaObject = function (value) {
+    return (value &&
+        (value.constructor === Object ||
+            value.constructor === Array ||
+            value.constructor.toString() === "function Object() { [native code] }" ||
+            value.constructor.toString() === "function Array() { [native code] }") &&
+        !value.toJSON);
 };
-exports.get = get;
-var isArray = typeChecker("Array");
-exports.isArray = isArray;
-var isObject = typeChecker("Object");
-exports.isObject = isObject;
-var isFunction = typeChecker("Function");
-exports.isFunction = isFunction;
-var isVanillaObject = function(value) {
-  return (
-    value &&
-    (value.constructor === Object ||
-      value.constructor === Array ||
-      value.constructor.toString() === "function Object() { [native code] }" ||
-      value.constructor.toString() === "function Array() { [native code] }") &&
-    !value.toJSON
-  );
-};
-exports.isVanillaObject = isVanillaObject;
-var equals = function(a, b) {
-  if (a == null && a == b) {
-    return true;
-  }
-  if (a === b) {
-    return true;
-  }
-  if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
-    return false;
-  }
-  if (isArray(a)) {
-    if (a.length !== b.length) {
-      return false;
+exports.equals = function (a, b) {
+    if (a == null && a == b) {
+        return true;
     }
-    for (var i = 0, length_1 = a.length; i < length_1; i++) {
-      if (!equals(a[i], b[i])) return false;
+    if (a === b) {
+        return true;
     }
-    return true;
-  } else if (isObject(a)) {
-    if (Object.keys(a).length !== Object.keys(b).length) {
-      return false;
+    if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
+        return false;
     }
-    for (var key in a) {
-      if (!equals(a[key], b[key])) return false;
+    if (exports.isArray(a)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (var i = 0, length_1 = a.length; i < length_1; i++) {
+            if (!exports.equals(a[i], b[i]))
+                return false;
+        }
+        return true;
     }
-    return true;
-  }
-  return false;
+    else if (exports.isObject(a)) {
+        if (Object.keys(a).length !== Object.keys(b).length) {
+            return false;
+        }
+        for (var key in a) {
+            if (!exports.equals(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    return false;
 };
-exports.equals = equals;
-var hasNestedProperty = function(object, key) {
-  var parts = String(key).split(".");
-  var current = object;
-  if (parts.length === 1) {
-    return current.hasOwnProperty(key);
-  }
-  for (var i = 0, n = parts.length - 1; i < n; i++) {
-    current = current[parts[i]];
-    if (!current) return false;
-  }
-  return current.hasOwnProperty(parts[parts.length - 1]);
-};
-exports.hasNestedProperty = hasNestedProperty;
-var nope = function() {
-  return false;
-};
-exports.nope = nope;

package.json

 {
   "name": "sift",
   "description": "mongodb query style array filtering",
-  "version": "10.0.0",
+  "version": "11.0.0",
   "repository": "crcn/sift.js",
@@ -13,5 +13,3 @@ "author": {
   "engines": {},
-  "dependencies": {
-    "@babel/register": "^7.7.7"
-  },
+  "dependencies": {},
   "typings": "./index.d.ts",
@@ -24,2 +22,3 @@ "husky": {
   "devDependencies": {
+    "@babel/register": "^7.7.4",
     "@babel/core": "^7.7.7",
@@ -26,0 +25,0 @@ "@babel/preset-env": "^7.7.7",

README.md

@@ -0,1 +1,3 @@
+**Installation**: `npm install sift`, or `yarn add sift`
+
 ## validate objects & filter arrays with mongodb queries
@@ -421,3 +423,3 @@
 
-#### Expressions
+#### Custom operations
 
@@ -427,2 +429,4 @@ Sift comes with expressions like `$not`, `$eq`, and others, but you can also add your own.
 ```javascript
+import { EqualsOperation } from "sift";
+
 var filter = sift(
@@ -433,5 +437,9 @@ {
   {
-    expressions: {
-      $customMod: query => value => {
-        return query % value;
+    operations: {
+      $customMod(params, ownerQuery, options) {
+        return new EqualsOperation(
+          value => value % params !== 0,
+          ownerQuery,
+          options
+        );
       }
@@ -438,0 +446,0 @@ }

sift.csp.min.js

@@ -1,482 +0,652 @@
-!(function(n, t) {
+!(function(t, n) {
   "object" == typeof exports && "object" == typeof module
-    ? (module.exports = t())
+    ? (module.exports = n())
     : "function" == typeof define && define.amd
-    ? define([], t)
+    ? define([], n)
     : "object" == typeof exports
-    ? (exports.sift = t())
-    : (n.sift = t());
+    ? (exports.sift = n())
+    : (t.sift = n());
 })(this, function() {
-  return (function(n) {
-    var t = {};
-    function r(e) {
-      if (t[e]) return t[e].exports;
-      var o = (t[e] = { i: e, l: !1, exports: {} });
-      return n[e].call(o.exports, o, o.exports, r), (o.l = !0), o.exports;
+  return (function(t) {
+    var n = {};
+    function e(r) {
+      if (n[r]) return n[r].exports;
+      var o = (n[r] = { i: r, l: !1, exports: {} });
+      return t[r].call(o.exports, o, o.exports, e), (o.l = !0), o.exports;
     }
     return (
-      (r.m = n),
-      (r.c = t),
-      (r.d = function(n, t, e) {
-        r.o(n, t) || Object.defineProperty(n, t, { enumerable: !0, get: e });
+      (e.m = t),
+      (e.c = n),
+      (e.d = function(t, n, r) {
+        e.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: r });
       }),
-      (r.r = function(n) {
+      (e.r = function(t) {
         "undefined" != typeof Symbol &&
           Symbol.toStringTag &&
-          Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }),
-          Object.defineProperty(n, "__esModule", { value: !0 });
+          Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+          Object.defineProperty(t, "__esModule", { value: !0 });
       }),
-      (r.t = function(n, t) {
-        if ((1 & t && (n = r(n)), 8 & t)) return n;
-        if (4 & t && "object" == typeof n && n && n.__esModule) return n;
-        var e = Object.create(null);
+      (e.t = function(t, n) {
+        if ((1 & n && (t = e(t)), 8 & n)) return t;
+        if (4 & n && "object" == typeof t && t && t.__esModule) return t;
+        var r = Object.create(null);
         if (
-          (r.r(e),
-          Object.defineProperty(e, "default", { enumerable: !0, value: n }),
-          2 & t && "string" != typeof n)
+          (e.r(r),
+          Object.defineProperty(r, "default", { enumerable: !0, value: t }),
+          2 & n && "string" != typeof t)
         )
-          for (var o in n)
-            r.d(
-              e,
+          for (var o in t)
+            e.d(
+              r,
               o,
-              function(t) {
-                return n[t];
+              function(n) {
+                return t[n];
               }.bind(null, o)
             );
-        return e;
+        return r;
       }),
-      (r.n = function(n) {
-        var t =
-          n && n.__esModule
+      (e.n = function(t) {
+        var n =
+          t && t.__esModule
             ? function() {
-                return n.default;
+                return t.default;
               }
             : function() {
-                return n;
+                return t;
               };
-        return r.d(t, "a", t), t;
+        return e.d(n, "a", n), n;
       }),
-      (r.o = function(n, t) {
-        return Object.prototype.hasOwnProperty.call(n, t);
+      (e.o = function(t, n) {
+        return Object.prototype.hasOwnProperty.call(t, n);
       }),
-      (r.p = ""),
-      r((r.s = 0))
+      (e.p = ""),
+      e((e.s = 2))
     );
   })([
-    function(n, t, r) {
-      n.exports = r(1);
-    },
-    function(n, t, r) {
+    function(t, n, e) {
       "use strict";
-      function e(n) {
-        return (e =
-          "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
-            ? function(n) {
-                return typeof n;
-              }
-            : function(n) {
-                return n &&
-                  "function" == typeof Symbol &&
-                  n.constructor === Symbol &&
-                  n !== Symbol.prototype
-                  ? "symbol"
-                  : typeof n;
-              })(n);
-      }
-      function o(n) {
-        var t = "[object " + n + "]";
-        return function(n) {
-          return Object.prototype.toString.call(n) === t;
-        };
-      }
-      r.r(t),
-        r.d(t, "default", function() {
-          return m;
+      Object.defineProperty(n, "__esModule", { value: !0 }),
+        (n.typeChecker = function(t) {
+          var n = "[object " + t + "]";
+          return function(t) {
+            return r(t) === n;
+          };
+        });
+      var r = function(t) {
+        return Object.prototype.toString.call(t);
+      };
+      (n.comparable = function(t) {
+        return t instanceof Date
+          ? t.getTime()
+          : n.isArray(t)
+          ? t.map(n.comparable)
+          : t && "function" == typeof t.toJSON
+          ? t.toJSON()
+          : t;
+      }),
+        (n.isArray = n.typeChecker("Array")),
+        (n.isObject = n.typeChecker("Object")),
+        (n.isFunction = n.typeChecker("Function")),
+        (n.isVanillaObject = function(t) {
+          return (
+            t &&
+            (t.constructor === Object ||
+              t.constructor === Array ||
+              "function Object() { [native code] }" ===
+                t.constructor.toString() ||
+              "function Array() { [native code] }" ===
+                t.constructor.toString()) &&
+            !t.toJSON
+          );
         }),
-        r.d(t, "compare", function() {
-          return j;
-        }),
-        r.d(t, "comparable", function() {
-          return O;
+        (n.equals = function(t, e) {
+          if (null == t && t == e) return !0;
+          if (t === e) return !0;
+          if (
+            Object.prototype.toString.call(t) !==
+            Object.prototype.toString.call(e)
+          )
+            return !1;
+          if (n.isArray(t)) {
+            if (t.length !== e.length) return !1;
+            for (var r = 0, o = t.length; r < o; r++)
+              if (!n.equals(t[r], e[r])) return !1;
+            return !0;
+          }
+          if (n.isObject(t)) {
+            if (Object.keys(t).length !== Object.keys(e).length) return !1;
+            for (var i in t) if (!n.equals(t[i], e[i])) return !1;
+            return !0;
+          }
+          return !1;
         });
-      var u = o("Array"),
-        i = o("Object"),
-        f = o("Function");
-      function c(n, t) {
-        return f(n.get) ? n.get(t) : n[t];
-      }
-      function a(n) {
-        return function(t, r) {
-          if (!u(r) || !r.length) return n(t, r);
-          for (var e = 0, o = r.length; e < o; e++)
-            if (n(t, c(r, e))) return !0;
-          return !1;
-        };
-      }
-      function l(n) {
-        return function(t, r) {
-          if (!u(r) || !r.length) return n(t, r);
-          for (var e = 0, o = r.length; e < o; e++)
-            if (!n(t, c(r, e))) return !1;
-          return !0;
-        };
-      }
-      function p(n, t, r, e) {
-        return n.validate(n.options, t, r, e);
-      }
-      var s = {
-          $eq: a(function(n, t) {
-            return n(t);
+    },
+    function(t, n, e) {
+      "use strict";
+      var r,
+        o =
+          (this && this.__extends) ||
+          ((r = function(t, n) {
+            return (r =
+              Object.setPrototypeOf ||
+              ({ __proto__: [] } instanceof Array &&
+                function(t, n) {
+                  t.__proto__ = n;
+                }) ||
+              function(t, n) {
+                for (var e in n) n.hasOwnProperty(e) && (t[e] = n[e]);
+              })(t, n);
           }),
-          $ne: l(function(n, t) {
-            return n(t);
+          function(t, n) {
+            function e() {
+              this.constructor = t;
+            }
+            r(t, n),
+              (t.prototype =
+                null === n
+                  ? Object.create(n)
+                  : ((e.prototype = n.prototype), new e()));
           }),
-          $gt: a(function(n, t) {
-            return n(t);
+        i =
+          (this && this.__spreadArrays) ||
+          function() {
+            for (var t = 0, n = 0, e = arguments.length; n < e; n++)
+              t += arguments[n].length;
+            var r = Array(t),
+              o = 0;
+            for (n = 0; n < e; n++)
+              for (var i = arguments[n], u = 0, s = i.length; u < s; u++, o++)
+                r[o] = i[u];
+            return r;
+          };
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var u = e(0),
+        s = function(t, n, e, r, o, i) {
+          var c = n[r];
+          if (u.isArray(t) && isNaN(Number(c)))
+            for (var a = 0, p = t.length; a < p; a++)
+              if (!s(t[a], n, e, r, a, t)) return !1;
+          return r === n.length || null == t
+            ? e(t, o, i)
+            : s(t[c], n, e, r + 1, c, t);
+        },
+        c = (function() {
+          function t(t, n, e) {
+            (this.params = t),
+              (this.owneryQuery = n),
+              (this.options = e),
+              this.init();
+          }
+          return (
+            (t.prototype.init = function() {}),
+            (t.prototype.reset = function() {
+              (this.done = !1), (this.success = !1);
+            }),
+            t
+          );
+        })();
+      n.BaseOperation = c;
+      var a = (function(t) {
+        function n(n, e, r, o) {
+          var i = t.call(this, n, e, r) || this;
+          return (i._children = o), i;
+        }
+        return (
+          o(n, t),
+          (n.prototype.reset = function() {
+            (this.success = !1), (this.done = !1);
+            for (var t = 0, n = this._children.length; t < n; t++)
+              this._children[t].reset();
           }),
-          $gte: a(function(n, t) {
-            return n(t);
+          (n.prototype.childrenNext = function(t, n, e) {
+            for (
+              var r = !0, o = !0, i = 0, u = this._children.length;
+              i < u;
+              i++
+            ) {
+              var s = this._children[i];
+              if ((s.next(t, n, e), s.success || (o = !1), s.done)) {
+                if (!s.success) break;
+              } else r = !1;
+            }
+            (this.done = r), (this.success = o);
           }),
-          $lt: a(function(n, t) {
-            return n(t);
+          n
+        );
+      })(c);
+      n.GroupOperation = a;
+      var p = (function(t) {
+        function n() {
+          return (null !== t && t.apply(this, arguments)) || this;
+        }
+        return (
+          o(n, t),
+          (n.prototype.next = function(t, n, e) {
+            this.childrenNext(t, n, e);
           }),
-          $lte: a(function(n, t) {
-            return n(t);
+          n
+        );
+      })(a);
+      n.QueryOperation = p;
+      var f = (function(t) {
+        function n(n, e, r, o, i) {
+          var u = t.call(this, e, r, o, i) || this;
+          return (
+            (u.keyPath = n),
+            (u._nextNestedValue = function(t, n, e) {
+              return u.childrenNext(t, n, e), !u.done;
+            }),
+            u
+          );
+        }
+        return (
+          o(n, t),
+          (n.prototype.next = function(t, n, e) {
+            s(t, this.keyPath, this._nextNestedValue, 0, n, e);
           }),
-          $mod: a(function(n, t) {
-            return n(t);
+          n
+        );
+      })(a);
+      (n.NestedOperation = f),
+        (n.createTester = function(t, n) {
+          if (t instanceof Function) return t;
+          if (t instanceof RegExp)
+            return function(n) {
+              return "string" == typeof n && t.test(n);
+            };
+          var e = u.comparable(t);
+          return function(t) {
+            return n(e, u.comparable(t));
+          };
+        });
+      var l = (function(t) {
+        function e() {
+          return (null !== t && t.apply(this, arguments)) || this;
+        }
+        return (
+          o(e, t),
+          (e.prototype.init = function() {
+            this._test = n.createTester(this.params, this.options.compare);
           }),
-          $in: function(n, t) {
-            return n(t);
-          },
-          $nin: function(n, t) {
-            return n(t);
-          },
-          $not: function(n, t, r, e) {
-            return n(t, r, e);
-          },
-          $type: function(n, t) {
-            return n(t);
-          },
-          $all: function(n, t, r, e) {
-            return s.$and(n, t, r, e);
-          },
-          $size: function(n, t) {
-            return !!t && n === t.length;
-          },
-          $or: function(n, t, r, e) {
-            for (var o = 0, u = n.length; o < u; o++)
-              if (p(c(n, o), t, r, e)) return !0;
-            return !1;
-          },
-          $nor: function(n, t, r, e) {
-            return !s.$or(n, t, r, e);
-          },
-          $and: function(n, t, r, e) {
-            for (var o = 0, u = n.length; o < u; o++)
-              if (!p(c(n, o), t, r, e)) return !1;
-            return !0;
-          },
-          $regex: a(function(n, t) {
-            return "string" == typeof t && n.test(t);
+          (e.prototype.next = function(t, n, e) {
+            this._test(t, n, e) && ((this.done = !0), (this.success = !0));
           }),
-          $where: function(n, t, r, e) {
-            return n.call(t, t, r, e);
-          },
-          $elemMatch: function(n, t, r, e) {
-            return u(t)
-              ? !!~(function(n, t) {
-                  for (var r = 0; r < n.length; r++) {
-                    c(n, r);
-                    if (p(t, c(n, r))) return r;
-                  }
-                  return -1;
-                })(t, n)
-              : p(n, t, r, e);
-          },
-          $exists: function(n, t, r, e) {
-            return e.hasOwnProperty(r) === n;
-          }
+          e
+        );
+      })(c);
+      n.EqualsOperation = l;
+      var h = (function(t) {
+        function n() {
+          return (null !== t && t.apply(this, arguments)) || this;
+        }
+        return (
+          o(n, t),
+          (n.prototype.next = function() {
+            (this.done = !0), (this.success = !1);
+          }),
+          n
+        );
+      })(c);
+      (n.NopeOperation = h),
+        (n.numericalOperationCreator = function(t) {
+          return function(n, e, r) {
+            return null == n ? new h(n, e, r) : t(n, e, r);
+          };
+        });
+      var y = function(t, n, e, r) {
+          var o = r.operations[t];
+          if (!o) throw new Error("Unsupported operation: " + t);
+          return o(n, e, r);
         },
-        g = {
-          $eq: function(n, t, r) {
-            var e = r.comparable,
-              o = r.compare;
-            return n instanceof RegExp
-              ? a(function(t) {
-                  return "string" == typeof t && n.test(t);
-                })
-              : n instanceof Function
-              ? a(n)
-              : u(n) && !n.length
-              ? a(function(n) {
-                  return u(n) && !n.length;
-                })
-              : a(
-                  null === n
-                    ? function(n) {
-                        return null == n;
-                      }
-                    : function(t) {
-                        return 0 === o(e(t), e(n));
-                      }
-                );
-          },
-          $gt: function(n, t, r) {
-            var e = r.comparable,
-              o = r.compare;
-            return function(t) {
-              return o(e(t), e(n)) > 0;
-            };
-          },
-          $gte: function(n, t, r) {
-            var e = r.comparable,
-              o = r.compare;
-            return function(t) {
-              return o(e(t), e(n)) >= 0;
-            };
-          },
-          $lt: function(n, t, r) {
-            var e = r.comparable,
-              o = r.compare;
-            return function(t) {
-              return o(e(t), e(n)) < 0;
-            };
-          },
-          $lte: function(n, t, r) {
-            var e = r.comparable,
-              o = r.compare;
-            return function(t) {
-              return o(e(t), e(n)) <= 0;
-            };
-          },
-          $in: function(n, t, r) {
-            var o = r.comparable;
-            return function(t) {
-              if (!(t instanceof Array)) {
-                var u = o(t);
-                if (u === t && "object" === e(t))
-                  for (f = n.length; f--; )
-                    if (
-                      String(n[f]) === String(t) &&
-                      "[object Object]" !== String(t)
-                    )
-                      return !0;
-                if (void 0 === u)
-                  for (f = n.length; f--; ) if (null == n[f]) return !0;
-                for (f = n.length; f--; ) {
-                  var i = p(h(c(n, f), r), u, f, n);
-                  if (
-                    i &&
-                    "[object Object]" !== String(i) &&
-                    "[object Object]" !== String(u)
-                  )
-                    return !0;
-                }
-                return !!~n.indexOf(u);
-              }
-              for (var f = t.length; f--; )
-                if (~n.indexOf(o(c(t, f)))) return !0;
+        O = function(t, n, e, r) {
+          if (
+            (function(t) {
+              for (var n in t) if ("$" === n.charAt(0)) return !0;
               return !1;
-            };
-          },
-          $nin: function(n, t, r) {
-            var e = g.$in(n, t, r);
-            return function(n, t, r, o) {
-              return !e(n, t, r, o);
-            };
-          },
-          $mod: function(n) {
-            return function(t) {
-              return t % n[0] == n[1];
-            };
-          },
-          $ne: function(n, t, r) {
-            var e = g.$eq(n, t, r);
-            return l(function(n, t, r, o) {
-              return !e(n, t, r, o);
-            });
-          },
-          $and: function(n, t, r) {
-            return n.map(d(r));
-          },
-          $all: function(n, t, r) {
-            return g.$and(n, t, r);
-          },
-          $or: function(n, t, r) {
-            return n.map(d(r));
-          },
-          $nor: function(n, t, r) {
-            return n.map(d(r));
-          },
-          $not: function(n, t, r) {
-            var e = d(r)(n);
-            return function(n, t, r) {
-              return !p(e, n, t, r);
-            };
-          },
-          $type: function(n) {
-            return function(t, r, e) {
-              return null != t && (t instanceof n || t.constructor == n);
-            };
-          },
-          $regex: function(n, t) {
-            return new RegExp(n, t.$options);
-          },
-          $where: function(n) {
-            if ("function" == typeof n) return n;
-            throw new Error(
-              'In CSP mode, sift does not support strings in "$where" condition'
-            );
-          },
-          $elemMatch: function(n, t, r) {
-            return d(r)(n);
-          },
-          $exists: function(n) {
-            return !!n;
+            })(n)
+          ) {
+            var o = d(n, r),
+              i = o[0];
+            if (o[1].length)
+              throw new Error(
+                "Property queries must contain only operations, or exact objects."
+              );
+            return new f(t, n, e, r, i);
           }
+          return new f(t, n, e, r, [new l(n, e, r)]);
         };
-      function v(n, t) {
-        return { options: n, validate: t };
-      }
-      function $(n, t) {
-        var r = n.keyPath,
-          e = n.child,
-          o = n.query,
-          i = [];
-        if (
-          ((function n(t, r, e, o, i) {
-            if (e === r.length || null == t)
-              return void i.push([t, r[e - 1], o]);
-            var f = c(r, e);
-            if (u(t) && isNaN(Number(f)))
-              for (var a = 0, l = t.length; a < l; a++) n(c(t, a), r, e, t, i);
-            else n(c(t, f), r, e + 1, t, i);
-          })(t, r, 0, t, i),
-          1 === i.length)
-        ) {
-          var f = i[0];
-          return p(e, f[0], f[1], f[2]);
-        }
-        for (var a = o && void 0 !== o.$ne, l = a, s = 0; s < i.length; s++) {
-          var g = i[s],
-            v = p(e, g[0], g[1], g[2]);
-          a ? (l &= v) : (l |= v);
-        }
-        return l;
-      }
-      function b(n, t, r) {
-        return v({ keyPath: n, child: t, query: r }, $);
-      }
-      function d(n) {
-        var t = n.comparable,
-          r = n.expressions,
-          e = function(n) {
-            var t;
-            return (
-              (!n ||
-                (!(t = n) ||
-                  (t.constructor !== Object &&
-                    t.constructor !== Array &&
-                    "function Object() { [native code] }" !==
-                      t.constructor.toString() &&
-                    "function Array() { [native code] }" !==
-                      t.constructor.toString()) ||
-                  t.toJSON)) &&
-                (n = { $eq: n }),
-              n
-            );
-          },
-          o = function(e) {
-            e = t(e);
-            var o = [];
-            for (var i in e) {
-              var f = e[i];
-              if ("$options" !== i) {
-                var c = s[i] || (n && r && r[i]);
-                if (c) g[i] && (f = g[i](f, e, n)), o.push(v(t(f), c));
-                else {
-                  if (36 === i.charCodeAt(0))
-                    throw new Error("Unknown operation " + i);
-                  var a = i.split(".");
-                  o.push(b(a, u(f), f));
+      n.createQueryOperation = function(t, n, e) {
+        var r = d(t, e),
+          o = r[0],
+          u = r[1],
+          s = i([new f([], t, n, e, o)], u);
+        return 1 === s.length ? s[0] : new p(t, n, e, s);
+      };
+      var d = function(t, n) {
+        var e = [],
+          r = [];
+        for (var o in (u.isVanillaObject(t) || (t = { $eq: t }), t))
+          if ("$" === o.charAt(0)) {
+            var i = y(o, t[o], t, n);
+            null != i && e.push(i);
+          } else r.push(O(o.split("."), t[o], t, n));
+        return [e, r];
+      };
+    },
+    function(t, n, e) {
+      t.exports = e(3);
+    },
+    function(t, n, e) {
+      "use strict";
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var r = e(4),
+        o = e(1);
+      n.EqualsOperation = o.EqualsOperation;
+      var i = e(0);
+      n.default = function(t, n) {
+        var e = void 0 === n ? {} : n,
+          u = e.compare,
+          s = e.operations,
+          c = o.createQueryOperation(t, null, {
+            compare: u || i.equals,
+            operations: Object.assign({}, r.creators, s || {})
+          });
+        return function(t, n, e) {
+          return c.reset(), c.next(t, n, e), c.success;
+        };
+      };
+    },
+    function(t, n, e) {
+      "use strict";
+      var r,
+        o =
+          (this && this.__extends) ||
+          ((r = function(t, n) {
+            return (r =
+              Object.setPrototypeOf ||
+              ({ __proto__: [] } instanceof Array &&
+                function(t, n) {
+                  t.__proto__ = n;
+                }) ||
+              function(t, n) {
+                for (var e in n) n.hasOwnProperty(e) && (t[e] = n[e]);
+              })(t, n);
+          }),
+          function(t, n) {
+            function e() {
+              this.constructor = t;
+            }
+            r(t, n),
+              (t.prototype =
+                null === n
+                  ? Object.create(n)
+                  : ((e.prototype = n.prototype), new e()));
+          });
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var i = e(1),
+        u = e(0),
+        s = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              this._test = i.createTester(this.params, this.options.compare);
+            }),
+            (n.prototype.reset = function() {
+              t.prototype.reset.call(this), (this.success = !0);
+            }),
+            (n.prototype.next = function(t) {
+              this._test(t) && ((this.done = !0), (this.success = !1));
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        c = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              this._queryOperation = i.createQueryOperation(
+                this.params,
+                this.owneryQuery,
+                this.options
+              );
+            }),
+            (n.prototype.reset = function() {
+              this._queryOperation.reset();
+            }),
+            (n.prototype.next = function(t, n, e) {
+              this._queryOperation.next(t, n, e),
+                (this.done = this._queryOperation.done),
+                (this.success = this._queryOperation.success);
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        a = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(n, e, r) {
+              t.prototype.next.call(this, n, e, r),
+                (this.success = !this.success);
+            }),
+            n
+          );
+        })(c),
+        p = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              var t = this;
+              this._ops = this.params.map(function(n) {
+                return i.createQueryOperation(n, null, t.options);
+              });
+            }),
+            (n.prototype.reset = function() {
+              (this.done = !1), (this.success = !1);
+              for (var t = 0, n = this._ops.length; t < n; t++)
+                this._ops[t].reset();
+            }),
+            (n.prototype.next = function(t, n, e) {
+              for (
+                var r = !1, o = !1, i = 0, u = this._ops.length;
+                i < u;
+                i++
+              ) {
+                var s = this._ops[i];
+                if ((s.next(t, n, e), s.success)) {
+                  (r = !0), (o = s.success);
+                  break;
                 }
               }
-            }
-            return 1 === o.length ? o[0] : v(o, s.$and);
-          },
-          u = function(n) {
+              (this.success = o), (this.done = r);
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        f = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(n, e, r) {
+              t.prototype.next.call(this, n, e, r),
+                (this.success = !this.success);
+            }),
+            n
+          );
+        })(p),
+        l = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(t, n, e) {
+              e.hasOwnProperty(n) === this.params &&
+                ((this.done = !0), (this.success = !0));
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        h = (function(t) {
+          function n(n, e, r) {
             return (
-              (n = e(n)),
-              -1 ===
-              (function n(t, r) {
-                if (!i(t)) return r;
-                for (var e in t) r.push(e), n(t[e], r);
-                return r;
-              })(n, [])
-                .join(",")
-                .search(/[$.]/)
-                ? v(n, y)
-                : o(n)
+              t.call(
+                this,
+                n,
+                e,
+                r,
+                n.map(function(t) {
+                  return i.createQueryOperation(t, e, r);
+                })
+              ) || this
             );
-          };
-        return function(n) {
-          return o(e(n));
-        };
-      }
-      function y(n, t) {
-        if (
-          Object.prototype.toString.call(n) !==
-          Object.prototype.toString.call(t)
-        )
-          return !1;
-        if (i(n)) {
-          if (Object.keys(n).length !== Object.keys(t).length) return !1;
-          for (var r in n) if (!y(n[r], t[r])) return !1;
-          return !0;
-        }
-        if (u(n)) {
-          if (n.length !== t.length) return !1;
-          for (var e = 0, o = n.length; e < o; e++)
-            if (!y(n[e], t[e])) return !1;
-          return !0;
-        }
-        return n === t;
-      }
-      function h(n, t) {
-        var r = d(t)(n);
-        return (
-          t &&
-            t.select &&
-            (r = {
-              options: r,
-              validate: function(n, r, e, o) {
-                return p(n, r && t.select(r), e, o);
-              }
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(t, n, e) {
+              this.childrenNext(t, n, e);
             }),
-          r
-        );
-      }
-      function m(n, t) {
-        var r = h(n, (t = Object.assign({ compare: j, comparable: O }, t)));
-        return function(n, t, e) {
-          return p(r, n, t, e);
-        };
-      }
-      function j(n, t) {
-        if (y(n, t)) return 0;
-        if (e(n) === e(t)) {
-          if (n > t) return 1;
-          if (n < t) return -1;
+            n
+          );
+        })(i.GroupOperation),
+        y = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n < t;
+            },
+            n,
+            e
+          );
+        }),
+        O = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n <= t;
+            },
+            n,
+            e
+          );
+        }),
+        d = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n > t;
+            },
+            n,
+            e
+          );
+        }),
+        v = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n >= t;
+            },
+            n,
+            e
+          );
+        }),
+        _ = function(t, n, e) {
+          return new h(t, n, e);
+        },
+        b = _;
+      n.creators = {
+        $lt: y,
+        $lte: O,
+        $mod: function(t, n, e) {
+          var r = t[0],
+            o = t[1];
+          return new i.EqualsOperation(
+            function(t) {
+              return u.comparable(t) % r === o;
+            },
+            n,
+            e
+          );
+        },
+        $gt: d,
+        $gte: v,
+        $eq: function(t, n, e) {
+          return new i.EqualsOperation(t, n, e);
+        },
+        $or: function(t, n, e) {
+          return new p(t, n, e);
+        },
+        $nor: function(t, n, e) {
+          return new f(t, n, e);
+        },
+        $and: _,
+        $options: function() {
+          return null;
+        },
+        $regex: function(t, n, e) {
+          return new i.EqualsOperation(new RegExp(t, n.$options), n, e);
+        },
+        $ne: function(t, n, e) {
+          return new s(t, n, e);
+        },
+        $nin: function(t, n, e) {
+          return new f(t, n, e);
+        },
+        $all: b,
+        $size: function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n && n.length === t;
+            },
+            n,
+            e
+          );
+        },
+        $in: function(t, n, e) {
+          return new p(t, n, e);
+        },
+        $type: function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return null != n && (n instanceof t || n.constructor === t);
+            },
+            n,
+            e
+          );
+        },
+        $elemMatch: function(t, n, e) {
+          return new c(t, n, e);
+        },
+        $exists: function(t, n, e) {
+          return new l(t, n, e);
+        },
+        $not: function(t, n, e) {
+          return new a(t, n, e);
+        },
+        $where: function(t, n, e) {
+          var r;
+          if (!u.isFunction(t))
+            throw new Error(
+              'In CSP mode, sift does not support strings in "$where" condition'
+            );
+          return (
+            (r = t),
+            new i.EqualsOperation(
+              function(t) {
+                return r.bind(t)(t);
+              },
+              n,
+              e
+            )
+          );
         }
-      }
-      function O(n) {
-        return n instanceof Date
-          ? n.getTime()
-          : u(n)
-          ? n.map(O)
-          : n && "function" == typeof n.toJSON
-          ? n.toJSON()
-          : n;
-      }
+      };
     }
@@ -483,0 +653,0 @@ ]);

sift.min.js

@@ -1,382 +0,647 @@
-!(function(r, e) {
+!(function(t, n) {
   "object" == typeof exports && "object" == typeof module
-    ? (module.exports = e())
+    ? (module.exports = n())
     : "function" == typeof define && define.amd
-    ? define([], e)
+    ? define([], n)
     : "object" == typeof exports
-    ? (exports.sift = e())
-    : (r.sift = e());
+    ? (exports.sift = n())
+    : (t.sift = n());
 })(this, function() {
-  return (function(r) {
-    var e = {};
-    function t(n) {
-      if (e[n]) return e[n].exports;
-      var u = (e[n] = { i: n, l: !1, exports: {} });
-      return r[n].call(u.exports, u, u.exports, t), (u.l = !0), u.exports;
+  return (function(t) {
+    var n = {};
+    function e(r) {
+      if (n[r]) return n[r].exports;
+      var o = (n[r] = { i: r, l: !1, exports: {} });
+      return t[r].call(o.exports, o, o.exports, e), (o.l = !0), o.exports;
     }
     return (
-      (t.m = r),
-      (t.c = e),
-      (t.d = function(r, e, n) {
-        t.o(r, e) || Object.defineProperty(r, e, { enumerable: !0, get: n });
+      (e.m = t),
+      (e.c = n),
+      (e.d = function(t, n, r) {
+        e.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: r });
       }),
-      (t.r = function(r) {
+      (e.r = function(t) {
         "undefined" != typeof Symbol &&
           Symbol.toStringTag &&
-          Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }),
-          Object.defineProperty(r, "__esModule", { value: !0 });
+          Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+          Object.defineProperty(t, "__esModule", { value: !0 });
       }),
-      (t.t = function(r, e) {
-        if ((1 & e && (r = t(r)), 8 & e)) return r;
-        if (4 & e && "object" == typeof r && r && r.__esModule) return r;
-        var n = Object.create(null);
+      (e.t = function(t, n) {
+        if ((1 & n && (t = e(t)), 8 & n)) return t;
+        if (4 & n && "object" == typeof t && t && t.__esModule) return t;
+        var r = Object.create(null);
         if (
-          (t.r(n),
-          Object.defineProperty(n, "default", { enumerable: !0, value: r }),
-          2 & e && "string" != typeof r)
+          (e.r(r),
+          Object.defineProperty(r, "default", { enumerable: !0, value: t }),
+          2 & n && "string" != typeof t)
         )
-          for (var u in r)
-            t.d(
-              n,
-              u,
-              function(e) {
-                return r[e];
-              }.bind(null, u)
+          for (var o in t)
+            e.d(
+              r,
+              o,
+              function(n) {
+                return t[n];
+              }.bind(null, o)
             );
-        return n;
+        return r;
       }),
-      (t.n = function(r) {
-        var e =
-          r && r.__esModule
+      (e.n = function(t) {
+        var n =
+          t && t.__esModule
             ? function() {
-                return r.default;
+                return t.default;
               }
             : function() {
-                return r;
+                return t;
               };
-        return t.d(e, "a", e), e;
+        return e.d(n, "a", n), n;
       }),
-      (t.o = function(r, e) {
-        return Object.prototype.hasOwnProperty.call(r, e);
+      (e.o = function(t, n) {
+        return Object.prototype.hasOwnProperty.call(t, n);
       }),
-      (t.p = ""),
-      t((t.s = 2))
+      (e.p = ""),
+      e((e.s = 2))
     );
   })([
-    function(r, e, t) {
+    function(t, n, e) {
       "use strict";
-      Object.defineProperty(e, "__esModule", { value: !0 });
-      var n = function(r) {
-          var e = "[object " + r + "]";
-          return function(r) {
-            return Object.prototype.toString.call(r) === e;
+      Object.defineProperty(n, "__esModule", { value: !0 }),
+        (n.typeChecker = function(t) {
+          var n = "[object " + t + "]";
+          return function(t) {
+            return r(t) === n;
           };
+        });
+      var r = function(t) {
+        return Object.prototype.toString.call(t);
+      };
+      (n.comparable = function(t) {
+        return t instanceof Date
+          ? t.getTime()
+          : n.isArray(t)
+          ? t.map(n.comparable)
+          : t && "function" == typeof t.toJSON
+          ? t.toJSON()
+          : t;
+      }),
+        (n.isArray = n.typeChecker("Array")),
+        (n.isObject = n.typeChecker("Object")),
+        (n.isFunction = n.typeChecker("Function")),
+        (n.isVanillaObject = function(t) {
+          return (
+            t &&
+            (t.constructor === Object ||
+              t.constructor === Array ||
+              "function Object() { [native code] }" ===
+                t.constructor.toString() ||
+              "function Array() { [native code] }" ===
+                t.constructor.toString()) &&
+            !t.toJSON
+          );
+        }),
+        (n.equals = function(t, e) {
+          if (null == t && t == e) return !0;
+          if (t === e) return !0;
+          if (
+            Object.prototype.toString.call(t) !==
+            Object.prototype.toString.call(e)
+          )
+            return !1;
+          if (n.isArray(t)) {
+            if (t.length !== e.length) return !1;
+            for (var r = 0, o = t.length; r < o; r++)
+              if (!n.equals(t[r], e[r])) return !1;
+            return !0;
+          }
+          if (n.isObject(t)) {
+            if (Object.keys(t).length !== Object.keys(e).length) return !1;
+            for (var i in t) if (!n.equals(t[i], e[i])) return !1;
+            return !0;
+          }
+          return !1;
+        });
+    },
+    function(t, n, e) {
+      "use strict";
+      var r,
+        o =
+          (this && this.__extends) ||
+          ((r = function(t, n) {
+            return (r =
+              Object.setPrototypeOf ||
+              ({ __proto__: [] } instanceof Array &&
+                function(t, n) {
+                  t.__proto__ = n;
+                }) ||
+              function(t, n) {
+                for (var e in n) n.hasOwnProperty(e) && (t[e] = n[e]);
+              })(t, n);
+          }),
+          function(t, n) {
+            function e() {
+              this.constructor = t;
+            }
+            r(t, n),
+              (t.prototype =
+                null === n
+                  ? Object.create(n)
+                  : ((e.prototype = n.prototype), new e()));
+          }),
+        i =
+          (this && this.__spreadArrays) ||
+          function() {
+            for (var t = 0, n = 0, e = arguments.length; n < e; n++)
+              t += arguments[n].length;
+            var r = Array(t),
+              o = 0;
+            for (n = 0; n < e; n++)
+              for (var i = arguments[n], u = 0, s = i.length; u < s; u++, o++)
+                r[o] = i[u];
+            return r;
+          };
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var u = e(0),
+        s = function(t, n, e, r, o, i) {
+          var c = n[r];
+          if (u.isArray(t) && isNaN(Number(c)))
+            for (var a = 0, p = t.length; a < p; a++)
+              if (!s(t[a], n, e, r, a, t)) return !1;
+          return r === n.length || null == t
+            ? e(t, o, i)
+            : s(t[c], n, e, r + 1, c, t);
         },
-        u = function(r) {
-          return r instanceof Date
-            ? r.getTime()
-            : o(r)
-            ? r.map(u)
-            : r && "function" == typeof r.toJSON
-            ? r.toJSON()
-            : r;
-        };
-      e.comparable = u;
-      e.get = function(r, e) {
-        return c(r.get) ? r.get(e) : r[e];
-      };
-      var o = n("Array");
-      e.isArray = o;
-      var i = n("Object");
-      e.isObject = i;
-      var c = n("Function");
-      e.isFunction = c;
-      e.isVanillaObject = function(r) {
+        c = (function() {
+          function t(t, n, e) {
+            (this.params = t),
+              (this.owneryQuery = n),
+              (this.options = e),
+              this.init();
+          }
+          return (
+            (t.prototype.init = function() {}),
+            (t.prototype.reset = function() {
+              (this.done = !1), (this.success = !1);
+            }),
+            t
+          );
+        })();
+      n.BaseOperation = c;
+      var a = (function(t) {
+        function n(n, e, r, o) {
+          var i = t.call(this, n, e, r) || this;
+          return (i._children = o), i;
+        }
         return (
-          r &&
-          (r.constructor === Object ||
-            r.constructor === Array ||
-            "function Object() { [native code] }" ===
-              r.constructor.toString() ||
-            "function Array() { [native code] }" ===
-              r.constructor.toString()) &&
-          !r.toJSON
+          o(n, t),
+          (n.prototype.reset = function() {
+            (this.success = !1), (this.done = !1);
+            for (var t = 0, n = this._children.length; t < n; t++)
+              this._children[t].reset();
+          }),
+          (n.prototype.childrenNext = function(t, n, e) {
+            for (
+              var r = !0, o = !0, i = 0, u = this._children.length;
+              i < u;
+              i++
+            ) {
+              var s = this._children[i];
+              if ((s.next(t, n, e), s.success || (o = !1), s.done)) {
+                if (!s.success) break;
+              } else r = !1;
+            }
+            (this.done = r), (this.success = o);
+          }),
+          n
         );
-      };
-      var a = function(r, e) {
-        if (null == r && r == e) return !0;
-        if (r === e) return !0;
-        if (
-          Object.prototype.toString.call(r) !==
-          Object.prototype.toString.call(e)
-        )
-          return !1;
-        if (o(r)) {
-          if (r.length !== e.length) return !1;
-          for (var t = 0, n = r.length; t < n; t++)
-            if (!a(r[t], e[t])) return !1;
-          return !0;
+      })(c);
+      n.GroupOperation = a;
+      var p = (function(t) {
+        function n() {
+          return (null !== t && t.apply(this, arguments)) || this;
         }
-        if (i(r)) {
-          if (Object.keys(r).length !== Object.keys(e).length) return !1;
-          for (var u in r) if (!a(r[u], e[u])) return !1;
-          return !0;
+        return (
+          o(n, t),
+          (n.prototype.next = function(t, n, e) {
+            this.childrenNext(t, n, e);
+          }),
+          n
+        );
+      })(a);
+      n.QueryOperation = p;
+      var f = (function(t) {
+        function n(n, e, r, o, i) {
+          var u = t.call(this, e, r, o, i) || this;
+          return (
+            (u.keyPath = n),
+            (u._nextNestedValue = function(t, n, e) {
+              return u.childrenNext(t, n, e), !u.done;
+            }),
+            u
+          );
         }
-        return !1;
-      };
-      e.equals = a;
-      e.hasNestedProperty = function(r, e) {
-        var t = String(e).split("."),
-          n = r;
-        if (1 === t.length) return n.hasOwnProperty(e);
-        for (var u = 0, o = t.length - 1; u < o; u++)
-          if (!(n = n[t[u]])) return !1;
-        return n.hasOwnProperty(t[t.length - 1]);
-      };
-      e.nope = function() {
-        return !1;
-      };
-    },
-    function(r, e, t) {
-      "use strict";
-      Object.defineProperty(e, "__esModule", { value: !0 });
-      var n = t(0),
-        u = function(r) {
-          return function(e, t, u) {
-            if (!n.isArray(e) || !e.length) return r(e, t, u);
-            for (var o = 0, i = e.length; o < i; o++)
-              if (r(n.get(e, o), t, u)) return !0;
-            return !1;
+        return (
+          o(n, t),
+          (n.prototype.next = function(t, n, e) {
+            s(t, this.keyPath, this._nextNestedValue, 0, n, e);
+          }),
+          n
+        );
+      })(a);
+      (n.NestedOperation = f),
+        (n.createTester = function(t, n) {
+          if (t instanceof Function) return t;
+          if (t instanceof RegExp)
+            return function(n) {
+              return "string" == typeof n && t.test(n);
+            };
+          var e = u.comparable(t);
+          return function(t) {
+            return n(e, u.comparable(t));
           };
-        };
-      e.spreadValueArray = u;
-      e.numericalOperation = function(r) {
-        return function(e) {
-          var t = n.comparable(e);
-          return null == t ? n.nope : u(r(t));
-        };
-      };
-      var o = function(r) {
-        return function(e) {
-          return "string" == typeof e && r.test(e);
-        };
-      };
-      e.createRegexpTester = o;
-      var i = function(r, e) {
-        var t = e.compare,
-          u = void 0 === t ? n.equals : t;
-        if (n.isFunction(r)) return r;
-        if (r instanceof RegExp) return o(r);
-        var i = n.comparable(r);
-        return function(r, e, t) {
-          return u(i, n.comparable(r));
-        };
-      };
-      e.createTester = i;
-      var c = function(r, e, t) {
-        var n = (function(r) {
-            for (var e in r) if ("$" === e.charAt(0)) return !0;
-            return !1;
-          })(e)
-            ? s(f(e, t))
-            : i(e, t),
-          u = r.split("."),
-          o = e && null != e.$ne;
-        return function(r, e, t) {
-          return a(n, o, r, u, t, 0);
-        };
-      };
-      e.createNestedFilter = c;
-      var a = function(r, e, t, u, o, i) {
-          var c = u[i];
-          if (n.isArray(t) && isNaN(Number(c))) {
-            for (var f = void 0, l = 0, s = t.length; l < s; l++) {
-              var p = a(r, e, n.get(t, l), u, o, i);
-              f = e && null != f ? f && p : f || p;
-            }
-            return f;
-          }
-          var v = n.get(t, c);
-          return t && null == v
-            ? r(void 0, c, t)
-            : i === u.length - 1
-            ? r(v, c, t)
-            : a(r, e, v, u, t, i + 1);
+        });
+      var l = (function(t) {
+        function e() {
+          return (null !== t && t.apply(this, arguments)) || this;
+        }
+        return (
+          o(e, t),
+          (e.prototype.init = function() {
+            this._test = n.createTester(this.params, this.options.compare);
+          }),
+          (e.prototype.next = function(t, n, e) {
+            this._test(t, n, e) && ((this.done = !0), (this.success = !0));
+          }),
+          e
+        );
+      })(c);
+      n.EqualsOperation = l;
+      var h = (function(t) {
+        function n() {
+          return (null !== t && t.apply(this, arguments)) || this;
+        }
+        return (
+          o(n, t),
+          (n.prototype.next = function() {
+            (this.done = !0), (this.success = !1);
+          }),
+          n
+        );
+      })(c);
+      (n.NopeOperation = h),
+        (n.numericalOperationCreator = function(t) {
+          return function(n, e, r) {
+            return null == n ? new h(n, e, r) : t(n, e, r);
+          };
+        });
+      var y = function(t, n, e, r) {
+          var o = r.operations[t];
+          if (!o) throw new Error("Unsupported operation: " + t);
+          return o(n, e, r);
         },
-        f = function(r, e) {
-          var t = [];
-          for (var u in (n.isVanillaObject(r) || (r = { $eq: r }), r)) {
-            var o = r[u];
-            "$" === u.charAt(0) ? t.push(l(u, o, r, e)) : t.push(c(u, o, e));
+        O = function(t, n, e, r) {
+          if (
+            (function(t) {
+              for (var n in t) if ("$" === n.charAt(0)) return !0;
+              return !1;
+            })(n)
+          ) {
+            var o = d(n, r),
+              i = o[0];
+            if (o[1].length)
+              throw new Error(
+                "Property queries must contain only operations, or exact objects."
+              );
+            return new f(t, n, e, r, i);
           }
-          return t;
+          return new f(t, n, e, r, [new l(n, e, r)]);
         };
-      e.createQueryFilters = f;
-      var l = function(r, e, t, n) {
-          var u = n.expressions[r];
-          if (!u) throw new Error("Unsupported operation " + r);
-          return u(e, n, t);
-        },
-        s = function(r) {
-          return function(e, t, n) {
-            for (var u = r.length; u--; ) if (!r[u](e, t, n)) return !1;
-            return !0;
-          };
-        };
-      e.createAndFilter = s;
-      e.createOrFilter = function(r) {
-        return function(e, t, n) {
-          for (var u = r.length; u--; ) if (r[u](e, t, n)) return !0;
-          return !1;
-        };
+      n.createQueryOperation = function(t, n, e) {
+        var r = d(t, e),
+          o = r[0],
+          u = r[1],
+          s = i([new f([], t, n, e, o)], u);
+        return 1 === s.length ? s[0] : new p(t, n, e, s);
       };
+      var d = function(t, n) {
+        var e = [],
+          r = [];
+        for (var o in (u.isVanillaObject(t) || (t = { $eq: t }), t))
+          if ("$" === o.charAt(0)) {
+            var i = y(o, t[o], t, n);
+            null != i && e.push(i);
+          } else r.push(O(o.split("."), t[o], t, n));
+        return [e, r];
+      };
     },
-    function(r, e, t) {
-      r.exports = t(3);
+    function(t, n, e) {
+      t.exports = e(3);
     },
-    function(r, e, t) {
+    function(t, n, e) {
       "use strict";
-      Object.defineProperty(e, "__esModule", { value: !0 });
-      var n = t(0),
-        u = t(4),
-        o = t(1);
-      e.default = function(r, e) {
-        var t = void 0 === e ? {} : e,
-          i = t.compare,
-          c = t.expressions;
-        return o.createAndFilter(
-          o.createQueryFilters(r, {
-            compare: i || n.equals,
-            expressions: Object.assign({}, u, c)
-          })
-        );
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var r = e(4),
+        o = e(1);
+      n.EqualsOperation = o.EqualsOperation;
+      var i = e(0);
+      n.default = function(t, n) {
+        var e = void 0 === n ? {} : n,
+          u = e.compare,
+          s = e.operations,
+          c = o.createQueryOperation(t, null, {
+            compare: u || i.equals,
+            operations: Object.assign({}, r.creators, s || {})
+          });
+        return function(t, n, e) {
+          return c.reset(), c.next(t, n, e), c.success;
+        };
       };
     },
-    function(r, e, t) {
+    function(t, n, e) {
       "use strict";
-      Object.defineProperty(e, "__esModule", { value: !0 });
-      var n = t(0),
-        u = t(1),
-        o = function(r, e) {
-          return u.spreadValueArray(u.createTester(r, e));
-        };
-      e.$eq = o;
-      e.$ne = function(r, e) {
-        var t = o(r, e);
-        return function(r, e, n) {
-          return !t(r, e, n);
-        };
-      };
-      var i = u.numericalOperation(function(r) {
-        return function(e) {
-          return n.comparable(e) > r;
-        };
-      });
-      e.$gt = i;
-      var c = u.numericalOperation(function(r) {
-        return function(e) {
-          return n.comparable(e) >= r;
-        };
-      });
-      e.$gte = c;
-      var a = u.numericalOperation(function(r) {
-        return function(e) {
-          return n.comparable(e) < r;
-        };
-      });
-      e.$lt = a;
-      var f = u.numericalOperation(function(r) {
-        return function(e) {
-          return n.comparable(e) <= r;
-        };
-      });
-      e.$lte = f;
-      var l = u.numericalOperation(function(r) {
-        var e = r[0],
-          t = r[1];
-        return function(r) {
-          return n.comparable(r) % e === t;
-        };
-      });
-      e.$mod = l;
-      e.$exists = function(r) {
-        return u.spreadValueArray(function(e, t, n) {
-          return n.hasOwnProperty(t) === r;
-        });
-      };
-      var s = function(r, e) {
-        var t = v(r, e);
-        return function(r, e, n) {
-          return t(r, e, n);
-        };
-      };
-      e.$in = s;
-      e.$nin = function(r, e) {
-        var t = s(r, e);
-        return function(r, e, n) {
-          return !t(r, e, n);
-        };
-      };
-      var p = function(r, e) {
-        return u.createAndFilter(
-          r.map(function(r) {
-            return u.createOrFilter(u.createQueryFilters(r, e));
-          })
-        );
-      };
-      e.$and = p;
-      e.$options = function(r) {
-        return function(r) {
-          return !0;
-        };
-      };
-      e.$not = function(r, e) {
-        var t = u.createAndFilter(u.createQueryFilters(r, e));
-        return function(r, e, n) {
-          return !t(r, e, n);
-        };
-      };
-      e.$size = function(r) {
-        return function(e) {
-          return e && e.length === r;
-        };
-      };
-      e.$all = function(r, e) {
-        return p(r, e);
-      };
-      e.$type = function(r) {
-        return u.spreadValueArray(function(e) {
-          return null != e && (e instanceof r || e.constructor === r);
-        });
-      };
-      e.$regex = function(r, e, t) {
-        var n = t.$options,
-          o = r instanceof RegExp ? r : new RegExp(r, n);
-        return u.spreadValueArray(u.createRegexpTester(o));
-      };
-      e.$elemMatch = function(r, e) {
-        return u.createAndFilter(u.createQueryFilters(r, e));
-      };
-      var v = function(r, e) {
-        return u.createOrFilter(
-          r.map(function(r) {
-            return u.createAndFilter(u.createQueryFilters(r, e));
-          })
-        );
-      };
-      e.$or = v;
-      e.$nor = function(r, e) {
-        var t = v(r, e);
-        return function(r, e, n) {
-          return !t(r, e, n);
-        };
-      };
-      e.$where = function(r) {
-        var e;
-        return (
-          (e = n.isFunction(r) ? r : new Function("obj", "return " + r)),
-          function(r) {
-            return e.bind(r)(r);
+      var r,
+        o =
+          (this && this.__extends) ||
+          ((r = function(t, n) {
+            return (r =
+              Object.setPrototypeOf ||
+              ({ __proto__: [] } instanceof Array &&
+                function(t, n) {
+                  t.__proto__ = n;
+                }) ||
+              function(t, n) {
+                for (var e in n) n.hasOwnProperty(e) && (t[e] = n[e]);
+              })(t, n);
+          }),
+          function(t, n) {
+            function e() {
+              this.constructor = t;
+            }
+            r(t, n),
+              (t.prototype =
+                null === n
+                  ? Object.create(n)
+                  : ((e.prototype = n.prototype), new e()));
+          });
+      Object.defineProperty(n, "__esModule", { value: !0 });
+      var i = e(1),
+        u = e(0),
+        s = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
           }
-        );
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              this._test = i.createTester(this.params, this.options.compare);
+            }),
+            (n.prototype.reset = function() {
+              t.prototype.reset.call(this), (this.success = !0);
+            }),
+            (n.prototype.next = function(t) {
+              this._test(t) && ((this.done = !0), (this.success = !1));
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        c = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              this._queryOperation = i.createQueryOperation(
+                this.params,
+                this.owneryQuery,
+                this.options
+              );
+            }),
+            (n.prototype.reset = function() {
+              this._queryOperation.reset();
+            }),
+            (n.prototype.next = function(t, n, e) {
+              this._queryOperation.next(t, n, e),
+                (this.done = this._queryOperation.done),
+                (this.success = this._queryOperation.success);
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        a = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(n, e, r) {
+              t.prototype.next.call(this, n, e, r),
+                (this.success = !this.success);
+            }),
+            n
+          );
+        })(c),
+        p = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.init = function() {
+              var t = this;
+              this._ops = this.params.map(function(n) {
+                return i.createQueryOperation(n, null, t.options);
+              });
+            }),
+            (n.prototype.reset = function() {
+              (this.done = !1), (this.success = !1);
+              for (var t = 0, n = this._ops.length; t < n; t++)
+                this._ops[t].reset();
+            }),
+            (n.prototype.next = function(t, n, e) {
+              for (
+                var r = !1, o = !1, i = 0, u = this._ops.length;
+                i < u;
+                i++
+              ) {
+                var s = this._ops[i];
+                if ((s.next(t, n, e), s.success)) {
+                  (r = !0), (o = s.success);
+                  break;
+                }
+              }
+              (this.success = o), (this.done = r);
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        f = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(n, e, r) {
+              t.prototype.next.call(this, n, e, r),
+                (this.success = !this.success);
+            }),
+            n
+          );
+        })(p),
+        l = (function(t) {
+          function n() {
+            return (null !== t && t.apply(this, arguments)) || this;
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(t, n, e) {
+              e.hasOwnProperty(n) === this.params &&
+                ((this.done = !0), (this.success = !0));
+            }),
+            n
+          );
+        })(i.BaseOperation),
+        h = (function(t) {
+          function n(n, e, r) {
+            return (
+              t.call(
+                this,
+                n,
+                e,
+                r,
+                n.map(function(t) {
+                  return i.createQueryOperation(t, e, r);
+                })
+              ) || this
+            );
+          }
+          return (
+            o(n, t),
+            (n.prototype.next = function(t, n, e) {
+              this.childrenNext(t, n, e);
+            }),
+            n
+          );
+        })(i.GroupOperation),
+        y = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n < t;
+            },
+            n,
+            e
+          );
+        }),
+        O = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n <= t;
+            },
+            n,
+            e
+          );
+        }),
+        d = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n > t;
+            },
+            n,
+            e
+          );
+        }),
+        v = i.numericalOperationCreator(function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n >= t;
+            },
+            n,
+            e
+          );
+        }),
+        _ = function(t, n, e) {
+          return new h(t, n, e);
+        },
+        b = _;
+      n.creators = {
+        $lt: y,
+        $lte: O,
+        $mod: function(t, n, e) {
+          var r = t[0],
+            o = t[1];
+          return new i.EqualsOperation(
+            function(t) {
+              return u.comparable(t) % r === o;
+            },
+            n,
+            e
+          );
+        },
+        $gt: d,
+        $gte: v,
+        $eq: function(t, n, e) {
+          return new i.EqualsOperation(t, n, e);
+        },
+        $or: function(t, n, e) {
+          return new p(t, n, e);
+        },
+        $nor: function(t, n, e) {
+          return new f(t, n, e);
+        },
+        $and: _,
+        $options: function() {
+          return null;
+        },
+        $regex: function(t, n, e) {
+          return new i.EqualsOperation(new RegExp(t, n.$options), n, e);
+        },
+        $ne: function(t, n, e) {
+          return new s(t, n, e);
+        },
+        $nin: function(t, n, e) {
+          return new f(t, n, e);
+        },
+        $all: b,
+        $size: function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return n && n.length === t;
+            },
+            n,
+            e
+          );
+        },
+        $in: function(t, n, e) {
+          return new p(t, n, e);
+        },
+        $type: function(t, n, e) {
+          return new i.EqualsOperation(
+            function(n) {
+              return null != n && (n instanceof t || n.constructor === t);
+            },
+            n,
+            e
+          );
+        },
+        $elemMatch: function(t, n, e) {
+          return new c(t, n, e);
+        },
+        $exists: function(t, n, e) {
+          return new l(t, n, e);
+        },
+        $not: function(t, n, e) {
+          return new a(t, n, e);
+        },
+        $where: function(t, n, e) {
+          var r;
+          return (
+            (r = u.isFunction(t) ? t : new Function("obj", "return " + t)),
+            new i.EqualsOperation(
+              function(t) {
+                return r.bind(t)(t);
+              },
+              n,
+              e
+            )
+          );
+        }
       };
@@ -383,0 +648,0 @@ }

src/core.ts

@@ -1,213 +0,307 @@
-import {
-  equals,
-  isArray,
-  isVanillaObject,
-  get,
-  isFunction,
-  comparable,
-  nope
-} from "./utils";
+import { isArray, Key, Comparator, isVanillaObject, comparable } from "./utils";
 
-type Key = string | number;
-type Filter = (item: any, key: Key, parent: any) => boolean;
+export interface Operation {
+  readonly success: boolean;
+  readonly done: boolean;
+  reset();
+  next(item: any, key: Key, owner: any);
+}
 
-type $And = any;
+export type Tester = (item: any, key?: Key, owner?: any) => boolean;
 
-type $Or = any;
+export type OperationCreator = (
+  params: any,
+  parentQuery: any,
+  options: Options
+) => Operation;
 
-type FieldQuery = any;
+/**
+ * Walks through each value given the context - used for nested operations. E.g:
+ * { "person.address": { $eq: "blarg" }}
+ */
 
-type $Eq = any;
+const walkKeyPathValues = (
+  item: any,
+  keyPath: Key[],
+  next: Tester,
+  depth: number,
+  key: Key,
+  owner: any
+) => {
+  const currentKey = keyPath[depth];
 
-type Query<TItem> = {
-  $and?: $And;
-  $or?: $Or;
-  $eq?: $Eq;
-  [identifier: string]: FieldQuery;
-};
-type FilterCreator = (
-  params: any,
-  options: Options,
-  parentQuery: Query<any>
-) => (item: any) => boolean;
+  // if array, then try matching. Might fall through for cases like:
+  // { $eq: [1, 2, 3] }, [ 1, 2, 3 ].
+  if (isArray(item) && isNaN(Number(currentKey))) {
+    for (let i = 0, { length } = item; i < length; i++) {
+      // if FALSE is returned, then terminate walker. For operations, this simply
+      // means that the search critera was met.
+      if (!walkKeyPathValues(item[i], keyPath, next, depth, i, item)) {
+        return false;
+      }
+    }
+  }
 
-type CustomOperations = {
-  [identifier: string]: FilterCreator;
-};
+  if (depth === keyPath.length || item == null) {
+    return next(item, key, owner);
+  }
 
-type Options = {
-  expressions: CustomOperations;
-  compare: (a, b) => boolean;
+  return walkKeyPathValues(
+    item[currentKey],
+    keyPath,
+    next,
+    depth + 1,
+    currentKey,
+    item
+  );
 };
 
-const containsOperation = query => {
-  for (const key in query) {
-    if (key.charAt(0) === "$") return true;
+export abstract class BaseOperation<TParams> implements Operation {
+  success: boolean;
+  done: boolean;
+  constructor(
+    readonly params: TParams,
+    readonly owneryQuery: any,
+    readonly options: Options
+  ) {
+    this.init();
   }
-  return false;
-};
+  protected init() {}
+  reset() {
+    this.done = false;
+    this.success = false;
+  }
+  abstract next(item: any, key: Key, parent: any);
+}
 
-const spreadValueArray = filter => (item, key, parent) => {
-  if (!isArray(item) || !item.length) {
-    return filter(item, key, parent);
+export abstract class GroupOperation extends BaseOperation<any> {
+  success: boolean;
+  done: boolean;
+
+  constructor(
+    params: any,
+    owneryQuery: any,
+    options: Options,
+    private readonly _children: Operation[]
+  ) {
+    super(params, owneryQuery, options);
   }
-  for (let i = 0, { length } = item; i < length; i++) {
-    if (filter(get(item, i), key, parent)) {
-      return true;
+
+  /**
+   */
+
+  reset() {
+    this.success = false;
+    this.done = false;
+    for (let i = 0, { length } = this._children; i < length; i++) {
+      this._children[i].reset();
     }
   }
-  return false;
-};
 
-const numericalOperation = createFilter => params => {
-  const comparableParams = comparable(params);
-  if (comparableParams == null) return nope;
-  return spreadValueArray(createFilter(comparableParams));
-};
+  abstract next(item: any, key: Key, owner: any);
 
-const createRegexpTester = tester => item =>
-  typeof item === "string" && tester.test(item);
+  /**
+   */
 
-const createTester = (params, { compare = equals }) => {
-  if (isFunction(params)) {
-    return params;
+  protected childrenNext(item: any, key: Key, owner: any) {
+    let done = true;
+    let success = true;
+    for (let i = 0, { length } = this._children; i < length; i++) {
+      const childOperation = this._children[i];
+      childOperation.next(item, key, owner);
+      if (!childOperation.success) {
+        success = false;
+      }
+      if (childOperation.done) {
+        if (!childOperation.success) {
+          break;
+        }
+      } else {
+        done = false;
+      }
+    }
+    this.done = done;
+    this.success = success;
   }
-  if (params instanceof RegExp) {
-    return createRegexpTester(params);
+}
+
+export class QueryOperation extends GroupOperation {
+  /**
+   */
+
+  next(item: any, key: Key, parent: any) {
+    this.childrenNext(item, key, parent);
   }
-  const comparableParams = comparable(params);
-  return (item, key: Key, parent: any) => {
-    return compare(comparableParams, comparable(item));
-  };
-};
-const createNestedFilter = <TItem>(
-  property: string,
-  query: Query<TItem>,
-  options: Options
-): Filter => {
-  const filter = containsOperation(query)
-    ? createAndFilter(createQueryFilters(query, options))
-    : createTester(query, options);
+}
 
-  const pathParts = property.split(".");
+export class NestedOperation extends GroupOperation {
+  constructor(
+    readonly keyPath: Key[],
+    params: any,
+    owneryQuery: any,
+    options: Options,
+    children: Operation[]
+  ) {
+    super(params, owneryQuery, options, children);
+  }
+  /**
+   */
 
-  // If the query contains $ne, need to test all elements ANDed together
-  const inclusive = query && query.$ne != null;
+  next(item: any, key: Key, parent: any) {
+    walkKeyPathValues(
+      item,
+      this.keyPath,
+      this._nextNestedValue,
+      0,
+      key,
+      parent
+    );
+  }
 
-  return (item: TItem, key: Key, parent: any) => {
-    return filterNested(filter, inclusive, item, pathParts, parent, 0);
+  /**
+   */
+
+  private _nextNestedValue = (value: any, key: Key, owner: any) => {
+    this.childrenNext(value, key, owner);
+    return !this.done;
   };
+}
+
+export const createTester = (a, compare: Comparator) => {
+  if (a instanceof Function) {
+    return a;
+  }
+  if (a instanceof RegExp) {
+    return b => typeof b === "string" && a.test(b);
+  }
+  const comparableA = comparable(a);
+  return b => compare(comparableA, comparable(b));
 };
 
-const filterNested = (
-  filter: Filter,
-  inclusive: boolean,
-  item: any,
-  keyPath: Key[],
-  parent: any,
-  depth: number
-): boolean => {
-  const currentKey = keyPath[depth];
-
-  if (isArray(item) && isNaN(Number(currentKey))) {
-    let allValid;
-    for (let i = 0, { length } = item; i < length; i++) {
-      const include = filterNested(
-        filter,
-        inclusive,
-        get(item, i),
-        keyPath,
-        parent,
-        depth
-      );
-      if (inclusive && allValid != null) {
-        allValid = allValid && include;
-      } else {
-        allValid = allValid || include;
-      }
+export class EqualsOperation<TParam> extends BaseOperation<TParam> {
+  private _test: Tester;
+  init() {
+    this._test = createTester(this.params, this.options.compare);
+  }
+  next(item, key: Key, parent: any) {
+    if (this._test(item, key, parent)) {
+      this.done = true;
+      this.success = true;
     }
-    return allValid;
   }
+}
 
-  const child = get(item, currentKey);
-
-  if (item && child == null) {
-    return filter(undefined, currentKey, item);
+export class NopeOperation<TParam> extends BaseOperation<TParam> {
+  next() {
+    this.done = true;
+    this.success = false;
   }
+}
 
-  if (depth === keyPath.length - 1) {
-    return filter(child, currentKey, item);
-  }
+export const numericalOperationCreator = (
+  createNumericalOperation: OperationCreator
+) => (params: number, owneryQuery: any, options: Options) =>
+  params == null
+    ? new NopeOperation(params, owneryQuery, options)
+    : createNumericalOperation(params, owneryQuery, options);
 
-  return filterNested(filter, inclusive, child, keyPath, item, depth + 1);
+export type Options = {
+  operations: {
+    [identifier: string]: OperationCreator;
+  };
+  compare: (a, b) => boolean;
 };
 
-const createQueryFilters = <TItem>(query: Query<TItem>, options: Options) => {
-  const filters = [];
-  if (!isVanillaObject(query)) {
-    query = { $eq: query };
+const createOperation = (
+  name: string,
+  params: any,
+  parentQuery: any,
+  options: Options
+) => {
+  const operationCreator = options.operations[name];
+  if (!operationCreator) {
+    throw new Error(`Unsupported operation: ${name}`);
   }
+  return operationCreator(params, parentQuery, options);
+};
 
-  for (const property in query) {
-    const params = query[property];
-
-    // operation
-    if (property.charAt(0) === "$") {
-      filters.push(createOperationFilter(property, params, query, options));
-    } else {
-      filters.push(createNestedFilter(property, params as Query<any>, options));
+const containsOperation = (query: any) => {
+  for (const key in query) {
+    if (key.charAt(0) === "$") return true;
+  }
+  return false;
+};
+const createNestedOperation = (
+  keyPath: Key[],
+  nestedQuery: any,
+  owneryQuery: any,
+  options: Options
+) => {
+  if (containsOperation(nestedQuery)) {
+    const [selfOperations, nestedOperations] = createQueryOperations(
+      nestedQuery,
+      options
+    );
+    if (nestedOperations.length) {
+      throw new Error(
+        `Property queries must contain only operations, or exact objects.`
+      );
     }
+    return new NestedOperation(
+      keyPath,
+      nestedQuery,
+      owneryQuery,
+      options,
+      selfOperations
+    );
   }
-
-  return filters;
+  return new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [
+    new EqualsOperation(nestedQuery, owneryQuery, options)
+  ]);
 };
 
-const createOperationFilter = (
-  operation: string,
-  params: any,
-  parentQuery: Query<any>,
+export const createQueryOperation = (
+  query: any,
+  owneryQuery: any,
   options: Options
-): Filter => {
-  const createFilter = options.expressions[operation];
+) => {
+  const [selfOperations, nestedOperations] = createQueryOperations(
+    query,
+    options
+  );
 
-  if (!createFilter) {
-    throw new Error(`Unsupported operation ${operation}`);
+  const ops = [
+    new NestedOperation([], query, owneryQuery, options, selfOperations),
+    ...nestedOperations
+  ];
+
+  if (ops.length === 1) {
+    return ops[0];
   }
 
-  return createFilter(params, options, parentQuery);
+  return new QueryOperation(query, owneryQuery, options, ops);
 };
 
-const createAndFilter = <TItem>(filters: Filter[]) => {
-  return (item: TItem, key: Key, parent: any) => {
-    for (let i = filters.length; i--; ) {
-      if (!filters[i](item, key, parent)) return false;
-    }
-    return true;
-  };
-};
+const createQueryOperations = (query: any, options: Options) => {
+  const selfOperations = [];
+  const nestedOperations = [];
+  if (!isVanillaObject(query)) {
+    query = { $eq: query };
+  }
+  for (const key in query) {
+    if (key.charAt(0) === "$") {
+      const op = createOperation(key, query[key], query, options);
 
-const createOrFilter = <TItem>(filters: Filter[]) => {
-  return (item: TItem, key: Key, parent: any) => {
-    for (let i = filters.length; i--; ) {
-      if (filters[i](item, key, parent)) return true;
+      // probably just a flag for another operation (like $options)
+      if (op != null) {
+        selfOperations.push(op);
+      }
+    } else {
+      nestedOperations.push(
+        createNestedOperation(key.split("."), query[key], query, options)
+      );
     }
-    return false;
-  };
-};
+  }
 
-export {
-  Key,
-  Filter,
-  Query,
-  FilterCreator,
-  spreadValueArray,
-  createQueryFilters,
-  createNestedFilter,
-  createTester,
-  numericalOperation,
-  createOrFilter,
-  CustomOperations,
-  Options,
-  createAndFilter,
-  createRegexpTester
+  return [selfOperations, nestedOperations];
 };

src/index.ts

@@ -1,37 +0,27 @@
-import { Query } from "./query";
+import { Query, creators } from "./operations";
 import {
-  isArray,
-  get,
-  nope,
-  hasNestedProperty,
-  isVanillaObject,
-  equals,
-  isFunction,
-  comparable
-} from "./utils";
-
-import * as defaultOperations from "./operations";
-import {
-  createNestedFilter,
-  createQueryFilters,
-  createAndFilter,
   Options,
-  Key,
-  Filter,
-  CustomOperations,
-  FilterCreator
+  createQueryOperation,
+  EqualsOperation,
+  BaseOperation
 } from "./core";
+import { equals, Key } from "./utils";
 
-const createFilter = <TItem>(
-  query: Query<TItem>,
-  { compare, expressions }: Partial<Options> = {}
+const createRootTester = (
+  query: Query,
+  { compare, operations }: Partial<Options> = {}
 ) => {
-  return createAndFilter(
-    createQueryFilters(query, {
-      compare: compare || equals,
-      expressions: Object.assign({}, defaultOperations, expressions)
-    })
-  );
+  const operation = createQueryOperation(query, null, {
+    compare: compare || equals,
+    operations: Object.assign({}, creators, operations || {})
+  });
+  return (item, key?: Key, owner?: any) => {
+    operation.reset();
+    operation.next(item, key, owner);
+    return operation.success;
+  };
 };
 
-export default createFilter;
+export { Query, EqualsOperation };
+
+export default createRootTester;

src/operations.ts

@@ -1,96 +0,211 @@
-import { comparable, isFunction } from "./utils";
 import {
-  spreadValueArray,
-  createQueryFilters,
+  BaseOperation,
+  EqualsOperation,
   Options,
-  createOrFilter,
-  createAndFilter,
-  createRegexpTester,
   createTester,
-  numericalOperation,
-  createNestedFilter
+  Tester,
+  createQueryOperation,
+  QueryOperation,
+  numericalOperationCreator,
+  Operation,
+  GroupOperation
 } from "./core";
+import { Key, comparable, isFunction } from "./utils";
 
-const $eq = (params, options) =>
-  spreadValueArray(createTester(params, options));
-const $ne = (params, options) => {
-  const filter = $eq(params, options);
-  return (item, key, parent) => {
-    return !filter(item, key, parent);
-  };
-};
+class $Ne extends BaseOperation<any> {
+  private _test: Tester;
+  init() {
+    this._test = createTester(this.params, this.options.compare);
+  }
+  reset() {
+    super.reset();
+    this.success = true;
+  }
+  next(item: any) {
+    if (this._test(item)) {
+      this.done = true;
+      this.success = false;
+    }
+  }
+}
 
-const $gt = numericalOperation(params => item => comparable(item) > params);
-const $gte = numericalOperation(params => item => comparable(item) >= params);
-const $lt = numericalOperation(params => item => comparable(item) < params);
-const $lte = numericalOperation(params => item => comparable(item) <= params);
-const $mod = numericalOperation(([mod, equalsValue]) => item =>
-  comparable(item) % mod === equalsValue
-);
+class $ElemMatch extends BaseOperation<Query> {
+  private _queryOperation: QueryOperation;
+  init() {
+    this._queryOperation = createQueryOperation(
+      this.params,
+      this.owneryQuery,
+      this.options
+    );
+  }
+  reset() {
+    this._queryOperation.reset();
+  }
+  next(item: any, key: Key, owner: any) {
+    this._queryOperation.next(item, key, owner);
+    this.done = this._queryOperation.done;
+    this.success = this._queryOperation.success;
+  }
+}
 
-const $exists = params =>
-  spreadValueArray((item, key, parent) => {
-    return parent.hasOwnProperty(key) === params;
-  });
+class $Not extends $ElemMatch {
+  next(item: any, key: Key, owner: any) {
+    super.next(item, key, owner);
+    this.success = !this.success;
+  }
+}
 
-const $in = (params, options) => {
-  const filter = $or(params, options);
-  return (item, key, parent) => {
-    return filter(item, key, parent);
-  };
-};
+class $Or extends BaseOperation<any> {
+  private _ops: Operation[];
+  init() {
+    this._ops = this.params.map(op =>
+      createQueryOperation(op, null, this.options)
+    );
+  }
+  reset() {
+    this.done = false;
+    this.success = false;
+    for (let i = 0, { length } = this._ops; i < length; i++) {
+      this._ops[i].reset();
+    }
+  }
+  next(item: any, key: Key, owner: any) {
+    let done = false;
+    let success = false;
+    for (let i = 0, { length } = this._ops; i < length; i++) {
+      const op = this._ops[i];
+      op.next(item, key, owner);
+      if (op.success) {
+        done = true;
+        success = op.success;
+        break;
+      }
+    }
 
-const $nin = (params, options) => {
-  const filter = $in(params, options);
-  return (item, key, value) => {
-    return !filter(item, key, value);
-  };
-};
+    this.success = success;
+    this.done = done;
+  }
+}
 
-const $and = (params, options) => {
-  const filter = createAndFilter(
-    params.map(query => createOrFilter(createQueryFilters(query, options)))
-  );
-  return filter;
-};
+class $Nor extends $Or {
+  next(item: any, key: Key, owner: any) {
+    super.next(item, key, owner);
+    this.success = !this.success;
+  }
+}
 
-const $options = params => item => true;
+class $Exists extends BaseOperation<boolean> {
+  next(item: any, key: Key, owner: any) {
+    if (owner.hasOwnProperty(key) === this.params) {
+      this.done = true;
+      this.success = true;
+    }
+  }
+}
 
-const $not = (query, options) => {
-  const filter = createAndFilter(createQueryFilters(query, options));
-  return (item, key, parent) => !filter(item, key, parent);
+class $And extends GroupOperation {
+  constructor(params: Query[], owneryQuery: Query, options: Options) {
+    super(
+      params,
+      owneryQuery,
+      options,
+      params.map(query => createQueryOperation(query, owneryQuery, options))
+    );
+  }
+  next(item: any, key: Key, owner: any) {
+    this.childrenNext(item, key, owner);
+  }
+}
+
+export type Query = {
+  [identifier: string]: Query | Object;
+  $eq?: any;
+  $ne?: any;
+  $elemMatch?: Query;
+  $lt?: number;
+  $gt?: number;
+  $lte?: number;
+  $gte?: number;
+  $mod?: [number, number];
+  $exists?: boolean;
+  $regex?: string;
+  $options?: "i" | "g" | "m" | "u";
+  $type: Function;
+  $or?: Query[];
+  $nor?: Query[];
 };
-const $size = size => item => item && item.length === size;
-const $all = (query, options) => $and(query, options);
-const $type = clazz =>
-  spreadValueArray(item => {
-    return item == undefined
-      ? false
-      : item instanceof clazz || item.constructor === clazz;
-  });
-const $regex = (pattern, options, { $options }) => {
-  const tester =
-    pattern instanceof RegExp ? pattern : new RegExp(pattern, $options);
-  return spreadValueArray(createRegexpTester(tester));
-};
-const $elemMatch = (query, options: Options) => {
-  const filter = createAndFilter(createQueryFilters(query, options));
-  return filter;
-};
-const $or = (params, options: Options) => {
-  return createOrFilter(
-    params.map(query => createAndFilter(createQueryFilters(query, options)))
+
+const $eq = (params: any, owneryQuery: Query, options: Options) =>
+  new EqualsOperation(params, owneryQuery, options);
+const $ne = (params: any, owneryQuery: Query, options: Options) =>
+  new $Ne(params, owneryQuery, options);
+const $or = (params: Query[], owneryQuery: Query, options: Options) =>
+  new $Or(params, owneryQuery, options);
+const $nor = (params: Query[], owneryQuery: Query, options: Options) =>
+  new $Nor(params, owneryQuery, options);
+const $elemMatch = (params: any, owneryQuery: Query, options: Options) =>
+  new $ElemMatch(params, owneryQuery, options);
+const $nin = (params: any, owneryQuery: Query, options: Options) =>
+  new $Nor(params, owneryQuery, options);
+const $in = (params: any, owneryQuery: Query, options: Options) =>
+  new $Or(params, owneryQuery, options);
+const $lt = numericalOperationCreator(
+  (params: any, owneryQuery: Query, options: Options) =>
+    new EqualsOperation(b => b < params, owneryQuery, options)
+);
+const $lte = numericalOperationCreator(
+  (params: any, owneryQuery: Query, options: Options) =>
+    new EqualsOperation(b => b <= params, owneryQuery, options)
+);
+const $gt = numericalOperationCreator(
+  (params: any, owneryQuery: Query, options: Options) =>
+    new EqualsOperation(b => b > params, owneryQuery, options)
+);
+const $gte = numericalOperationCreator(
+  (params: any, owneryQuery: Query, options: Options) =>
+    new EqualsOperation(b => b >= params, owneryQuery, options)
+);
+const $mod = (
+  [mod, equalsValue]: number[],
+  owneryQuery: Query,
+  options: Options
+) =>
+  new EqualsOperation(
+    b => comparable(b) % mod === equalsValue,
+    owneryQuery,
+    options
   );
-};
-const $nor = (params, options: Options) => {
-  const filter = $or(params, options);
-  return (item, key, parent) => !filter(item, key, parent);
-};
-const $where = query => {
-  let tester;
+const $exists = (params: boolean, owneryQuery: Query, options: Options) =>
+  new $Exists(params, owneryQuery, options);
+const $regex = (pattern: string, owneryQuery: Query, options: Options) =>
+  new EqualsOperation(
+    new RegExp(pattern, owneryQuery.$options),
+    owneryQuery,
+    options
+  );
+const $not = (params: any, owneryQuery: Query, options: Options) =>
+  new $Not(params, owneryQuery, options);
+const $type = (clazz: Function, owneryQuery: Query, options: Options) =>
+  new EqualsOperation(
+    b => (b != null ? b instanceof clazz || b.constructor === clazz : false),
+    owneryQuery,
+    options
+  );
+const $and = (params: Query[], ownerQuery: Query, options: Options) =>
+  new $And(params, ownerQuery, options);
+const $all = $and;
+const $size = (params: number, ownerQuery: Query, options: Options) =>
+  new EqualsOperation(b => b && b.length === params, ownerQuery, options);
+const $options = () => null;
+const $where = (
+  params: string | Function,
+  ownerQuery: Query,
+  options: Options
+) => {
+  let test;
 
-  if (isFunction(query)) {
-    tester = query;
+  if (isFunction(params)) {
+    test = params;
   } else if (!process.env.CSP_ENABLED) {
-    tester = new Function("obj", "return " + query);
+    test = new Function("obj", "return " + params);
   } else {
@@ -102,27 +217,27 @@ throw new Error(
 
-  return item => tester.bind(item)(item);
+  return new EqualsOperation(b => test.bind(b)(b), ownerQuery, options);
 };
 
-export {
-  $eq,
-  $ne,
+export const creators = {
+  $lt,
+  $lte,
+  $mod,
   $gt,
   $gte,
-  $lt,
-  $lte,
-  $elemMatch,
-  $and,
+  $eq,
   $or,
   $nor,
-  $where,
+  $and,
+  $options,
   $regex,
-  $type,
+  $ne,
+  $nin,
   $all,
   $size,
-  $options,
+  $in,
+  $type,
+  $elemMatch,
   $exists,
   $not,
-  $in,
-  $nin,
-  $mod
+  $where
 };

src/utils.ts

@@ -1,9 +0,13 @@
-const typeChecker = <TType>(type) => {
+export type Key = string | number;
+export type Comparator = (a, b) => boolean;
+export const typeChecker = <TType>(type) => {
   const typeString = "[object " + type + "]";
   return function(value): value is TType {
-    return Object.prototype.toString.call(value) === typeString;
+    return getClassName(value) === typeString;
   };
 };
 
-const comparable = (value: any) => {
+const getClassName = value => Object.prototype.toString.call(value);
+
+export const comparable = (value: any) => {
   if (value instanceof Date) {
@@ -20,9 +24,6 @@ return value.getTime();
 
-const get = (object, key) =>
-  isFunction(object.get) ? object.get(key) : object[key];
-
-const isArray = typeChecker<Array<any>>("Array");
-const isObject = typeChecker<Object>("Object");
-const isFunction = typeChecker<Function>("Function");
-const isVanillaObject = value => {
+export const isArray = typeChecker<Array<any>>("Array");
+export const isObject = typeChecker<Object>("Object");
+export const isFunction = typeChecker<Function>("Function");
+export const isVanillaObject = value => {
   return (
@@ -38,3 +39,3 @@ value &&
 
-const equals = (a, b) => {
+export const equals = (a, b) => {
   if (a == null && a == b) {
@@ -70,28 +71,1 @@ return true;
 };
-
-const hasNestedProperty = (object, key) => {
-  const parts = String(key).split(".");
-  let current = object;
-  if (parts.length === 1) {
-    return current.hasOwnProperty(key);
-  }
-  for (let i = 0, n = parts.length - 1; i < n; i++) {
-    current = current[parts[i]];
-    if (!current) return false;
-  }
-  return current.hasOwnProperty(parts[parts.length - 1]);
-};
-
-const nope = () => false;
-
-export {
-  get,
-  nope,
-  equals,
-  isArray,
-  isObject,
-  comparable,
-  isFunction,
-  isVanillaObject,
-  hasNestedProperty
-};

test/basic-test.js

@@ -45,3 +45,3 @@ import * as assert from "assert";
 
-    assert.equal(err.message, "Unsupported operation $aaa");
+    assert.equal(err.message, "Unsupported operation: $aaa");
   });
@@ -48,0 +48,0 @@

test/immutable-test.js

@@ -15,5 +15,5 @@ import * as assert from "assert";
 
-  it("works with Immutable.Map in a Immutable.List", function() {
+  xit("works with Immutable.Map in a Immutable.List", function() {
     assert.equal(persons.filter(sift({ "person.age": { $gt: 4 } })).size, 2);
   });
 });

test/operations-test.js

@@ -8,6 +8,12 @@ import * as assert from "assert";
     [
-      { "foo.0": "baz" },
-      [{ foo: ["bar", "baz"] }, { foo: ["baz", "bar"] }],
-      [{ foo: ["baz", "bar"] }]
+      {
+        $where: function() {
+          return this.v === 1;
+        }
+      },
+      [{ v: 1 }, { v: 2 }],
+      [{ v: 1 }]
     ],
+    [{ $where: "this.v === 1" }, [{ v: 1 }, { v: 2 }], [{ v: 1 }]],
+    [{ $where: "obj.v === 1" }, [{ v: 1 }, { v: 2 }], [{ v: 1 }]],
 
@@ -286,33 +292,60 @@ // $eq
     [
-      { 'order.items.product': { $all: ['poster', 'frame'] } },
-      [{
-        "order" : {
-          "id" : "or_0001",
-          "amount" : 6000,
-          "items" : [
-            {
-              "product" : "poster",
-              "sku" : "P18x24",
-              "quantity" : 1,
-              "amount" : 3000
-            },
-            {
-              "product" : "frame",
-              "sku" : "P18x24",
-              "quantity" : 1,
-              "amount" : 3000
-            },
-            {
-              "product" : "shipping",
-              "sku" : "shipping",
-              "quantity" : 1,
-              "amount" : 5000
-            }
-          ]
+      { "order.items.product": { $all: ["poster", "frame"] } },
+      [
+        {
+          order: {
+            id: "or_0001",
+            amount: 6000,
+            items: [
+              {
+                product: "poster",
+                sku: "P18x24",
+                quantity: 1,
+                amount: 3000
+              },
+              {
+                product: "frame",
+                sku: "P18x24",
+                quantity: 1,
+                amount: 3000
+              },
+              {
+                product: "shipping",
+                sku: "shipping",
+                quantity: 1,
+                amount: 5000
+              }
+            ]
+          }
         }
-      }],
+      ],
       [
-
+        {
+          order: {
+            id: "or_0001",
+            amount: 6000,
+            items: [
+              {
+                product: "poster",
+                sku: "P18x24",
+                quantity: 1,
+                amount: 3000
+              },
+              {
+                product: "frame",
+                sku: "P18x24",
+                quantity: 1,
+                amount: 3000
+              },
+              {
+                product: "shipping",
+                sku: "shipping",
+                quantity: 1,
+                amount: 5000
+              }
+            ]
+          }
+        }
       ]
-    ]
+    ],
 
@@ -319,0 +352,0 @@ // $size

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses eval() which is a dangerous function. This prevents the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses eval() which is a dangerous function. This prevents the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

380231

increased by13.41%

Dependency count

0

decreased by-100%

Lines of code

3878

increased by17.94%

Number of lines in readme file

474

increased by1.72%

Number of low supply chain risk alerts

4

decreased by-20%

Worsened metrics

Dev dependency count

15

increased by7.14%

Number of package files

33

decreased by-10.81%

Dependency changes

• - Removed@babel/register@^7.7.7

• - Removed@ampproject/remapping@2.3.0(transitive)

• - Removed@babel/code-frame@7.24.7(transitive)

• - Removed@babel/compat-data@7.25.4(transitive)

• - Removed@babel/core@7.25.2(transitive)

• - Removed@babel/generator@7.25.6(transitive)

• - Removed@babel/helper-compilation-targets@7.25.2(transitive)

• - Removed@babel/helper-module-imports@7.24.7(transitive)

• - Removed@babel/helper-module-transforms@7.25.2(transitive)

• - Removed@babel/helper-simple-access@7.24.7(transitive)

• - Removed@babel/helper-string-parser@7.24.8(transitive)

• - Removed@babel/helper-validator-identifier@7.24.7(transitive)

• - Removed@babel/helper-validator-option@7.24.8(transitive)

• - Removed@babel/helpers@7.25.6(transitive)

• - Removed@babel/highlight@7.24.7(transitive)

• - Removed@babel/parser@7.25.6(transitive)

• - Removed@babel/register@7.24.6(transitive)

• - Removed@babel/template@7.25.0(transitive)

• - Removed@babel/traverse@7.25.6(transitive)

• - Removed@babel/types@7.25.6(transitive)

• - Removed@jridgewell/gen-mapping@0.3.5(transitive)

• - Removed@jridgewell/resolve-uri@3.1.2(transitive)

• - Removed@jridgewell/set-array@1.2.1(transitive)

• - Removed@jridgewell/sourcemap-codec@1.5.0(transitive)

• - Removed@jridgewell/trace-mapping@0.3.25(transitive)

• - Removedansi-styles@3.2.1(transitive)

• - Removedbrowserslist@4.23.3(transitive)

• - Removedbuffer-from@1.1.2(transitive)

• - Removedcaniuse-lite@1.0.30001660(transitive)

• - Removedchalk@2.4.2(transitive)

• - Removedclone-deep@4.0.1(transitive)

• - Removedcolor-convert@1.9.3(transitive)

• - Removedcolor-name@1.1.3(transitive)

• - Removedcommondir@1.0.1(transitive)

• - Removedconvert-source-map@2.0.0(transitive)

• - Removeddebug@4.3.7(transitive)

• - Removedelectron-to-chromium@1.5.24(transitive)

• - Removedescalade@3.2.0(transitive)

• - Removedescape-string-regexp@1.0.5(transitive)

• - Removedfind-cache-dir@2.1.0(transitive)

• - Removedfind-up@3.0.0(transitive)

• - Removedgensync@1.0.0-beta.2(transitive)

• - Removedglobals@11.12.0(transitive)

• - Removedhas-flag@3.0.0(transitive)

• - Removedis-plain-object@2.0.4(transitive)

• - Removedisobject@3.0.1(transitive)

• - Removedjs-tokens@4.0.0(transitive)

• - Removedjsesc@2.5.2(transitive)

• - Removedjson5@2.2.3(transitive)

• - Removedkind-of@6.0.3(transitive)

• - Removedlocate-path@3.0.0(transitive)

• - Removedlru-cache@5.1.1(transitive)

• - Removedmake-dir@2.1.0(transitive)

• - Removedms@2.1.3(transitive)

• - Removednode-releases@2.0.18(transitive)

• - Removedp-limit@2.3.0(transitive)

• - Removedp-locate@3.0.0(transitive)

• - Removedp-try@2.2.0(transitive)

• - Removedpath-exists@3.0.0(transitive)

• - Removedpicocolors@1.1.0(transitive)

• - Removedpify@4.0.1(transitive)

• - Removedpirates@4.0.6(transitive)

• - Removedpkg-dir@3.0.0(transitive)

• - Removedsemver@5.7.26.3.1(transitive)

• - Removedshallow-clone@3.0.1(transitive)

• - Removedsource-map@0.6.1(transitive)

• - Removedsource-map-support@0.5.21(transitive)

• - Removedsupports-color@5.5.0(transitive)

• - Removedto-fast-properties@2.0.0(transitive)

• - Removedupdate-browserslist-db@1.1.0(transitive)

• - Removedyallist@3.1.1(transitive)