@speclynx/apidom-json-path 4.0.1 → 4.0.3

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.0.3](https://github.com/speclynx/apidom/compare/v4.0.2...v4.0.3) (2026-03-11)
+
+### Bug Fixes
+
+- **release:** fix v4.0.2 failed release ([b4dc1c4](https://github.com/speclynx/apidom/commit/b4dc1c48e8d9b2986a70e49b5554eb0a166d7528))
+
+## [4.0.2](https://github.com/speclynx/apidom/compare/v4.0.1...v4.0.2) (2026-03-11)
+
+**Note:** Version bump only for package @speclynx/apidom-json-path
+
 ## [4.0.1](https://github.com/speclynx/apidom/compare/v4.0.0...v4.0.1) (2026-03-11)
 
 **Note:** Version bump only for package @speclynx/apidom-json-path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@speclynx/apidom-json-path",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Evaluate JSONPath expressions against ApiDOM.",
   "keywords": [
     "apidom",
@@ -55,13 +55,12 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@babel/runtime-corejs3": "^7.28.4",
-    "@speclynx/apidom-datamodel": "4.0.1",
-    "@speclynx/apidom-error": "4.0.1",
+    "@speclynx/apidom-datamodel": "4.0.3",
+    "@speclynx/apidom-error": "4.0.3",
     "@swaggerexpert/jsonpath": "^4.0.3"
   },
   "files": [
-    "src/**/*.mjs",
-    "src/**/*.cjs",
+    "src/",
     "dist/",
     "types/apidom-json-path.d.ts",
     "LICENSES",
@@ -69,5 +68,5 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "gitHead": "223132a9b00081ca04842efc2736a491f7876f44"
+  "gitHead": "6ccfa09c02232516215e7de3ead276641957e626"
 }

package/src/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.test = exports.parse = exports.functions = exports.evaluate = exports.XMLTranslator = exports.NormalizedPath = exports.JSONPathParseError = exports.JSONPathEvaluateError = exports.JSONPathError = exports.JSONNormalizedPathError = exports.JSONEvaluationRealm = exports.Grammar = exports.EvaluationRealm = exports.CSTTranslator = exports.CSTOptimizedTranslator = exports.ASTTranslator = void 0;
+var _jsonpath = require("@swaggerexpert/jsonpath");
+exports.parse = _jsonpath.parse;
+exports.CSTTranslator = _jsonpath.CSTTranslator;
+exports.CSTOptimizedTranslator = _jsonpath.CSTOptimizedTranslator;
+exports.ASTTranslator = _jsonpath.ASTTranslator;
+exports.XMLTranslator = _jsonpath.XMLTranslator;
+exports.test = _jsonpath.test;
+exports.NormalizedPath = _jsonpath.NormalizedPath;
+exports.functions = _jsonpath.functions;
+exports.EvaluationRealm = _jsonpath.EvaluationRealm;
+exports.JSONEvaluationRealm = _jsonpath.JSONEvaluationRealm;
+exports.Grammar = _jsonpath.Grammar;
+exports.JSONPathError = _jsonpath.JSONPathError;
+exports.JSONPathParseError = _jsonpath.JSONPathParseError;
+exports.JSONNormalizedPathError = _jsonpath.JSONNormalizedPathError;
+exports.JSONPathEvaluateError = _jsonpath.JSONPathEvaluateError;
+var _realm = _interopRequireDefault(require("./realm.cjs"));
+exports.ApiDOMEvaluationRealm = _realm.default;
+const realm = new _realm.default();
+
+/**
+ * Options for ApiDOM JSONPath evaluation.
+ * @public
+ */
+
+/**
+ * Evaluate a JSONPath expression against an ApiDOM element.
+ *
+ * @param value - ApiDOM element to query
+ * @param expression - JSONPath expression
+ * @param options - Evaluation options
+ * @returns Array of matched values
+ *
+ * @example
+ * ```typescript
+ * import { ObjectElement } from '@speclynx/apidom-datamodel';
+ * import { evaluate } from '@speclynx/apidom-json-path';
+ *
+ * const element = new ObjectElement({ a: { b: [1, 2, 3] } });
+ * const results = evaluate(element, '$.a.b[*]');
+ * // => [NumberElement(1), NumberElement(2), NumberElement(3)]
+ * ```
+ *
+ * @public
+ */
+const evaluate = (value, expression, options = {}) => {
+  return (0, _jsonpath.evaluate)(value, expression, {
+    ...options,
+    realm
+  });
+};
+
+/**
+ * Re-export all types
+ */
+exports.evaluate = evaluate;

package/src/index.mjs

@@ -0,0 +1,65 @@
+import { evaluate as baseEvaluate } from '@swaggerexpert/jsonpath';
+export {
+/**
+ * Parsing
+ */
+parse, CSTTranslator, CSTOptimizedTranslator, ASTTranslator, XMLTranslator,
+/**
+ * Testing
+ */
+test,
+/**
+ * Normalized Path
+ */
+NormalizedPath,
+/**
+ * Evaluation
+ */
+functions, EvaluationRealm, JSONEvaluationRealm,
+/**
+ * Grammar
+ */
+Grammar,
+/**
+ * Errors
+ */
+JSONPathError, JSONPathParseError, JSONNormalizedPathError, JSONPathEvaluateError } from '@swaggerexpert/jsonpath';
+import ApiDOMEvaluationRealm from "./realm.mjs";
+export { ApiDOMEvaluationRealm };
+const realm = new ApiDOMEvaluationRealm();
+
+/**
+ * Options for ApiDOM JSONPath evaluation.
+ * @public
+ */
+
+/**
+ * Evaluate a JSONPath expression against an ApiDOM element.
+ *
+ * @param value - ApiDOM element to query
+ * @param expression - JSONPath expression
+ * @param options - Evaluation options
+ * @returns Array of matched values
+ *
+ * @example
+ * ```typescript
+ * import { ObjectElement } from '@speclynx/apidom-datamodel';
+ * import { evaluate } from '@speclynx/apidom-json-path';
+ *
+ * const element = new ObjectElement({ a: { b: [1, 2, 3] } });
+ * const results = evaluate(element, '$.a.b[*]');
+ * // => [NumberElement(1), NumberElement(2), NumberElement(3)]
+ * ```
+ *
+ * @public
+ */
+export const evaluate = (value, expression, options = {}) => {
+  return baseEvaluate(value, expression, {
+    ...options,
+    realm
+  });
+};
+
+/**
+ * Re-export all types
+ */

package/src/index.ts

@@ -0,0 +1,94 @@
+import { evaluate as baseEvaluate } from '@swaggerexpert/jsonpath';
+
+export {
+  /**
+   * Parsing
+   */
+  parse,
+  CSTTranslator,
+  CSTOptimizedTranslator,
+  ASTTranslator,
+  XMLTranslator,
+  /**
+   * Testing
+   */
+  test,
+  /**
+   * Normalized Path
+   */
+  NormalizedPath,
+  /**
+   * Evaluation
+   */
+  functions,
+  EvaluationRealm,
+  JSONEvaluationRealm,
+  /**
+   * Grammar
+   */
+  Grammar,
+  /**
+   * Errors
+   */
+  JSONPathError,
+  JSONPathParseError,
+  JSONNormalizedPathError,
+  JSONPathEvaluateError,
+} from '@swaggerexpert/jsonpath';
+
+import ApiDOMEvaluationRealm from './realm.ts';
+
+export { ApiDOMEvaluationRealm };
+
+const realm = new ApiDOMEvaluationRealm();
+
+/**
+ * Options for ApiDOM JSONPath evaluation.
+ * @public
+ */
+export interface ApiDOMEvaluateOptions {
+  /**
+   * Optional callback called for each match.
+   * @param value - The matched value
+   * @param normalizedPath - The normalized path to the match
+   */
+  callback?: (value: unknown, normalizedPath: string) => void;
+  /**
+   * Optional custom function registry.
+   * Can extend or override built-in functions (length, count, match, search, value).
+   */
+  functions?: Record<string, (...args: unknown[]) => unknown>;
+}
+
+/**
+ * Evaluate a JSONPath expression against an ApiDOM element.
+ *
+ * @param value - ApiDOM element to query
+ * @param expression - JSONPath expression
+ * @param options - Evaluation options
+ * @returns Array of matched values
+ *
+ * @example
+ * ```typescript
+ * import { ObjectElement } from '@speclynx/apidom-datamodel';
+ * import { evaluate } from '@speclynx/apidom-json-path';
+ *
+ * const element = new ObjectElement({ a: { b: [1, 2, 3] } });
+ * const results = evaluate(element, '$.a.b[*]');
+ * // => [NumberElement(1), NumberElement(2), NumberElement(3)]
+ * ```
+ *
+ * @public
+ */
+export const evaluate = <T = unknown>(
+  value: unknown,
+  expression: string,
+  options: ApiDOMEvaluateOptions = {},
+): T[] => {
+  return baseEvaluate(value, expression, { ...options, realm });
+};
+
+/**
+ * Re-export all types
+ */
+export type * from '@swaggerexpert/jsonpath';

package/src/realm.cjs

@@ -0,0 +1,148 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _jsonpath = require("@swaggerexpert/jsonpath");
+/**
+ * ApiDOM Evaluation Realm implementation for JSONPath.
+ * @public
+ */
+class ApiDOMEvaluationRealm extends _jsonpath.EvaluationRealm {
+  name = 'apidom';
+  isObject(value) {
+    return (0, _apidomDatamodel.isObjectElement)(value);
+  }
+  isArray(value) {
+    return (0, _apidomDatamodel.isArrayElement)(value);
+  }
+  isString(value) {
+    return (0, _apidomDatamodel.isStringElement)(value);
+  }
+  isNumber(value) {
+    return (0, _apidomDatamodel.isNumberElement)(value);
+  }
+  isBoolean(value) {
+    return (0, _apidomDatamodel.isBooleanElement)(value);
+  }
+  isNull(value) {
+    return (0, _apidomDatamodel.isNullElement)(value);
+  }
+  getString(value) {
+    if ((0, _apidomDatamodel.isStringElement)(value)) return value.toValue();
+    if (typeof value === 'string') return value;
+    return undefined;
+  }
+  getProperty(value, key) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return undefined;
+    if (!value.hasKey(key)) return undefined;
+    return value.get(key);
+  }
+  hasProperty(value, key) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return false;
+    return value.hasKey(key);
+  }
+  getElement(value, index) {
+    if (!(0, _apidomDatamodel.isArrayElement)(value)) return undefined;
+    if (index < 0 || index >= value.length) return undefined;
+    return value.get(index);
+  }
+  getKeys(value) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return [];
+    return value.keys();
+  }
+  getLength(value) {
+    if ((0, _apidomDatamodel.isStringElement)(value)) return [...value.toValue()].length;
+    if ((0, _apidomDatamodel.isArrayElement)(value)) return value.length;
+    if ((0, _apidomDatamodel.isObjectElement)(value)) return value.length;
+    if (typeof value === 'string') return [...value].length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  *entries(value) {
+    if ((0, _apidomDatamodel.isArrayElement)(value)) {
+      let index = 0;
+      for (const item of value) {
+        yield [index, item];
+        index += 1;
+      }
+    } else if ((0, _apidomDatamodel.isObjectElement)(value)) {
+      for (const member of value) {
+        yield [member.key.toValue(), member.value];
+      }
+    }
+  }
+  compare(left, operator, right) {
+    // Handle Nothing (undefined) comparisons
+    if (left === undefined || right === undefined) {
+      if (operator === '==') return left === undefined && right === undefined;
+      if (operator === '!=') return !(left === undefined && right === undefined);
+      return false;
+    }
+
+    // Check if both are numbers (elements or primitives)
+    const leftIsNumber = (0, _apidomDatamodel.isNumberElement)(left) || typeof left === 'number';
+    const rightIsNumber = (0, _apidomDatamodel.isNumberElement)(right) || typeof right === 'number';
+
+    // For numeric values, use primitive comparison with -0 normalization (RFC 9535)
+    if (leftIsNumber && rightIsNumber) {
+      const leftPrimitive = (0, _apidomDatamodel.isNumberElement)(left) ? left.toValue() : left;
+      const rightPrimitive = (0, _apidomDatamodel.isNumberElement)(right) ? right.toValue() : right;
+      const leftVal = Object.is(leftPrimitive, -0) ? 0 : leftPrimitive;
+      const rightVal = Object.is(rightPrimitive, -0) ? 0 : rightPrimitive;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // Check if both are strings (elements or primitives)
+    const leftIsString = (0, _apidomDatamodel.isStringElement)(left) || typeof left === 'string';
+    const rightIsString = (0, _apidomDatamodel.isStringElement)(right) || typeof right === 'string';
+
+    // For string values, use primitive comparison
+    if (leftIsString && rightIsString) {
+      const leftVal = (0, _apidomDatamodel.isStringElement)(left) ? left.toValue() : left;
+      const rightVal = (0, _apidomDatamodel.isStringElement)(right) ? right.toValue() : right;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // For other types (booleans, nulls), only equality operators are defined (RFC 9535)
+    if (operator === '==') {
+      return (0, _apidomDatamodel.refract)(left).equals(right);
+    }
+    if (operator === '!=') {
+      return !(0, _apidomDatamodel.refract)(left).equals(right);
+    }
+    // Comparison operators (<, >, <=, >=) are not defined for non-numeric, non-string types
+    return false;
+  }
+}
+var _default = exports.default = ApiDOMEvaluationRealm;

package/src/realm.mjs

@@ -0,0 +1,145 @@
+import { isObjectElement, isArrayElement, isStringElement, isNumberElement, isBooleanElement, isNullElement, refract } from '@speclynx/apidom-datamodel';
+import { EvaluationRealm } from '@swaggerexpert/jsonpath';
+
+/**
+ * ApiDOM Evaluation Realm implementation for JSONPath.
+ * @public
+ */
+class ApiDOMEvaluationRealm extends EvaluationRealm {
+  name = 'apidom';
+  isObject(value) {
+    return isObjectElement(value);
+  }
+  isArray(value) {
+    return isArrayElement(value);
+  }
+  isString(value) {
+    return isStringElement(value);
+  }
+  isNumber(value) {
+    return isNumberElement(value);
+  }
+  isBoolean(value) {
+    return isBooleanElement(value);
+  }
+  isNull(value) {
+    return isNullElement(value);
+  }
+  getString(value) {
+    if (isStringElement(value)) return value.toValue();
+    if (typeof value === 'string') return value;
+    return undefined;
+  }
+  getProperty(value, key) {
+    if (!isObjectElement(value)) return undefined;
+    if (!value.hasKey(key)) return undefined;
+    return value.get(key);
+  }
+  hasProperty(value, key) {
+    if (!isObjectElement(value)) return false;
+    return value.hasKey(key);
+  }
+  getElement(value, index) {
+    if (!isArrayElement(value)) return undefined;
+    if (index < 0 || index >= value.length) return undefined;
+    return value.get(index);
+  }
+  getKeys(value) {
+    if (!isObjectElement(value)) return [];
+    return value.keys();
+  }
+  getLength(value) {
+    if (isStringElement(value)) return [...value.toValue()].length;
+    if (isArrayElement(value)) return value.length;
+    if (isObjectElement(value)) return value.length;
+    if (typeof value === 'string') return [...value].length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  *entries(value) {
+    if (isArrayElement(value)) {
+      let index = 0;
+      for (const item of value) {
+        yield [index, item];
+        index += 1;
+      }
+    } else if (isObjectElement(value)) {
+      for (const member of value) {
+        yield [member.key.toValue(), member.value];
+      }
+    }
+  }
+  compare(left, operator, right) {
+    // Handle Nothing (undefined) comparisons
+    if (left === undefined || right === undefined) {
+      if (operator === '==') return left === undefined && right === undefined;
+      if (operator === '!=') return !(left === undefined && right === undefined);
+      return false;
+    }
+
+    // Check if both are numbers (elements or primitives)
+    const leftIsNumber = isNumberElement(left) || typeof left === 'number';
+    const rightIsNumber = isNumberElement(right) || typeof right === 'number';
+
+    // For numeric values, use primitive comparison with -0 normalization (RFC 9535)
+    if (leftIsNumber && rightIsNumber) {
+      const leftPrimitive = isNumberElement(left) ? left.toValue() : left;
+      const rightPrimitive = isNumberElement(right) ? right.toValue() : right;
+      const leftVal = Object.is(leftPrimitive, -0) ? 0 : leftPrimitive;
+      const rightVal = Object.is(rightPrimitive, -0) ? 0 : rightPrimitive;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // Check if both are strings (elements or primitives)
+    const leftIsString = isStringElement(left) || typeof left === 'string';
+    const rightIsString = isStringElement(right) || typeof right === 'string';
+
+    // For string values, use primitive comparison
+    if (leftIsString && rightIsString) {
+      const leftVal = isStringElement(left) ? left.toValue() : left;
+      const rightVal = isStringElement(right) ? right.toValue() : right;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // For other types (booleans, nulls), only equality operators are defined (RFC 9535)
+    if (operator === '==') {
+      return refract(left).equals(right);
+    }
+    if (operator === '!=') {
+      return !refract(left).equals(right);
+    }
+    // Comparison operators (<, >, <=, >=) are not defined for non-numeric, non-string types
+    return false;
+  }
+}
+export default ApiDOMEvaluationRealm;

package/src/realm.ts

@@ -0,0 +1,172 @@
+import {
+  ObjectElement,
+  ArrayElement,
+  isObjectElement,
+  isArrayElement,
+  isStringElement,
+  isNumberElement,
+  isBooleanElement,
+  isNullElement,
+  refract,
+} from '@speclynx/apidom-datamodel';
+import { EvaluationRealm } from '@swaggerexpert/jsonpath';
+
+/**
+ * ApiDOM Evaluation Realm implementation for JSONPath.
+ * @public
+ */
+class ApiDOMEvaluationRealm extends EvaluationRealm {
+  override name = 'apidom';
+
+  override isObject(value: unknown): value is ObjectElement {
+    return isObjectElement(value);
+  }
+
+  override isArray(value: unknown): value is ArrayElement {
+    return isArrayElement(value);
+  }
+
+  override isString(value: unknown): boolean {
+    return isStringElement(value);
+  }
+
+  override isNumber(value: unknown): boolean {
+    return isNumberElement(value);
+  }
+
+  override isBoolean(value: unknown): boolean {
+    return isBooleanElement(value);
+  }
+
+  override isNull(value: unknown): boolean {
+    return isNullElement(value);
+  }
+
+  override getString(value: unknown): string | undefined {
+    if (isStringElement(value)) return value.toValue() as string;
+    if (typeof value === 'string') return value;
+    return undefined;
+  }
+
+  override getProperty(value: unknown, key: string): unknown {
+    if (!isObjectElement(value)) return undefined;
+    if (!value.hasKey(key)) return undefined;
+    return value.get(key);
+  }
+
+  override hasProperty(value: unknown, key: string): boolean {
+    if (!isObjectElement(value)) return false;
+    return value.hasKey(key);
+  }
+
+  override getElement(value: unknown, index: number): unknown {
+    if (!isArrayElement(value)) return undefined;
+    if (index < 0 || index >= value.length) return undefined;
+    return value.get(index);
+  }
+
+  override getKeys(value: unknown): string[] {
+    if (!isObjectElement(value)) return [];
+    return value.keys() as string[];
+  }
+
+  override getLength(value: unknown): number {
+    if (isStringElement(value)) return [...(value.toValue() as string)].length;
+    if (isArrayElement(value)) return value.length;
+    if (isObjectElement(value)) return value.length;
+    if (typeof value === 'string') return [...value].length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+
+  override *entries(value: unknown): Iterable<[string | number, unknown]> {
+    if (isArrayElement(value)) {
+      let index = 0;
+      for (const item of value) {
+        yield [index, item];
+        index += 1;
+      }
+    } else if (isObjectElement(value)) {
+      for (const member of value) {
+        yield [member.key!.toValue() as string, member.value];
+      }
+    }
+  }
+
+  override compare(left: unknown, operator: string, right: unknown): boolean {
+    // Handle Nothing (undefined) comparisons
+    if (left === undefined || right === undefined) {
+      if (operator === '==') return left === undefined && right === undefined;
+      if (operator === '!=') return !(left === undefined && right === undefined);
+      return false;
+    }
+
+    // Check if both are numbers (elements or primitives)
+    const leftIsNumber = isNumberElement(left) || typeof left === 'number';
+    const rightIsNumber = isNumberElement(right) || typeof right === 'number';
+
+    // For numeric values, use primitive comparison with -0 normalization (RFC 9535)
+    if (leftIsNumber && rightIsNumber) {
+      const leftPrimitive = (isNumberElement(left) ? left.toValue() : left) as number;
+      const rightPrimitive = (isNumberElement(right) ? right.toValue() : right) as number;
+      const leftVal = Object.is(leftPrimitive, -0) ? 0 : leftPrimitive;
+      const rightVal = Object.is(rightPrimitive, -0) ? 0 : rightPrimitive;
+
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // Check if both are strings (elements or primitives)
+    const leftIsString = isStringElement(left) || typeof left === 'string';
+    const rightIsString = isStringElement(right) || typeof right === 'string';
+
+    // For string values, use primitive comparison
+    if (leftIsString && rightIsString) {
+      const leftVal = (isStringElement(left) ? left.toValue() : left) as string;
+      const rightVal = (isStringElement(right) ? right.toValue() : right) as string;
+
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // For other types (booleans, nulls), only equality operators are defined (RFC 9535)
+    if (operator === '==') {
+      return refract(left).equals(right);
+    }
+    if (operator === '!=') {
+      return !refract(left).equals(right);
+    }
+    // Comparison operators (<, >, <=, >=) are not defined for non-numeric, non-string types
+    return false;
+  }
+}
+
+export default ApiDOMEvaluationRealm;