@higher.archi/boe 1.0.0

package/dist/core/operators/array/contains.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Array Contains Operators
+ *
+ * Checks if arrays contain elements.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayLength = exports.arrayIsNotEmpty = exports.arrayIsEmpty = exports.inArray = exports.arrayContains = void 0;
+const operator_1 = require("../operator");
+/**
+ * Array contains - checks if array contains an element
+ */
+exports.arrayContains = (0, operator_1.binaryOp)('arrayContains', (arr, element) => arr.includes(element), {
+    leftType: 'array',
+    rightType: 'any',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array contains a specific element',
+    aliases: ['includes', 'has'],
+});
+/**
+ * In - checks if element is in array (reversed args)
+ */
+exports.inArray = (0, operator_1.binaryOp)('in', (element, arr) => arr.includes(element), {
+    leftType: 'any',
+    rightType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an element is in an array',
+    aliases: ['memberOf'],
+});
+/**
+ * Array is empty
+ */
+exports.arrayIsEmpty = (0, operator_1.unaryOp)('arrayIsEmpty', (arr) => arr.length === 0, {
+    paramType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array is empty',
+});
+/**
+ * Array is not empty
+ */
+exports.arrayIsNotEmpty = (0, operator_1.unaryOp)('arrayIsNotEmpty', (arr) => arr.length > 0, {
+    paramType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array is not empty',
+});
+/**
+ * Array length
+ */
+exports.arrayLength = (0, operator_1.unaryOp)('arrayLength', (arr) => arr.length, {
+    paramType: 'array',
+    returns: 'number',
+    category: 'array',
+    description: 'Returns the length of an array',
+    aliases: ['length', 'count', 'size'],
+});
+exports.default = [exports.arrayContains, exports.inArray, exports.arrayIsEmpty, exports.arrayIsNotEmpty, exports.arrayLength];
+//# sourceMappingURL=contains.js.map

package/dist/core/operators/array/contains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contains.js","sourceRoot":"","sources":["../../../../src/core/operators/array/contains.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAgD;AAGhD;;GAEG;AACU,QAAA,aAAa,GAAa,IAAA,mBAAQ,EAC7C,eAAe,EACf,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EACvC;IACE,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,KAAK;IAChB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,gDAAgD;IAC7D,OAAO,EAAE,CAAC,UAAU,EAAE,KAAK,CAAC;CAC7B,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,OAAO,GAAa,IAAA,mBAAQ,EACvC,IAAI,EACJ,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EACvC;IACE,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,qCAAqC;IAClD,OAAO,EAAE,CAAC,UAAU,CAAC;CACtB,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAa,IAAA,kBAAO,EAC3C,cAAc,EACd,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,EACzB;IACE,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,6BAA6B;CAC3C,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,eAAe,GAAa,IAAA,kBAAO,EAC9C,iBAAiB,EACjB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EACvB;IACE,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,iCAAiC;CAC/C,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,WAAW,GAAa,IAAA,kBAAO,EAC1C,aAAa,EACb,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,EACnB;IACE,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,gCAAgC;IAC7C,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC;CACrC,CACF,CAAC;AAEF,kBAAe,CAAC,qBAAa,EAAE,eAAO,EAAE,oBAAY,EAAE,uBAAe,EAAE,mBAAW,CAAC,CAAC"}

package/dist/core/operators/array/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Array Operators
+ *
+ * Exports all array operators for registry registration.
+ */
+export * from './contains';
+/**
+ * All array operators as an array for bulk registration
+ */
+export declare const arrayOperators: import("..").Operator<import("..").OperatorParameter[], import("..").OperatorReturnType>[];
+export default arrayOperators;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/operators/array/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/array/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,cAAc,YAAY,CAAC;AAE3B;;GAEG;AACH,eAAO,MAAM,cAAc,4FAE1B,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/core/operators/array/index.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Array Operators
+ *
+ * Exports all array operators for registry registration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOperators = void 0;
+const contains_1 = __importDefault(require("./contains"));
+__exportStar(require("./contains"), exports);
+/**
+ * All array operators as an array for bulk registration
+ */
+exports.arrayOperators = [
+    ...contains_1.default,
+];
+exports.default = exports.arrayOperators;
+//# sourceMappingURL=index.js.map

package/dist/core/operators/array/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/operators/array/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;;;;;;;;;;;;;;;AAEH,0DAAqC;AAErC,6CAA2B;AAE3B;;GAEG;AACU,QAAA,cAAc,GAAG;IAC5B,GAAG,kBAAW;CACf,CAAC;AAEF,kBAAe,sBAAc,CAAC"}

package/dist/core/operators/comparison/approximately-equals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Approximately Equals Operator
+ *
+ * Checks if two numbers are approximately equal within a tolerance.
+ */
+import { Operator } from '../types';
+/**
+ * Approximately equals with explicit tolerance (ternary)
+ */
+export declare const approximatelyEqualsWithTolerance: Operator;
+/**
+ * Approximately equals with default tolerance (binary)
+ */
+export declare const approximatelyEquals: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=approximately-equals.d.ts.map

package/dist/core/operators/comparison/approximately-equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approximately-equals.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/approximately-equals.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAOpC;;GAEG;AACH,eAAO,MAAM,gCAAgC,EAAE,QAS9C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAWjC,CAAC;;AAEF,wBAAuE"}

package/dist/core/operators/comparison/approximately-equals.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Approximately Equals Operator
+ *
+ * Checks if two numbers are approximately equal within a tolerance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approximatelyEquals = exports.approximatelyEqualsWithTolerance = void 0;
+const operator_1 = require("../operator");
+/**
+ * Default tolerance for approximate equality
+ */
+const DEFAULT_TOLERANCE = 0.0001;
+/**
+ * Approximately equals with explicit tolerance (ternary)
+ */
+exports.approximatelyEqualsWithTolerance = (0, operator_1.ternaryOp)('approximatelyEqualsWithTolerance', (a, b, tolerance) => Math.abs(a - b) <= tolerance, {
+    params: ['number', 'number', 'number'],
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two numbers are approximately equal within a specified tolerance',
+});
+/**
+ * Approximately equals with default tolerance (binary)
+ */
+exports.approximatelyEquals = (0, operator_1.binaryOp)('approximatelyEquals', (a, b) => Math.abs(a - b) <= DEFAULT_TOLERANCE, {
+    leftType: 'number',
+    rightType: 'number',
+    returns: 'boolean',
+    category: 'comparison',
+    description: `Checks if two numbers are approximately equal (tolerance: ${DEFAULT_TOLERANCE})`,
+    aliases: ['approxEq', '~='],
+});
+exports.default = [exports.approximatelyEquals, exports.approximatelyEqualsWithTolerance];
+//# sourceMappingURL=approximately-equals.js.map

package/dist/core/operators/comparison/approximately-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approximately-equals.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/approximately-equals.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAkD;AAGlD;;GAEG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEjC;;GAEG;AACU,QAAA,gCAAgC,GAAa,IAAA,oBAAS,EACjE,kCAAkC,EAClC,CAAC,CAAS,EAAE,CAAS,EAAE,SAAiB,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,SAAS,EACzE;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,4EAA4E;CAC1F,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,mBAAmB,GAAa,IAAA,mBAAQ,EACnD,qBAAqB,EACrB,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,iBAAiB,EAC9D;IACE,QAAQ,EAAE,QAAQ;IAClB,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,6DAA6D,iBAAiB,GAAG;IAC9F,OAAO,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC;CAC5B,CACF,CAAC;AAEF,kBAAe,CAAC,2BAAmB,EAAE,wCAAgC,CAAC,CAAC"}

package/dist/core/operators/comparison/equals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Equals Operator
+ *
+ * Checks strict equality between two values.
+ * Supports multiple types with type-specific implementations.
+ */
+import { PolymorphicOperator } from '../types';
+/**
+ * Equals operator - checks if two values are strictly equal
+ */
+export declare const equals: PolymorphicOperator;
+/**
+ * Equals ignore case - string-specific case-insensitive comparison
+ */
+export declare const equalsIgnoreCase: PolymorphicOperator;
+declare const _default: PolymorphicOperator[];
+export default _default;
+//# sourceMappingURL=equals.d.ts.map

package/dist/core/operators/comparison/equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/equals.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,mBAgBpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAY9B,CAAC;;AAEF,wBAA0C"}

package/dist/core/operators/comparison/equals.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Equals Operator
+ *
+ * Checks strict equality between two values.
+ * Supports multiple types with type-specific implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalsIgnoreCase = exports.equals = void 0;
+const operator_1 = require("../operator");
+/**
+ * Equals operator - checks if two values are strictly equal
+ */
+exports.equals = (0, operator_1.polymorphicOp)('equals', {
+    string: (a, b) => a === b,
+    number: (a, b) => a === b,
+    boolean: (a, b) => a === b,
+    date: (a, b) => a.getTime() === b.getTime(),
+    any: (a, b) => a === b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two values are strictly equal',
+    aliases: ['eq', '===', '=='],
+});
+/**
+ * Equals ignore case - string-specific case-insensitive comparison
+ */
+exports.equalsIgnoreCase = (0, operator_1.polymorphicOp)('equalsIgnoreCase', {
+    string: (a, b) => a.toLowerCase() === b.toLowerCase(),
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two strings are equal, ignoring case',
+    aliases: ['eqIgnoreCase'],
+});
+exports.default = [exports.equals, exports.equalsIgnoreCase];
+//# sourceMappingURL=equals.js.map

package/dist/core/operators/comparison/equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/equals.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,0CAA4C;AAG5C;;GAEG;AACU,QAAA,MAAM,GAAwB,IAAA,wBAAa,EACtD,QAAQ,EACR;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACzC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACzC,OAAO,EAAE,CAAC,CAAU,EAAE,CAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE;IACvD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;CACjC,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,yCAAyC;IACtD,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC;CAC7B,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,gBAAgB,GAAwB,IAAA,wBAAa,EAChE,kBAAkB,EAClB;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,WAAW,EAAE;CACtE,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,gDAAgD;IAC7D,OAAO,EAAE,CAAC,cAAc,CAAC;CAC1B,CACF,CAAC;AAEF,kBAAe,CAAC,cAAM,EAAE,wBAAgB,CAAC,CAAC"}

package/dist/core/operators/comparison/greater-than.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Greater Than Operators
+ *
+ * Checks if the first value is greater than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+import { PolymorphicOperator } from '../types';
+/**
+ * Greater than operator
+ */
+export declare const greaterThan: PolymorphicOperator;
+/**
+ * Greater than or equals operator
+ */
+export declare const greaterThanOrEquals: PolymorphicOperator;
+declare const _default: PolymorphicOperator[];
+export default _default;
+//# sourceMappingURL=greater-than.d.ts.map

package/dist/core/operators/comparison/greater-than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/greater-than.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,mBAgBzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAgBjC,CAAC;;AAEF,wBAAkD"}

package/dist/core/operators/comparison/greater-than.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Greater Than Operators
+ *
+ * Checks if the first value is greater than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.greaterThanOrEquals = exports.greaterThan = void 0;
+const operator_1 = require("../operator");
+/**
+ * Greater than operator
+ */
+exports.greaterThan = (0, operator_1.polymorphicOp)('greaterThan', {
+    number: (a, b) => a > b,
+    string: (a, b) => a.localeCompare(b, undefined, { numeric: true }) > 0,
+    date: (a, b) => a.getTime() > b.getTime(),
+    any: (a, b) => a != null && b != null && a > b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is greater than the second',
+    aliases: ['gt', '>'],
+});
+/**
+ * Greater than or equals operator
+ */
+exports.greaterThanOrEquals = (0, operator_1.polymorphicOp)('greaterThanOrEquals', {
+    number: (a, b) => a >= b,
+    string: (a, b) => a.localeCompare(b, undefined, { numeric: true }) >= 0,
+    date: (a, b) => a.getTime() >= b.getTime(),
+    any: (a, b) => a != null && b != null && a >= b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is greater than or equal to the second',
+    aliases: ['gte', '>='],
+});
+exports.default = [exports.greaterThan, exports.greaterThanOrEquals];
+//# sourceMappingURL=greater-than.js.map

package/dist/core/operators/comparison/greater-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/greater-than.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,0CAA4C;AAG5C;;GAEG;AACU,QAAA,WAAW,GAAwB,IAAA,wBAAa,EAC3D,aAAa,EACb;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC;IACvC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAC/B,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IACtD,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE;IACrD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC;CACzD,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,sDAAsD;IACnE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;CACrB,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,mBAAmB,GAAwB,IAAA,wBAAa,EACnE,qBAAqB,EACrB;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;IACxC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAC/B,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC;IACvD,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,OAAO,EAAE;IACtD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;CAC1D,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,kEAAkE;IAC/E,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;CACvB,CACF,CAAC;AAEF,kBAAe,CAAC,mBAAW,EAAE,2BAAmB,CAAC,CAAC"}

package/dist/core/operators/comparison/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Comparison Operators
+ *
+ * Exports all comparison operators for registry registration.
+ */
+export * from './equals';
+export * from './not-equals';
+export * from './greater-than';
+export * from './less-than';
+export * from './nullish';
+export * from './approximately-equals';
+/**
+ * All comparison operators as an array for bulk registration
+ */
+export declare const comparisonOperators: (import("..").PolymorphicOperator | import("..").Operator<import("..").OperatorParameter[], import("..").OperatorReturnType>)[];
+export default comparisonOperators;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/operators/comparison/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,wBAAwB,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,mBAAmB,iIAO/B,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/core/operators/comparison/index.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Comparison Operators
+ *
+ * Exports all comparison operators for registry registration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparisonOperators = void 0;
+const equals_1 = __importDefault(require("./equals"));
+const not_equals_1 = __importDefault(require("./not-equals"));
+const greater_than_1 = __importDefault(require("./greater-than"));
+const less_than_1 = __importDefault(require("./less-than"));
+const nullish_1 = __importDefault(require("./nullish"));
+const approximately_equals_1 = __importDefault(require("./approximately-equals"));
+__exportStar(require("./equals"), exports);
+__exportStar(require("./not-equals"), exports);
+__exportStar(require("./greater-than"), exports);
+__exportStar(require("./less-than"), exports);
+__exportStar(require("./nullish"), exports);
+__exportStar(require("./approximately-equals"), exports);
+/**
+ * All comparison operators as an array for bulk registration
+ */
+exports.comparisonOperators = [
+    ...equals_1.default,
+    ...not_equals_1.default,
+    ...greater_than_1.default,
+    ...less_than_1.default,
+    ...nullish_1.default,
+    ...approximately_equals_1.default,
+];
+exports.default = exports.comparisonOperators;
+//# sourceMappingURL=index.js.map

package/dist/core/operators/comparison/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;;;;;;;;;;;;;;;AAEH,sDAAiC;AACjC,8DAAwC;AACxC,kEAA4C;AAC5C,4DAAsC;AACtC,wDAAmC;AACnC,kFAA4D;AAE5D,2CAAyB;AACzB,+CAA6B;AAC7B,iDAA+B;AAC/B,8CAA4B;AAC5B,4CAA0B;AAC1B,yDAAuC;AAEvC;;GAEG;AACU,QAAA,mBAAmB,GAAG;IACjC,GAAG,gBAAS;IACZ,GAAG,oBAAY;IACf,GAAG,sBAAc;IACjB,GAAG,mBAAW;IACd,GAAG,iBAAU;IACb,GAAG,8BAAsB;CAC1B,CAAC;AAEF,kBAAe,2BAAmB,CAAC"}

package/dist/core/operators/comparison/less-than.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Less Than Operators
+ *
+ * Checks if the first value is less than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+import { PolymorphicOperator } from '../types';
+/**
+ * Less than operator
+ */
+export declare const lessThan: PolymorphicOperator;
+/**
+ * Less than or equals operator
+ */
+export declare const lessThanOrEquals: PolymorphicOperator;
+declare const _default: PolymorphicOperator[];
+export default _default;
+//# sourceMappingURL=less-than.d.ts.map

package/dist/core/operators/comparison/less-than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/less-than.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,mBAgBtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAgB9B,CAAC;;AAEF,wBAA4C"}

package/dist/core/operators/comparison/less-than.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Less Than Operators
+ *
+ * Checks if the first value is less than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lessThanOrEquals = exports.lessThan = void 0;
+const operator_1 = require("../operator");
+/**
+ * Less than operator
+ */
+exports.lessThan = (0, operator_1.polymorphicOp)('lessThan', {
+    number: (a, b) => a < b,
+    string: (a, b) => a.localeCompare(b, undefined, { numeric: true }) < 0,
+    date: (a, b) => a.getTime() < b.getTime(),
+    any: (a, b) => a != null && b != null && a < b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is less than the second',
+    aliases: ['lt', '<'],
+});
+/**
+ * Less than or equals operator
+ */
+exports.lessThanOrEquals = (0, operator_1.polymorphicOp)('lessThanOrEquals', {
+    number: (a, b) => a <= b,
+    string: (a, b) => a.localeCompare(b, undefined, { numeric: true }) <= 0,
+    date: (a, b) => a.getTime() <= b.getTime(),
+    any: (a, b) => a != null && b != null && a <= b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is less than or equal to the second',
+    aliases: ['lte', '<='],
+});
+exports.default = [exports.lessThan, exports.lessThanOrEquals];
+//# sourceMappingURL=less-than.js.map

package/dist/core/operators/comparison/less-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/less-than.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,0CAA4C;AAG5C;;GAEG;AACU,QAAA,QAAQ,GAAwB,IAAA,wBAAa,EACxD,UAAU,EACV;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC;IACvC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAC/B,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IACtD,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE;IACrD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC;CACzD,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,mDAAmD;IAChE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;CACrB,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,gBAAgB,GAAwB,IAAA,wBAAa,EAChE,kBAAkB,EAClB;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;IACxC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAC/B,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC;IACvD,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,OAAO,EAAE;IACtD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;CAC1D,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,+DAA+D;IAC5E,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;CACvB,CACF,CAAC;AAEF,kBAAe,CAAC,gBAAQ,EAAE,wBAAgB,CAAC,CAAC"}

package/dist/core/operators/comparison/not-equals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Not Equals Operator
+ *
+ * Checks inequality between two values.
+ * Supports multiple types with type-specific implementations.
+ */
+import { PolymorphicOperator } from '../types';
+/**
+ * Not equals operator - checks if two values are not equal
+ */
+export declare const notEquals: PolymorphicOperator;
+/**
+ * Not equals ignore case - string-specific case-insensitive comparison
+ */
+export declare const notEqualsIgnoreCase: PolymorphicOperator;
+declare const _default: PolymorphicOperator[];
+export default _default;
+//# sourceMappingURL=not-equals.d.ts.map

package/dist/core/operators/comparison/not-equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-equals.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/not-equals.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,mBAgBvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAYjC,CAAC;;AAEF,wBAAgD"}

package/dist/core/operators/comparison/not-equals.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Not Equals Operator
+ *
+ * Checks inequality between two values.
+ * Supports multiple types with type-specific implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEqualsIgnoreCase = exports.notEquals = void 0;
+const operator_1 = require("../operator");
+/**
+ * Not equals operator - checks if two values are not equal
+ */
+exports.notEquals = (0, operator_1.polymorphicOp)('notEquals', {
+    string: (a, b) => a !== b,
+    number: (a, b) => a !== b,
+    boolean: (a, b) => a !== b,
+    date: (a, b) => a.getTime() !== b.getTime(),
+    any: (a, b) => a !== b,
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two values are not equal',
+    aliases: ['neq', '!==', '!='],
+});
+/**
+ * Not equals ignore case - string-specific case-insensitive comparison
+ */
+exports.notEqualsIgnoreCase = (0, operator_1.polymorphicOp)('notEqualsIgnoreCase', {
+    string: (a, b) => a.toLowerCase() !== b.toLowerCase(),
+}, {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two strings are not equal, ignoring case',
+    aliases: ['neqIgnoreCase'],
+});
+exports.default = [exports.notEquals, exports.notEqualsIgnoreCase];
+//# sourceMappingURL=not-equals.js.map

package/dist/core/operators/comparison/not-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-equals.js","sourceRoot":"","sources":["../../../../src/core/operators/comparison/not-equals.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,0CAA4C;AAG5C;;GAEG;AACU,QAAA,SAAS,GAAwB,IAAA,wBAAa,EACzD,WAAW,EACX;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACzC,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACzC,OAAO,EAAE,CAAC,CAAU,EAAE,CAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE;IACvD,GAAG,EAAE,CAAC,CAAM,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;CACjC,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,oCAAoC;IACjD,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC;CAC9B,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,mBAAmB,GAAwB,IAAA,wBAAa,EACnE,qBAAqB,EACrB;IACE,MAAM,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,WAAW,EAAE;CACtE,EACD;IACE,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,YAAY;IACtB,WAAW,EAAE,oDAAoD;IACjE,OAAO,EAAE,CAAC,eAAe,CAAC;CAC3B,CACF,CAAC;AAEF,kBAAe,CAAC,iBAAS,EAAE,2BAAmB,CAAC,CAAC"}

package/dist/core/operators/comparison/nullish.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Nullish Operators
+ *
+ * Checks for null, undefined, and defined states.
+ */
+import { Operator } from '../types';
+/**
+ * Is null operator
+ */
+export declare const isNull: Operator;
+/**
+ * Is not null operator
+ */
+export declare const isNotNull: Operator;
+/**
+ * Is undefined operator
+ */
+export declare const isUndefined: Operator;
+/**
+ * Is defined operator
+ */
+export declare const isDefined: Operator;
+/**
+ * Is nullish operator (null or undefined)
+ */
+export declare const isNullish: Operator;
+/**
+ * Is not nullish operator
+ */
+export declare const isNotNullish: Operator;
+/**
+ * Is empty operator (null, undefined, or empty string)
+ */
+export declare const isEmpty: Operator;
+/**
+ * Coalesce operator - returns first non-empty value (not null, undefined, or empty string)
+ */
+export declare const coalesce: Operator;
+/**
+ * Coalesce nullish operator - returns first non-nullish value (only checks null/undefined)
+ */
+export declare const coalesceNullish: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=nullish.d.ts.map

package/dist/core/operators/comparison/nullish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullish.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/comparison/nullish.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AASpC;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,QASpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,QASvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,QASzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,QASvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,QASvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,QAS1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,QASrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAUtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAU7B,CAAC;;AAEF,wBAUE"}