create-mern-omar 1.1.0 → 1.2.0

package/templates/node_modules/sift/sift.csp.min.js

@@ -1,778 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sift = {}));
-})(this, (function (exports) { 'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol */
-
-    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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    var typeChecker = function (type) {
-        var typeString = "[object " + type + "]";
-        return function (value) {
-            return getClassName(value) === typeString;
-        };
-    };
-    var getClassName = function (value) { return Object.prototype.toString.call(value); };
-    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 coercePotentiallyNull = function (value) {
-        return value == null ? null : value;
-    };
-    var isArray = typeChecker("Array");
-    var isObject = typeChecker("Object");
-    var isFunction = typeChecker("Function");
-    var isProperty = function (item, key) {
-        return item.hasOwnProperty(key) && !isFunction(item[key]);
-    };
-    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);
-    };
-    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;
-            }
-            for (var i = 0, length_1 = a.length; i < length_1; i++) {
-                if (!equals(a[i], b[i]))
-                    return false;
-            }
-            return true;
-        }
-        else if (isObject(a)) {
-            if (Object.keys(a).length !== Object.keys(b).length) {
-                return false;
-            }
-            for (var key in a) {
-                if (!equals(a[key], b[key]))
-                    return false;
-            }
-            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 (isArray(item) &&
-            isNaN(Number(currentKey)) &&
-            !isProperty(item, 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, depth === 0, depth === keyPath.length);
-        }
-        return walkKeyPathValues(item[currentKey], keyPath, next, depth + 1, currentKey, item);
-    };
-    var BaseOperation = /** @class */ (function () {
-        function BaseOperation(params, owneryQuery, options, name) {
-            this.params = params;
-            this.owneryQuery = owneryQuery;
-            this.options = options;
-            this.name = name;
-            this.init();
-        }
-        BaseOperation.prototype.init = function () { };
-        BaseOperation.prototype.reset = function () {
-            this.done = false;
-            this.keep = false;
-        };
-        return 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;
-        }
-        /**
-         */
-        GroupOperation.prototype.reset = function () {
-            this.keep = 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, root, leaf) {
-            var done = true;
-            var keep = true;
-            for (var i = 0, length_3 = this.children.length; i < length_3; i++) {
-                var childOperation = this.children[i];
-                if (!childOperation.done) {
-                    childOperation.next(item, key, owner, root, leaf);
-                }
-                if (!childOperation.keep) {
-                    keep = false;
-                }
-                if (childOperation.done) {
-                    if (!childOperation.keep) {
-                        break;
-                    }
-                }
-                else {
-                    done = false;
-                }
-            }
-            this.done = done;
-            this.keep = keep;
-        };
-        return GroupOperation;
-    }(BaseOperation));
-    var NamedGroupOperation = /** @class */ (function (_super) {
-        __extends(NamedGroupOperation, _super);
-        function NamedGroupOperation(params, owneryQuery, options, children, name) {
-            var _this = _super.call(this, params, owneryQuery, options, children) || this;
-            _this.name = name;
-            return _this;
-        }
-        return NamedGroupOperation;
-    }(GroupOperation));
-    var QueryOperation = /** @class */ (function (_super) {
-        __extends(QueryOperation, _super);
-        function QueryOperation() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        /**
-         */
-        QueryOperation.prototype.next = function (item, key, parent, root) {
-            this.childrenNext(item, key, parent, root);
-        };
-        return QueryOperation;
-    }(GroupOperation));
-    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.propop = true;
-            /**
-             */
-            _this._nextNestedValue = function (value, key, owner, root, leaf) {
-                _this.childrenNext(value, key, owner, root, leaf);
-                return !_this.done;
-            };
-            return _this;
-        }
-        /**
-         */
-        NestedOperation.prototype.next = function (item, key, parent) {
-            walkKeyPathValues(item, this.keyPath, this._nextNestedValue, 0, key, parent);
-        };
-        return NestedOperation;
-    }(GroupOperation));
-    var createTester = function (a, compare) {
-        if (a instanceof Function) {
-            return a;
-        }
-        if (a instanceof RegExp) {
-            return function (b) {
-                var result = typeof b === "string" && a.test(b);
-                a.lastIndex = 0;
-                return result;
-            };
-        }
-        var comparableA = comparable(a);
-        return function (b) { return compare(comparableA, comparable(b)); };
-    };
-    var EqualsOperation = /** @class */ (function (_super) {
-        __extends(EqualsOperation, _super);
-        function EqualsOperation() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        EqualsOperation.prototype.init = function () {
-            this._test = createTester(this.params, this.options.compare);
-        };
-        EqualsOperation.prototype.next = function (item, key, parent) {
-            if (!Array.isArray(parent) || parent.hasOwnProperty(key)) {
-                if (this._test(item, key, parent)) {
-                    this.done = true;
-                    this.keep = true;
-                }
-            }
-        };
-        return EqualsOperation;
-    }(BaseOperation));
-    var createEqualsOperation = function (params, owneryQuery, options) { return new EqualsOperation(params, owneryQuery, options); };
-    var numericalOperationCreator = function (createNumericalOperation) {
-        return function (params, owneryQuery, options, name) {
-            return createNumericalOperation(params, owneryQuery, options, name);
-        };
-    };
-    var numericalOperation = function (createTester) {
-        return numericalOperationCreator(function (params, owneryQuery, options, name) {
-            var typeofParams = typeof comparable(params);
-            var test = createTester(params);
-            return new EqualsOperation(function (b) {
-                var actualValue = coercePotentiallyNull(b);
-                return (typeof comparable(actualValue) === typeofParams && test(actualValue));
-            }, owneryQuery, options, name);
-        });
-    };
-    var createNamedOperation = function (name, params, parentQuery, options) {
-        var operationCreator = options.operations[name];
-        if (!operationCreator) {
-            throwUnsupportedOperation(name);
-        }
-        return operationCreator(params, parentQuery, options, name);
-    };
-    var throwUnsupportedOperation = function (name) {
-        throw new Error("Unsupported operation: ".concat(name));
-    };
-    var containsOperation = function (query, options) {
-        for (var key in query) {
-            if (options.operations.hasOwnProperty(key) || key.charAt(0) === "$")
-                return true;
-        }
-        return false;
-    };
-    var createNestedOperation = function (keyPath, nestedQuery, parentKey, owneryQuery, options) {
-        if (containsOperation(nestedQuery, options)) {
-            var _a = createQueryOperations(nestedQuery, parentKey, 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 new NestedOperation(keyPath, nestedQuery, owneryQuery, options, [
-            new EqualsOperation(nestedQuery, owneryQuery, options),
-        ]);
-    };
-    var createQueryOperation = function (query, owneryQuery, _a) {
-        if (owneryQuery === void 0) { owneryQuery = null; }
-        var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
-        var options = {
-            compare: compare || equals,
-            operations: Object.assign({}, operations || {}),
-        };
-        var _c = createQueryOperations(query, null, options), selfOperations = _c[0], nestedOperations = _c[1];
-        var ops = [];
-        if (selfOperations.length) {
-            ops.push(new NestedOperation([], query, owneryQuery, options, selfOperations));
-        }
-        ops.push.apply(ops, nestedOperations);
-        if (ops.length === 1) {
-            return ops[0];
-        }
-        return new QueryOperation(query, owneryQuery, options, ops);
-    };
-    var createQueryOperations = function (query, parentKey, options) {
-        var selfOperations = [];
-        var nestedOperations = [];
-        if (!isVanillaObject(query)) {
-            selfOperations.push(new EqualsOperation(query, query, options));
-            return [selfOperations, nestedOperations];
-        }
-        for (var key in query) {
-            if (options.operations.hasOwnProperty(key)) {
-                var op = createNamedOperation(key, query[key], query, options);
-                if (op) {
-                    if (!op.propop && parentKey && !options.operations[parentKey]) {
-                        throw new Error("Malformed query. ".concat(key, " cannot be matched against property."));
-                    }
-                }
-                // probably just a flag for another operation (like $options)
-                if (op != null) {
-                    selfOperations.push(op);
-                }
-            }
-            else if (key.charAt(0) === "$") {
-                throwUnsupportedOperation(key);
-            }
-            else {
-                nestedOperations.push(createNestedOperation(key.split("."), query[key], key, query, options));
-            }
-        }
-        return [selfOperations, nestedOperations];
-    };
-    var createOperationTester = function (operation) {
-        return function (item, key, owner) {
-            operation.reset();
-            operation.next(item, key, owner);
-            return operation.keep;
-        };
-    };
-    var createQueryTester = function (query, options) {
-        if (options === void 0) { options = {}; }
-        return createOperationTester(createQueryOperation(query, null, options));
-    };
-
-    var $Ne = /** @class */ (function (_super) {
-        __extends($Ne, _super);
-        function $Ne() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $Ne.prototype.init = function () {
-            this._test = createTester(this.params, this.options.compare);
-        };
-        $Ne.prototype.reset = function () {
-            _super.prototype.reset.call(this);
-            this.keep = true;
-        };
-        $Ne.prototype.next = function (item) {
-            if (this._test(item)) {
-                this.done = true;
-                this.keep = false;
-            }
-        };
-        return $Ne;
-    }(BaseOperation));
-    // https://docs.mongodb.com/manual/reference/operator/query/elemMatch/
-    var $ElemMatch = /** @class */ (function (_super) {
-        __extends($ElemMatch, _super);
-        function $ElemMatch() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $ElemMatch.prototype.init = function () {
-            if (!this.params || typeof this.params !== "object") {
-                throw new Error("Malformed query. $elemMatch must by an object.");
-            }
-            this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
-        };
-        $ElemMatch.prototype.reset = function () {
-            _super.prototype.reset.call(this);
-            this._queryOperation.reset();
-        };
-        $ElemMatch.prototype.next = function (item) {
-            if (isArray(item)) {
-                for (var i = 0, length_1 = item.length; i < length_1; i++) {
-                    // reset query operation since item being tested needs to pass _all_ query
-                    // operations for it to be a success
-                    this._queryOperation.reset();
-                    var child = item[i];
-                    this._queryOperation.next(child, i, item, false);
-                    this.keep = this.keep || this._queryOperation.keep;
-                }
-                this.done = true;
-            }
-            else {
-                this.done = false;
-                this.keep = false;
-            }
-        };
-        return $ElemMatch;
-    }(BaseOperation));
-    var $Not = /** @class */ (function (_super) {
-        __extends($Not, _super);
-        function $Not() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $Not.prototype.init = function () {
-            this._queryOperation = createQueryOperation(this.params, this.owneryQuery, this.options);
-        };
-        $Not.prototype.reset = function () {
-            _super.prototype.reset.call(this);
-            this._queryOperation.reset();
-        };
-        $Not.prototype.next = function (item, key, owner, root) {
-            this._queryOperation.next(item, key, owner, root);
-            this.done = this._queryOperation.done;
-            this.keep = !this._queryOperation.keep;
-        };
-        return $Not;
-    }(BaseOperation));
-    var $Size = /** @class */ (function (_super) {
-        __extends($Size, _super);
-        function $Size() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $Size.prototype.init = function () { };
-        $Size.prototype.next = function (item) {
-            if (isArray(item) && item.length === this.params) {
-                this.done = true;
-                this.keep = true;
-            }
-            // if (parent && parent.length === this.params) {
-            //   this.done = true;
-            //   this.keep = true;
-            // }
-        };
-        return $Size;
-    }(BaseOperation));
-    var assertGroupNotEmpty = function (values) {
-        if (values.length === 0) {
-            throw new Error("$and/$or/$nor must be a nonempty array");
-        }
-    };
-    var $Or = /** @class */ (function (_super) {
-        __extends($Or, _super);
-        function $Or() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = false;
-            return _this;
-        }
-        $Or.prototype.init = function () {
-            var _this = this;
-            assertGroupNotEmpty(this.params);
-            this._ops = this.params.map(function (op) {
-                return createQueryOperation(op, null, _this.options);
-            });
-        };
-        $Or.prototype.reset = function () {
-            this.done = false;
-            this.keep = false;
-            for (var i = 0, length_2 = this._ops.length; i < length_2; i++) {
-                this._ops[i].reset();
-            }
-        };
-        $Or.prototype.next = function (item, key, owner) {
-            var done = false;
-            var success = false;
-            for (var i = 0, length_3 = this._ops.length; i < length_3; i++) {
-                var op = this._ops[i];
-                op.next(item, key, owner);
-                if (op.keep) {
-                    done = true;
-                    success = op.keep;
-                    break;
-                }
-            }
-            this.keep = success;
-            this.done = done;
-        };
-        return $Or;
-    }(BaseOperation));
-    var $Nor = /** @class */ (function (_super) {
-        __extends($Nor, _super);
-        function $Nor() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = false;
-            return _this;
-        }
-        $Nor.prototype.next = function (item, key, owner) {
-            _super.prototype.next.call(this, item, key, owner);
-            this.keep = !this.keep;
-        };
-        return $Nor;
-    }($Or));
-    var $In = /** @class */ (function (_super) {
-        __extends($In, _super);
-        function $In() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $In.prototype.init = function () {
-            var _this = this;
-            var params = Array.isArray(this.params) ? this.params : [this.params];
-            this._testers = params.map(function (value) {
-                if (containsOperation(value, _this.options)) {
-                    throw new Error("cannot nest $ under ".concat(_this.name.toLowerCase()));
-                }
-                return createTester(value, _this.options.compare);
-            });
-        };
-        $In.prototype.next = function (item, key, owner) {
-            var done = false;
-            var success = false;
-            for (var i = 0, length_4 = this._testers.length; i < length_4; i++) {
-                var test = this._testers[i];
-                if (test(item)) {
-                    done = true;
-                    success = true;
-                    break;
-                }
-            }
-            this.keep = success;
-            this.done = done;
-        };
-        return $In;
-    }(BaseOperation));
-    var $Nin = /** @class */ (function (_super) {
-        __extends($Nin, _super);
-        function $Nin(params, ownerQuery, options, name) {
-            var _this = _super.call(this, params, ownerQuery, options, name) || this;
-            _this.propop = true;
-            _this._in = new $In(params, ownerQuery, options, name);
-            return _this;
-        }
-        $Nin.prototype.next = function (item, key, owner, root) {
-            this._in.next(item, key, owner);
-            if (isArray(owner) && !root) {
-                if (this._in.keep) {
-                    this.keep = false;
-                    this.done = true;
-                }
-                else if (key == owner.length - 1) {
-                    this.keep = true;
-                    this.done = true;
-                }
-            }
-            else {
-                this.keep = !this._in.keep;
-                this.done = true;
-            }
-        };
-        $Nin.prototype.reset = function () {
-            _super.prototype.reset.call(this);
-            this._in.reset();
-        };
-        return $Nin;
-    }(BaseOperation));
-    var $Exists = /** @class */ (function (_super) {
-        __extends($Exists, _super);
-        function $Exists() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $Exists.prototype.next = function (item, key, owner, root, leaf) {
-            if (!leaf) {
-                this.done = true;
-                this.keep = !this.params;
-            }
-            else if (owner.hasOwnProperty(key) === this.params) {
-                this.done = true;
-                this.keep = true;
-            }
-        };
-        return $Exists;
-    }(BaseOperation));
-    var $And = /** @class */ (function (_super) {
-        __extends($And, _super);
-        function $And(params, owneryQuery, options, name) {
-            var _this = _super.call(this, params, owneryQuery, options, params.map(function (query) { return createQueryOperation(query, owneryQuery, options); }), name) || this;
-            _this.propop = false;
-            assertGroupNotEmpty(params);
-            return _this;
-        }
-        $And.prototype.next = function (item, key, owner, root) {
-            this.childrenNext(item, key, owner, root);
-        };
-        return $And;
-    }(NamedGroupOperation));
-    var $All = /** @class */ (function (_super) {
-        __extends($All, _super);
-        function $All(params, owneryQuery, options, name) {
-            var _this = _super.call(this, params, owneryQuery, options, params.map(function (query) { return createQueryOperation(query, owneryQuery, options); }), name) || this;
-            _this.propop = true;
-            return _this;
-        }
-        $All.prototype.next = function (item, key, owner, root) {
-            this.childrenNext(item, key, owner, root);
-        };
-        return $All;
-    }(NamedGroupOperation));
-    var $eq = function (params, owneryQuery, options) {
-        return new EqualsOperation(params, owneryQuery, options);
-    };
-    var $ne = function (params, owneryQuery, options, name) { return new $Ne(params, owneryQuery, options, name); };
-    var $or = function (params, owneryQuery, options, name) { return new $Or(params, owneryQuery, options, name); };
-    var $nor = function (params, owneryQuery, options, name) { return new $Nor(params, owneryQuery, options, name); };
-    var $elemMatch = function (params, owneryQuery, options, name) { return new $ElemMatch(params, owneryQuery, options, name); };
-    var $nin = function (params, owneryQuery, options, name) { return new $Nin(params, owneryQuery, options, name); };
-    var $in = function (params, owneryQuery, options, name) {
-        return new $In(params, owneryQuery, options, name);
-    };
-    var $lt = numericalOperation(function (params) { return function (b) {
-        return b != null && b < params;
-    }; });
-    var $lte = numericalOperation(function (params) { return function (b) {
-        return b === params || b <= params;
-    }; });
-    var $gt = numericalOperation(function (params) { return function (b) {
-        return b != null && b > params;
-    }; });
-    var $gte = numericalOperation(function (params) { return function (b) {
-        return b === params || b >= params;
-    }; });
-    var $mod = function (_a, owneryQuery, options) {
-        var mod = _a[0], equalsValue = _a[1];
-        return new EqualsOperation(function (b) { return comparable(b) % mod === equalsValue; }, owneryQuery, options);
-    };
-    var $exists = function (params, owneryQuery, options, name) { return new $Exists(params, owneryQuery, options, name); };
-    var $regex = function (pattern, owneryQuery, options) {
-        return new EqualsOperation(new RegExp(pattern, owneryQuery.$options), owneryQuery, options);
-    };
-    var $not = function (params, owneryQuery, options, name) { return new $Not(params, owneryQuery, options, name); };
-    var typeAliases = {
-        number: function (v) { return typeof v === "number"; },
-        string: function (v) { return typeof v === "string"; },
-        bool: function (v) { return typeof v === "boolean"; },
-        array: function (v) { return Array.isArray(v); },
-        null: function (v) { return v === null; },
-        timestamp: function (v) { return v instanceof Date; },
-    };
-    var $type = function (clazz, owneryQuery, options) {
-        return new EqualsOperation(function (b) {
-            if (typeof clazz === "string") {
-                if (!typeAliases[clazz]) {
-                    throw new Error("Type alias does not exist");
-                }
-                return typeAliases[clazz](b);
-            }
-            return b != null ? b instanceof clazz || b.constructor === clazz : false;
-        }, owneryQuery, options);
-    };
-    var $and = function (params, ownerQuery, options, name) { return new $And(params, ownerQuery, options, name); };
-    var $all = function (params, ownerQuery, options, name) { return new $All(params, ownerQuery, options, name); };
-    var $size = function (params, ownerQuery, options) { return new $Size(params, ownerQuery, options, "$size"); };
-    var $options = function () { return null; };
-    var $where = function (params, ownerQuery, options) {
-        var test;
-        if (isFunction(params)) {
-            test = params;
-        }
-        else {
-            throw new Error("In CSP mode, sift does not support strings in \"$where\" condition");
-        }
-        return new EqualsOperation(function (b) { return test.bind(b)(b); }, ownerQuery, options);
-    };
-
-    var defaultOperations = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        $Size: $Size,
-        $all: $all,
-        $and: $and,
-        $elemMatch: $elemMatch,
-        $eq: $eq,
-        $exists: $exists,
-        $gt: $gt,
-        $gte: $gte,
-        $in: $in,
-        $lt: $lt,
-        $lte: $lte,
-        $mod: $mod,
-        $ne: $ne,
-        $nin: $nin,
-        $nor: $nor,
-        $not: $not,
-        $options: $options,
-        $or: $or,
-        $regex: $regex,
-        $size: $size,
-        $type: $type,
-        $where: $where
-    });
-
-    var createDefaultQueryOperation = function (query, ownerQuery, _a) {
-        var _b = _a === void 0 ? {} : _a, compare = _b.compare, operations = _b.operations;
-        return createQueryOperation(query, ownerQuery, {
-            compare: compare,
-            operations: Object.assign({}, defaultOperations, operations || {}),
-        });
-    };
-    var createDefaultQueryTester = function (query, options) {
-        if (options === void 0) { options = {}; }
-        var op = createDefaultQueryOperation(query, null, options);
-        return createOperationTester(op);
-    };
-
-    exports.$Size = $Size;
-    exports.$all = $all;
-    exports.$and = $and;
-    exports.$elemMatch = $elemMatch;
-    exports.$eq = $eq;
-    exports.$exists = $exists;
-    exports.$gt = $gt;
-    exports.$gte = $gte;
-    exports.$in = $in;
-    exports.$lt = $lt;
-    exports.$lte = $lte;
-    exports.$mod = $mod;
-    exports.$ne = $ne;
-    exports.$nin = $nin;
-    exports.$nor = $nor;
-    exports.$not = $not;
-    exports.$options = $options;
-    exports.$or = $or;
-    exports.$regex = $regex;
-    exports.$size = $size;
-    exports.$type = $type;
-    exports.$where = $where;
-    exports.EqualsOperation = EqualsOperation;
-    exports.createDefaultQueryOperation = createDefaultQueryOperation;
-    exports.createEqualsOperation = createEqualsOperation;
-    exports.createOperationTester = createOperationTester;
-    exports.createQueryOperation = createQueryOperation;
-    exports.createQueryTester = createQueryTester;
-    exports.default = createDefaultQueryTester;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=sift.csp.min.js.map