@cloudbase/database 1.4.3 → 1.5.1

package/dist/esm/command.js

@@ -3,92 +3,112 @@ import { LogicCommand, LOGIC_COMMANDS_LITERAL } from './commands/logic';
 import { UpdateCommand, UPDATE_COMMANDS_LITERAL } from './commands/update';
 import { isArray, isObject, isString } from './utils/type';
 import Aggregation from './aggregate';
-export const Command = {
-    eq(val) {
+export var Command = {
+    eq: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.EQ, [val]);
     },
-    neq(val) {
+    neq: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.NEQ, [val]);
     },
-    lt(val) {
+    lt: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.LT, [val]);
     },
-    lte(val) {
+    lte: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.LTE, [val]);
     },
-    gt(val) {
+    gt: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.GT, [val]);
     },
-    gte(val) {
+    gte: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.GTE, [val]);
     },
-    in(val) {
+    in: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.IN, val);
     },
-    nin(val) {
+    nin: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.NIN, val);
     },
-    all(val) {
+    all: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.ALL, val);
     },
-    elemMatch(val) {
+    elemMatch: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.ELEM_MATCH, [val]);
     },
-    exists(val) {
+    exists: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.EXISTS, [val]);
     },
-    size(val) {
+    size: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.SIZE, [val]);
     },
-    mod() {
+    mod: function () {
         if (arguments.length == 1)
             return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [arguments[0]]);
         if (arguments.length == 2)
             return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [[arguments[0], arguments[1]]]);
         return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, arguments);
     },
-    geoNear(val) {
+    geoNear: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_NEAR, [val]);
     },
-    geoWithin(val) {
+    geoWithin: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_WITHIN, [val]);
     },
-    geoIntersects(val) {
+    geoIntersects: function (val) {
         return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_INTERSECTS, [val]);
     },
-    and(...__expressions__) {
-        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    and: function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.AND, expressions);
     },
-    nor(...__expressions__) {
-        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    nor: function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.NOR, expressions);
     },
-    or(...__expressions__) {
-        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    or: function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.OR, expressions);
     },
-    not(...__expressions__) {
-        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    not: function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.NOT, expressions);
     },
-    set(val) {
+    set: function (val) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.SET, [val]);
     },
-    remove() {
+    remove: function () {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.REMOVE, []);
     },
-    inc(val) {
+    inc: function (val) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.INC, [val]);
     },
-    mul(val) {
+    mul: function (val) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MUL, [val]);
     },
-    push(...args) {
-        let values;
+    push: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var values;
         if (isObject(args[0]) && args[0].hasOwnProperty('each')) {
             values = {};
-            const options = args[0];
+            var options = args[0];
             if (options.each !== undefined) {
                 values['$each'] = options.each;
             }
@@ -110,48 +130,52 @@ export const Command = {
         }
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PUSH, values);
     },
-    pull(values) {
+    pull: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PULL, values);
     },
-    pullAll(values) {
+    pullAll: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PULL_ALL, values);
     },
-    pop() {
+    pop: function () {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.POP, []);
     },
-    shift() {
+    shift: function () {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.SHIFT, []);
     },
-    unshift(...__values__) {
-        const values = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    unshift: function () {
+        var __values__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __values__[_i] = arguments[_i];
+        }
+        var values = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.UNSHIFT, values);
     },
-    addToSet(values) {
+    addToSet: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.ADD_TO_SET, values);
     },
-    rename(values) {
+    rename: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.RENAME, [values]);
     },
-    bit(values) {
+    bit: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.BIT, [values]);
     },
-    max(values) {
+    max: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MAX, [values]);
     },
-    min(values) {
+    min: function (values) {
         return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MIN, [values]);
     },
-    expr(values) {
+    expr: function (values) {
         return {
             $expr: values
         };
     },
-    jsonSchema(schema) {
+    jsonSchema: function (schema) {
         return {
             $jsonSchema: schema
         };
     },
-    text(values) {
+    text: function (values) {
         if (isString(values)) {
             return {
                 $search: values.search
@@ -167,115 +191,119 @@ export const Command = {
         }
     },
     aggregate: {
-        pipeline() {
+        pipeline: function () {
             return new Aggregation();
         },
-        abs: param => new AggregationOperator('abs', param),
-        add: param => new AggregationOperator('add', param),
-        ceil: param => new AggregationOperator('ceil', param),
-        divide: param => new AggregationOperator('divide', param),
-        exp: param => new AggregationOperator('exp', param),
-        floor: param => new AggregationOperator('floor', param),
-        ln: param => new AggregationOperator('ln', param),
-        log: param => new AggregationOperator('log', param),
-        log10: param => new AggregationOperator('log10', param),
-        mod: param => new AggregationOperator('mod', param),
-        multiply: param => new AggregationOperator('multiply', param),
-        pow: param => new AggregationOperator('pow', param),
-        sqrt: param => new AggregationOperator('sqrt', param),
-        subtract: param => new AggregationOperator('subtract', param),
-        trunc: param => new AggregationOperator('trunc', param),
-        arrayElemAt: param => new AggregationOperator('arrayElemAt', param),
-        arrayToObject: param => new AggregationOperator('arrayToObject', param),
-        concatArrays: param => new AggregationOperator('concatArrays', param),
-        filter: param => new AggregationOperator('filter', param),
-        in: param => new AggregationOperator('in', param),
-        indexOfArray: param => new AggregationOperator('indexOfArray', param),
-        isArray: param => new AggregationOperator('isArray', param),
-        map: param => new AggregationOperator('map', param),
-        range: param => new AggregationOperator('range', param),
-        reduce: param => new AggregationOperator('reduce', param),
-        reverseArray: param => new AggregationOperator('reverseArray', param),
-        size: param => new AggregationOperator('size', param),
-        slice: param => new AggregationOperator('slice', param),
-        zip: param => new AggregationOperator('zip', param),
-        and: param => new AggregationOperator('and', param),
-        not: param => new AggregationOperator('not', param),
-        or: param => new AggregationOperator('or', param),
-        cmp: param => new AggregationOperator('cmp', param),
-        eq: param => new AggregationOperator('eq', param),
-        gt: param => new AggregationOperator('gt', param),
-        gte: param => new AggregationOperator('gte', param),
-        lt: param => new AggregationOperator('lt', param),
-        lte: param => new AggregationOperator('lte', param),
-        neq: param => new AggregationOperator('ne', param),
-        cond: param => new AggregationOperator('cond', param),
-        ifNull: param => new AggregationOperator('ifNull', param),
-        switch: param => new AggregationOperator('switch', param),
-        dateFromParts: param => new AggregationOperator('dateFromParts', param),
-        dateFromString: param => new AggregationOperator('dateFromString', param),
-        dayOfMonth: param => new AggregationOperator('dayOfMonth', param),
-        dayOfWeek: param => new AggregationOperator('dayOfWeek', param),
-        dayOfYear: param => new AggregationOperator('dayOfYear', param),
-        isoDayOfWeek: param => new AggregationOperator('isoDayOfWeek', param),
-        isoWeek: param => new AggregationOperator('isoWeek', param),
-        isoWeekYear: param => new AggregationOperator('isoWeekYear', param),
-        millisecond: param => new AggregationOperator('millisecond', param),
-        minute: param => new AggregationOperator('minute', param),
-        month: param => new AggregationOperator('month', param),
-        second: param => new AggregationOperator('second', param),
-        hour: param => new AggregationOperator('hour', param),
-        week: param => new AggregationOperator('week', param),
-        year: param => new AggregationOperator('year', param),
-        literal: param => new AggregationOperator('literal', param),
-        mergeObjects: param => new AggregationOperator('mergeObjects', param),
-        objectToArray: param => new AggregationOperator('objectToArray', param),
-        allElementsTrue: param => new AggregationOperator('allElementsTrue', param),
-        anyElementTrue: param => new AggregationOperator('anyElementTrue', param),
-        setDifference: param => new AggregationOperator('setDifference', param),
-        setEquals: param => new AggregationOperator('setEquals', param),
-        setIntersection: param => new AggregationOperator('setIntersection', param),
-        setIsSubset: param => new AggregationOperator('setIsSubset', param),
-        setUnion: param => new AggregationOperator('setUnion', param),
-        concat: param => new AggregationOperator('concat', param),
-        dateToString: param => new AggregationOperator('dateToString', param),
-        indexOfBytes: param => new AggregationOperator('indexOfBytes', param),
-        indexOfCP: param => new AggregationOperator('indexOfCP', param),
-        split: param => new AggregationOperator('split', param),
-        strLenBytes: param => new AggregationOperator('strLenBytes', param),
-        strLenCP: param => new AggregationOperator('strLenCP', param),
-        strcasecmp: param => new AggregationOperator('strcasecmp', param),
-        substr: param => new AggregationOperator('substr', param),
-        substrBytes: param => new AggregationOperator('substrBytes', param),
-        substrCP: param => new AggregationOperator('substrCP', param),
-        toLower: param => new AggregationOperator('toLower', param),
-        toUpper: param => new AggregationOperator('toUpper', param),
-        meta: param => new AggregationOperator('meta', param),
-        addToSet: param => new AggregationOperator('addToSet', param),
-        avg: param => new AggregationOperator('avg', param),
-        first: param => new AggregationOperator('first', param),
-        last: param => new AggregationOperator('last', param),
-        max: param => new AggregationOperator('max', param),
-        min: param => new AggregationOperator('min', param),
-        push: param => new AggregationOperator('push', param),
-        stdDevPop: param => new AggregationOperator('stdDevPop', param),
-        stdDevSamp: param => new AggregationOperator('stdDevSamp', param),
-        sum: param => new AggregationOperator('sum', param),
-        let: param => new AggregationOperator('let', param)
+        abs: function (param) { return new AggregationOperator('abs', param); },
+        add: function (param) { return new AggregationOperator('add', param); },
+        ceil: function (param) { return new AggregationOperator('ceil', param); },
+        divide: function (param) { return new AggregationOperator('divide', param); },
+        exp: function (param) { return new AggregationOperator('exp', param); },
+        floor: function (param) { return new AggregationOperator('floor', param); },
+        ln: function (param) { return new AggregationOperator('ln', param); },
+        log: function (param) { return new AggregationOperator('log', param); },
+        log10: function (param) { return new AggregationOperator('log10', param); },
+        mod: function (param) { return new AggregationOperator('mod', param); },
+        multiply: function (param) { return new AggregationOperator('multiply', param); },
+        pow: function (param) { return new AggregationOperator('pow', param); },
+        sqrt: function (param) { return new AggregationOperator('sqrt', param); },
+        subtract: function (param) { return new AggregationOperator('subtract', param); },
+        trunc: function (param) { return new AggregationOperator('trunc', param); },
+        arrayElemAt: function (param) { return new AggregationOperator('arrayElemAt', param); },
+        arrayToObject: function (param) { return new AggregationOperator('arrayToObject', param); },
+        concatArrays: function (param) { return new AggregationOperator('concatArrays', param); },
+        filter: function (param) { return new AggregationOperator('filter', param); },
+        in: function (param) { return new AggregationOperator('in', param); },
+        indexOfArray: function (param) { return new AggregationOperator('indexOfArray', param); },
+        isArray: function (param) { return new AggregationOperator('isArray', param); },
+        map: function (param) { return new AggregationOperator('map', param); },
+        range: function (param) { return new AggregationOperator('range', param); },
+        reduce: function (param) { return new AggregationOperator('reduce', param); },
+        reverseArray: function (param) { return new AggregationOperator('reverseArray', param); },
+        size: function (param) { return new AggregationOperator('size', param); },
+        slice: function (param) { return new AggregationOperator('slice', param); },
+        zip: function (param) { return new AggregationOperator('zip', param); },
+        and: function (param) { return new AggregationOperator('and', param); },
+        not: function (param) { return new AggregationOperator('not', param); },
+        or: function (param) { return new AggregationOperator('or', param); },
+        cmp: function (param) { return new AggregationOperator('cmp', param); },
+        eq: function (param) { return new AggregationOperator('eq', param); },
+        gt: function (param) { return new AggregationOperator('gt', param); },
+        gte: function (param) { return new AggregationOperator('gte', param); },
+        lt: function (param) { return new AggregationOperator('lt', param); },
+        lte: function (param) { return new AggregationOperator('lte', param); },
+        neq: function (param) { return new AggregationOperator('ne', param); },
+        cond: function (param) { return new AggregationOperator('cond', param); },
+        ifNull: function (param) { return new AggregationOperator('ifNull', param); },
+        switch: function (param) { return new AggregationOperator('switch', param); },
+        dateFromParts: function (param) { return new AggregationOperator('dateFromParts', param); },
+        dateFromString: function (param) { return new AggregationOperator('dateFromString', param); },
+        dayOfMonth: function (param) { return new AggregationOperator('dayOfMonth', param); },
+        dayOfWeek: function (param) { return new AggregationOperator('dayOfWeek', param); },
+        dayOfYear: function (param) { return new AggregationOperator('dayOfYear', param); },
+        isoDayOfWeek: function (param) { return new AggregationOperator('isoDayOfWeek', param); },
+        isoWeek: function (param) { return new AggregationOperator('isoWeek', param); },
+        isoWeekYear: function (param) { return new AggregationOperator('isoWeekYear', param); },
+        millisecond: function (param) { return new AggregationOperator('millisecond', param); },
+        minute: function (param) { return new AggregationOperator('minute', param); },
+        month: function (param) { return new AggregationOperator('month', param); },
+        second: function (param) { return new AggregationOperator('second', param); },
+        hour: function (param) { return new AggregationOperator('hour', param); },
+        week: function (param) { return new AggregationOperator('week', param); },
+        year: function (param) { return new AggregationOperator('year', param); },
+        literal: function (param) { return new AggregationOperator('literal', param); },
+        mergeObjects: function (param) { return new AggregationOperator('mergeObjects', param); },
+        objectToArray: function (param) { return new AggregationOperator('objectToArray', param); },
+        allElementsTrue: function (param) { return new AggregationOperator('allElementsTrue', param); },
+        anyElementTrue: function (param) { return new AggregationOperator('anyElementTrue', param); },
+        setDifference: function (param) { return new AggregationOperator('setDifference', param); },
+        setEquals: function (param) { return new AggregationOperator('setEquals', param); },
+        setIntersection: function (param) { return new AggregationOperator('setIntersection', param); },
+        setIsSubset: function (param) { return new AggregationOperator('setIsSubset', param); },
+        setUnion: function (param) { return new AggregationOperator('setUnion', param); },
+        concat: function (param) { return new AggregationOperator('concat', param); },
+        dateToString: function (param) { return new AggregationOperator('dateToString', param); },
+        indexOfBytes: function (param) { return new AggregationOperator('indexOfBytes', param); },
+        indexOfCP: function (param) { return new AggregationOperator('indexOfCP', param); },
+        split: function (param) { return new AggregationOperator('split', param); },
+        strLenBytes: function (param) { return new AggregationOperator('strLenBytes', param); },
+        strLenCP: function (param) { return new AggregationOperator('strLenCP', param); },
+        strcasecmp: function (param) { return new AggregationOperator('strcasecmp', param); },
+        substr: function (param) { return new AggregationOperator('substr', param); },
+        substrBytes: function (param) { return new AggregationOperator('substrBytes', param); },
+        substrCP: function (param) { return new AggregationOperator('substrCP', param); },
+        toLower: function (param) { return new AggregationOperator('toLower', param); },
+        toUpper: function (param) { return new AggregationOperator('toUpper', param); },
+        meta: function (param) { return new AggregationOperator('meta', param); },
+        addToSet: function (param) { return new AggregationOperator('addToSet', param); },
+        avg: function (param) { return new AggregationOperator('avg', param); },
+        first: function (param) { return new AggregationOperator('first', param); },
+        last: function (param) { return new AggregationOperator('last', param); },
+        max: function (param) { return new AggregationOperator('max', param); },
+        min: function (param) { return new AggregationOperator('min', param); },
+        push: function (param) { return new AggregationOperator('push', param); },
+        stdDevPop: function (param) { return new AggregationOperator('stdDevPop', param); },
+        stdDevSamp: function (param) { return new AggregationOperator('stdDevSamp', param); },
+        sum: function (param) { return new AggregationOperator('sum', param); },
+        let: function (param) { return new AggregationOperator('let', param); }
     },
     project: {
-        slice: param => new ProjectionOperator('slice', param),
-        elemMatch: param => new ProjectionOperator('elemMatch', param)
+        slice: function (param) { return new ProjectionOperator('slice', param); },
+        elemMatch: function (param) { return new ProjectionOperator('elemMatch', param); }
     }
 };
-export class AggregationOperator {
-    constructor(name, param) {
+var AggregationOperator = (function () {
+    function AggregationOperator(name, param) {
         this['$' + name] = param;
     }
-}
-export class ProjectionOperator {
-    constructor(name, param) {
+    return AggregationOperator;
+}());
+export { AggregationOperator };
+var ProjectionOperator = (function () {
+    function ProjectionOperator(name, param) {
         this['$' + name] = param;
     }
-}
+    return ProjectionOperator;
+}());
+export { ProjectionOperator };
 export default Command;

package/dist/esm/commands/logic.js

@@ -1,9 +1,9 @@
 import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_LOGIC_COMMAND } from '../helper/symbol';
 import { isQueryCommand } from './query';
-export const AND = 'and';
-export const OR = 'or';
-export const NOT = 'not';
-export const NOR = 'nor';
+export var AND = 'and';
+export var OR = 'or';
+export var NOT = 'not';
+export var NOR = 'nor';
 export var LOGIC_COMMANDS_LITERAL;
 (function (LOGIC_COMMANDS_LITERAL) {
     LOGIC_COMMANDS_LITERAL["AND"] = "and";
@@ -11,8 +11,8 @@ export var LOGIC_COMMANDS_LITERAL;
     LOGIC_COMMANDS_LITERAL["NOT"] = "not";
     LOGIC_COMMANDS_LITERAL["NOR"] = "nor";
 })(LOGIC_COMMANDS_LITERAL || (LOGIC_COMMANDS_LITERAL = {}));
-export class LogicCommand {
-    constructor(operator, operands, fieldName) {
+var LogicCommand = (function () {
+    function LogicCommand(operator, operands, fieldName) {
         this._internalType = SYMBOL_LOGIC_COMMAND;
         Object.defineProperties(this, {
             _internalType: {
@@ -27,23 +27,23 @@ export class LogicCommand {
             if (Array.isArray(operands)) {
                 operands = operands.slice();
                 this.operands = operands;
-                for (let i = 0, len = operands.length; i < len; i++) {
-                    const query = operands[i];
+                for (var i = 0, len = operands.length; i < len; i++) {
+                    var query = operands[i];
                     if (isLogicCommand(query) || isQueryCommand(query)) {
                         operands[i] = query._setFieldName(this.fieldName);
                     }
                 }
             }
             else {
-                const query = operands;
+                var query = operands;
                 if (isLogicCommand(query) || isQueryCommand(query)) {
                     operands = query._setFieldName(this.fieldName);
                 }
             }
         }
     }
-    _setFieldName(fieldName) {
-        const operands = this.operands.map(operand => {
+    LogicCommand.prototype._setFieldName = function (fieldName) {
+        var operands = this.operands.map(function (operand) {
             if (operand instanceof LogicCommand) {
                 return operand._setFieldName(fieldName);
             }
@@ -51,20 +51,30 @@ export class LogicCommand {
                 return operand;
             }
         });
-        const command = new LogicCommand(this.operator, operands, fieldName);
+        var command = new LogicCommand(this.operator, operands, fieldName);
         return command;
-    }
-    and(...__expressions__) {
-        const expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    };
+    LogicCommand.prototype.and = function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         expressions.unshift(this);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.AND, expressions, this.fieldName);
-    }
-    or(...__expressions__) {
-        const expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+    };
+    LogicCommand.prototype.or = function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
         expressions.unshift(this);
         return new LogicCommand(LOGIC_COMMANDS_LITERAL.OR, expressions, this.fieldName);
-    }
-}
+    };
+    return LogicCommand;
+}());
+export { LogicCommand };
 export function isLogicCommand(object) {
     return object && (object instanceof LogicCommand) && (object._internalType === SYMBOL_LOGIC_COMMAND);
 }

package/dist/esm/commands/query.d.ts

@@ -37,7 +37,7 @@ export declare class QueryCommand extends LogicCommand {
     operator: QUERY_COMMANDS_LITERAL;
     constructor(operator: QUERY_COMMANDS_LITERAL, operands: any, fieldName?: string | InternalSymbol);
     toJSON(): {
-        ['$ne']: any;
+        $ne: any;
     } | {
         [x: string]: any;
         $ne?: undefined;