@usearazzo/runner 0.0.0-stage → 1.0.1-alpha.7

package/src/criterion/CriterionEvaluator.mjs

@@ -0,0 +1,196 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isStringElement } from '@speclynx/apidom-datamodel';
+import { isCriterionElement, isCriterionExpressionTypeElement } from '@speclynx/apidom-ns-arazzo-1';
+import { test as isRuntimeExpression } from '@swaggerexpert/arazzo-runtime-expression';
+import CriterionError from "../errors/CriterionError.mjs";
+import RegexCriterionEvaluator from "./RegexCriterionEvaluator.mjs";
+import SimpleCriterionEvaluator from "./SimpleCriterionEvaluator.mjs";
+import JSONPathCriterionEvaluator from "./JSONPathCriterionEvaluator.mjs";
+import XPathCriterionEvaluator from "./XPathCriterionEvaluator.mjs";
+/**
+ * Resolves a runtime expression to a value during criterion evaluation.
+ *
+ * Used both for a criterion's `context` (regex/jsonpath/xpath) and for the
+ * expressions embedded in a `simple` condition. It should resolve leniently —
+ * an unresolvable reference returning `undefined` fails the criterion rather
+ * than throwing (a common way to drive it is
+ * `(expression) => runtimeExpressionEvaluator.evaluate(expression)` with a
+ * lenient evaluator).
+ * @public
+ */
+/**
+ * Options for the CriterionEvaluator.
+ * @public
+ */
+/**
+ * Evaluates an Arazzo Criterion Object to a boolean.
+ *
+ * Dispatches on the criterion's `type` (defaulting to `simple` when omitted):
+ * - `simple` — evaluates the condition directly, resolving the runtime
+ *   expressions embedded in it.
+ * - `regex` — resolves the `context` runtime expression, then applies the
+ *   pattern to the resolved value.
+ * - `jsonpath` — resolves the `context` runtime expression, then applies the
+ *   JSONPath query to the resolved value (met when the query matches). Only the
+ *   `rfc9535` version is supported (the spec default); an explicit other version
+ *   throws.
+ * - `xpath` — resolves the `context` runtime expression, then applies the XPath
+ *   3.1 query to the resolved XML value (met by the Effective Boolean Value).
+ *   Only the `xpath-31` version is supported (the spec default); an explicit
+ *   other version throws.
+ *
+ * The evaluator is agnostic about how runtime expressions are resolved: the
+ * caller supplies a {@link CriterionContextResolver} per evaluation, keeping
+ * runtime-state, document, and registry concerns in the runtime expression
+ * evaluator rather than duplicated here.
+ * @public
+ */
+class CriterionEvaluator {
+  #simple;
+  #regex;
+  #jsonpath;
+  #xpath;
+  constructor(options = {}) {
+    this.#simple = options.simple ?? new SimpleCriterionEvaluator();
+    this.#regex = options.regex ?? new RegexCriterionEvaluator();
+    this.#jsonpath = options.jsonpath ?? new JSONPathCriterionEvaluator();
+    this.#xpath = options.xpath ?? new XPathCriterionEvaluator();
+  }
+
+  /**
+   * Evaluates a criterion element, returning whether the condition is met.
+   *
+   * `resolve` turns a runtime expression into a value: for `simple` it resolves
+   * the expressions embedded in the condition; for the other types it resolves
+   * the criterion's `context` expression that the condition is applied to.
+   */
+  evaluate(criterion, resolve) {
+    if (!isCriterionElement(criterion)) {
+      throw new CriterionError('Element is not a Criterion Object', {
+        reason: 'invalid-criterion'
+      });
+    }
+    const condition = isStringElement(criterion.condition) ? toValue(criterion.condition) : undefined;
+    // `condition` is required; an empty string is not a meaningful condition
+    // (e.g. an empty regex would match unconditionally), so reject it too.
+    if (condition === undefined || condition === '') {
+      throw new CriterionError('Criterion is missing a "condition"', {
+        reason: 'missing-condition'
+      });
+    }
+    const type = this.#resolveType(criterion);
+    this.#requireValidContext(criterion, type);
+    switch (type) {
+      case 'simple':
+        return this.#simple.evaluate(condition, resolve);
+      case 'regex':
+        return this.#regex.evaluate(condition, this.#resolveContext(criterion, type, resolve));
+      case 'jsonpath':
+        // only rfc9535 is supported; it is the spec default, so an omitted
+        // version is accepted. draft-goessner has different semantics and is
+        // rejected rather than mis-evaluated.
+        this.#requireVersion(criterion, type, condition, 'rfc9535');
+        return this.#jsonpath.evaluate(condition, this.#resolveContext(criterion, type, resolve));
+      case 'xpath':
+        // only XPath 3.1 is supported; xpath-31 is the spec default, so an
+        // omitted version is accepted. Older versions are rejected.
+        this.#requireVersion(criterion, type, condition, 'xpath-31');
+        return this.#xpath.evaluate(condition, this.#resolveContext(criterion, type, resolve));
+      default:
+        throw new CriterionError(`Unknown criterion type "${type}"`, {
+          condition,
+          type,
+          reason: 'unknown-type'
+        });
+    }
+  }
+
+  /**
+   * Determines the criterion `type`, defaulting to `simple` only when the field
+   * is omitted. The `type` field may be a bare string or a Criterion Expression
+   * Type Object (whose own `type` names the flavor). A present-but-unreadable
+   * `type` throws a {@link CriterionError} rather than silently defaulting.
+   */
+  #resolveType(criterion) {
+    const type = criterion.type;
+    if (type === undefined) return 'simple';
+    if (isCriterionExpressionTypeElement(type) && isStringElement(type.type)) {
+      return toValue(type.type);
+    }
+    if (isStringElement(type)) return toValue(type);
+    throw new CriterionError('Criterion has an invalid "type"', {
+      reason: 'invalid-type'
+    });
+  }
+
+  /**
+   * Extracts the expression `version` from a Criterion Expression Type Object,
+   * or `undefined` when no version is declared (a bare-string `type`, or a type
+   * object without a `version`) — in which case the spec default for the type
+   * applies. A `version` that is present but not a string is malformed and
+   * throws a {@link CriterionError} rather than silently defaulting.
+   */
+  #resolveVersion(criterion) {
+    const type = criterion.type;
+    if (!isCriterionExpressionTypeElement(type) || type.version === undefined) {
+      return undefined;
+    }
+    if (isStringElement(type.version)) {
+      return toValue(type.version);
+    }
+    throw new CriterionError('Criterion has an invalid expression type "version"', {
+      reason: 'invalid-version'
+    });
+  }
+
+  /**
+   * Enforces that a versioned condition type declares only the one version this
+   * runner supports. An omitted version is accepted (it is the spec default);
+   * any other declared version throws a {@link CriterionError}.
+   */
+  #requireVersion(criterion, type, condition, supported) {
+    const version = this.#resolveVersion(criterion);
+    if (version !== undefined && version !== supported) {
+      throw new CriterionError(`Unsupported ${type} version "${version}" (only ${supported})`, {
+        condition,
+        type,
+        reason: 'unsupported-version'
+      });
+    }
+  }
+
+  /**
+   * Enforces that a present `context` is a valid runtime expression, for every
+   * criterion type: the spec types it `{expression}`, and `simple` ignores it,
+   * so a malformed one would otherwise go unnoticed there.
+   */
+  #requireValidContext(criterion, type) {
+    const {
+      context
+    } = criterion;
+    if (context === undefined) return;
+    if (!isStringElement(context) || !isRuntimeExpression(toValue(context))) {
+      throw new CriterionError('Criterion has a "context" that is not a valid runtime expression', {
+        type,
+        reason: 'invalid-context'
+      });
+    }
+  }
+
+  /**
+   * Resolves the criterion's `context` runtime expression to the value the
+   * condition is applied to. The condition types that need a context (`regex`,
+   * `jsonpath`, `xpath`) must declare one; a criterion of such a type without a
+   * `context` throws a {@link CriterionError}.
+   */
+  #resolveContext(criterion, type, resolve) {
+    if (!isStringElement(criterion.context)) {
+      throw new CriterionError(`Criterion type "${type}" requires a "context"`, {
+        type,
+        reason: 'missing-context'
+      });
+    }
+    return resolve(toValue(criterion.context));
+  }
+}
+export default CriterionEvaluator;

package/src/criterion/JSONPathCriterionEvaluator.cjs

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jsonpath = require("@swaggerexpert/jsonpath");
+var _CriterionError = _interopRequireDefault(require("../errors/CriterionError.cjs"));
+/**
+ * Evaluates a `jsonpath` Arazzo criterion condition against a resolved context value.
+ *
+ * The condition is a JSONPath query (RFC 9535, per the Criterion Expression
+ * Type Object's pinned version) applied to the resolved `context`. The criterion
+ * is met when the query yields a non-empty node list.
+ *
+ * Per Arazzo 1.1.0, a `null` or `undefined` context fails the condition. The
+ * context is a plain runtime value (the runtime expression evaluator has already
+ * converted any ApiDOM element), so the default JSON evaluation realm applies.
+ * @public
+ */
+class JSONPathCriterionEvaluator {
+  /**
+   * Runs the JSONPath `condition` against the resolved context value, returning
+   * whether it matched anything.
+   *
+   * Returns `false` when the context is `null` or `undefined`. Throws
+   * {@link CriterionError} when the condition is not a valid JSONPath query.
+   */
+  evaluate(condition, context) {
+    if (context === null || context === undefined) return false;
+    try {
+      return (0, _jsonpath.evaluate)(context, condition).length > 0;
+    } catch (error) {
+      if (error instanceof _jsonpath.JSONPathError) {
+        throw new _CriterionError.default(`Invalid jsonpath criterion condition "${condition}"`, {
+          cause: error,
+          condition,
+          type: 'jsonpath',
+          reason: 'invalid-jsonpath'
+        });
+      }
+      throw error;
+    }
+  }
+}
+var _default = exports.default = JSONPathCriterionEvaluator;

package/src/criterion/JSONPathCriterionEvaluator.mjs

@@ -0,0 +1,40 @@
+import { evaluate as evaluateJSONPath, JSONPathError } from '@swaggerexpert/jsonpath';
+import CriterionError from "../errors/CriterionError.mjs";
+/**
+ * Evaluates a `jsonpath` Arazzo criterion condition against a resolved context value.
+ *
+ * The condition is a JSONPath query (RFC 9535, per the Criterion Expression
+ * Type Object's pinned version) applied to the resolved `context`. The criterion
+ * is met when the query yields a non-empty node list.
+ *
+ * Per Arazzo 1.1.0, a `null` or `undefined` context fails the condition. The
+ * context is a plain runtime value (the runtime expression evaluator has already
+ * converted any ApiDOM element), so the default JSON evaluation realm applies.
+ * @public
+ */
+class JSONPathCriterionEvaluator {
+  /**
+   * Runs the JSONPath `condition` against the resolved context value, returning
+   * whether it matched anything.
+   *
+   * Returns `false` when the context is `null` or `undefined`. Throws
+   * {@link CriterionError} when the condition is not a valid JSONPath query.
+   */
+  evaluate(condition, context) {
+    if (context === null || context === undefined) return false;
+    try {
+      return evaluateJSONPath(context, condition).length > 0;
+    } catch (error) {
+      if (error instanceof JSONPathError) {
+        throw new CriterionError(`Invalid jsonpath criterion condition "${condition}"`, {
+          cause: error,
+          condition,
+          type: 'jsonpath',
+          reason: 'invalid-jsonpath'
+        });
+      }
+      throw error;
+    }
+  }
+}
+export default JSONPathCriterionEvaluator;

package/src/criterion/RegexCriterionEvaluator.cjs

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _CriterionError = _interopRequireDefault(require("../errors/CriterionError.cjs"));
+/**
+ * Evaluates a `regex` Arazzo criterion condition against a resolved context value.
+ *
+ * The Arazzo specification does not pin a regular expression dialect for the
+ * `regex` criterion type. This evaluator uses ECMA-262 (the native `RegExp`
+ * dialect), matching OpenAPI, which pins ECMA-262 for `pattern` via JSON Schema.
+ * The pattern is applied with search (not full-match) semantics — anchoring is
+ * the author's responsibility via `^`/`$`, consistent with the spec's `^200$`
+ * example.
+ *
+ * Per Arazzo 1.1.0, a `null` or `undefined` context fails the condition. A
+ * non-scalar context is serialized with `JSON.stringify` (matching how the
+ * runtime expression evaluator stringifies values for interpolation), so a
+ * pattern can match against an object/array body; scalars are coerced with
+ * `String()`.
+ *
+ * The pattern is a native `RegExp`, which has no execution timeout; a
+ * pathological author pattern (catastrophic backtracking) against a long
+ * context can stall. Patterns originate from the Arazzo document, so this is
+ * treated as trusted input rather than guarded here.
+ * @public
+ */
+class RegexCriterionEvaluator {
+  /**
+   * Tests the resolved context value against the regular expression `condition`.
+   *
+   * The context is coerced to a string before matching. Returns `false` when the
+   * context is `null` or `undefined`. Throws {@link CriterionError} when the
+   * condition is not a valid regular expression.
+   */
+  evaluate(condition, context) {
+    if (context === null || context === undefined) return false;
+    let regExp;
+    try {
+      regExp = new RegExp(condition);
+    } catch (error) {
+      throw new _CriterionError.default(`Invalid regex criterion condition "${condition}"`, {
+        cause: error,
+        condition,
+        type: 'regex',
+        reason: 'invalid-regex'
+      });
+    }
+    return regExp.test(this.#stringify(context));
+  }
+
+  /**
+   * Coerces a non-null context value to the string the pattern is tested
+   * against, matching the runtime expression evaluator's interpolation
+   * stringify: strings as-is, objects/arrays as JSON, everything else via
+   * `String()`. A value whose `JSON.stringify` is `undefined` becomes `''`.
+   */
+  #stringify(context) {
+    if (typeof context === 'string') return context;
+    if (typeof context === 'object') return JSON.stringify(context) ?? '';
+    return String(context);
+  }
+}
+var _default = exports.default = RegexCriterionEvaluator;

package/src/criterion/RegexCriterionEvaluator.mjs

@@ -0,0 +1,60 @@
+import CriterionError from "../errors/CriterionError.mjs";
+/**
+ * Evaluates a `regex` Arazzo criterion condition against a resolved context value.
+ *
+ * The Arazzo specification does not pin a regular expression dialect for the
+ * `regex` criterion type. This evaluator uses ECMA-262 (the native `RegExp`
+ * dialect), matching OpenAPI, which pins ECMA-262 for `pattern` via JSON Schema.
+ * The pattern is applied with search (not full-match) semantics — anchoring is
+ * the author's responsibility via `^`/`$`, consistent with the spec's `^200$`
+ * example.
+ *
+ * Per Arazzo 1.1.0, a `null` or `undefined` context fails the condition. A
+ * non-scalar context is serialized with `JSON.stringify` (matching how the
+ * runtime expression evaluator stringifies values for interpolation), so a
+ * pattern can match against an object/array body; scalars are coerced with
+ * `String()`.
+ *
+ * The pattern is a native `RegExp`, which has no execution timeout; a
+ * pathological author pattern (catastrophic backtracking) against a long
+ * context can stall. Patterns originate from the Arazzo document, so this is
+ * treated as trusted input rather than guarded here.
+ * @public
+ */
+class RegexCriterionEvaluator {
+  /**
+   * Tests the resolved context value against the regular expression `condition`.
+   *
+   * The context is coerced to a string before matching. Returns `false` when the
+   * context is `null` or `undefined`. Throws {@link CriterionError} when the
+   * condition is not a valid regular expression.
+   */
+  evaluate(condition, context) {
+    if (context === null || context === undefined) return false;
+    let regExp;
+    try {
+      regExp = new RegExp(condition);
+    } catch (error) {
+      throw new CriterionError(`Invalid regex criterion condition "${condition}"`, {
+        cause: error,
+        condition,
+        type: 'regex',
+        reason: 'invalid-regex'
+      });
+    }
+    return regExp.test(this.#stringify(context));
+  }
+
+  /**
+   * Coerces a non-null context value to the string the pattern is tested
+   * against, matching the runtime expression evaluator's interpolation
+   * stringify: strings as-is, objects/arrays as JSON, everything else via
+   * `String()`. A value whose `JSON.stringify` is `undefined` becomes `''`.
+   */
+  #stringify(context) {
+    if (typeof context === 'string') return context;
+    if (typeof context === 'object') return JSON.stringify(context) ?? '';
+    return String(context);
+  }
+}
+export default RegexCriterionEvaluator;

package/src/criterion/SimpleCriterionEvaluator.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _arazzoCriterion = require("@swaggerexpert/arazzo-criterion");
+var _CriterionError = _interopRequireDefault(require("../errors/CriterionError.cjs"));
+/**
+ * Evaluates a `simple` Arazzo criterion condition.
+ *
+ * A simple condition embeds runtime expressions directly in the condition
+ * (e.g. `$statusCode == 200 && $response.body.status == 'available'`), so —
+ * unlike `regex`/`jsonpath`/`xpath` — it has no separate `context`. Parsing,
+ * loose/case-insensitive comparison, and member/index navigation are delegated
+ * to `@swaggerexpert/arazzo-criterion`; each embedded runtime expression is
+ * resolved through the supplied resolver.
+ *
+ * An operand that resolves to `undefined` (a lenient miss) does not throw; it is
+ * compared per the library's rules (e.g. `undefined == x` and relational
+ * comparisons are false, matching the spec's "null equals only null"), so a
+ * negated or disjunctive condition may still pass. A malformed condition throws
+ * {@link CriterionError}.
+ * @public
+ */
+class SimpleCriterionEvaluator {
+  /**
+   * Evaluates the simple `condition`, resolving each embedded runtime
+   * expression via `resolve`.
+   */
+  evaluate(condition, resolve) {
+    try {
+      return (0, _arazzoCriterion.evaluate)(condition, {
+        resolve
+      });
+    } catch (error) {
+      if (error instanceof _arazzoCriterion.ArazzoCriterionError) {
+        throw new _CriterionError.default(`Invalid simple criterion condition "${condition}"`, {
+          cause: error,
+          condition,
+          type: 'simple',
+          reason: 'invalid-simple'
+        });
+      }
+      throw error;
+    }
+  }
+}
+var _default = exports.default = SimpleCriterionEvaluator;

package/src/criterion/SimpleCriterionEvaluator.mjs

@@ -0,0 +1,43 @@
+import { evaluate as evaluateSimpleCriterion, ArazzoCriterionError } from '@swaggerexpert/arazzo-criterion';
+import CriterionError from "../errors/CriterionError.mjs";
+/**
+ * Evaluates a `simple` Arazzo criterion condition.
+ *
+ * A simple condition embeds runtime expressions directly in the condition
+ * (e.g. `$statusCode == 200 && $response.body.status == 'available'`), so —
+ * unlike `regex`/`jsonpath`/`xpath` — it has no separate `context`. Parsing,
+ * loose/case-insensitive comparison, and member/index navigation are delegated
+ * to `@swaggerexpert/arazzo-criterion`; each embedded runtime expression is
+ * resolved through the supplied resolver.
+ *
+ * An operand that resolves to `undefined` (a lenient miss) does not throw; it is
+ * compared per the library's rules (e.g. `undefined == x` and relational
+ * comparisons are false, matching the spec's "null equals only null"), so a
+ * negated or disjunctive condition may still pass. A malformed condition throws
+ * {@link CriterionError}.
+ * @public
+ */
+class SimpleCriterionEvaluator {
+  /**
+   * Evaluates the simple `condition`, resolving each embedded runtime
+   * expression via `resolve`.
+   */
+  evaluate(condition, resolve) {
+    try {
+      return evaluateSimpleCriterion(condition, {
+        resolve
+      });
+    } catch (error) {
+      if (error instanceof ArazzoCriterionError) {
+        throw new CriterionError(`Invalid simple criterion condition "${condition}"`, {
+          cause: error,
+          condition,
+          type: 'simple',
+          reason: 'invalid-simple'
+        });
+      }
+      throw error;
+    }
+  }
+}
+export default SimpleCriterionEvaluator;

package/src/criterion/XPathCriterionEvaluator.cjs

@@ -0,0 +1,117 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fontoxpath = _interopRequireDefault(require("fontoxpath"));
+var _xmldom = require("@xmldom/xmldom");
+var _CriterionError = _interopRequireDefault(require("../errors/CriterionError.cjs"));
+// fontoxpath is CommonJS and its named exports are not statically resolvable
+// under ESM, so import the default and destructure.
+
+const {
+  evaluateXPathToBoolean,
+  evaluateXPath
+} = _fontoxpath.default;
+
+/**
+ * Evaluates an `xpath` Arazzo criterion condition against a resolved context value.
+ *
+ * The condition is an XPath 3.1 query applied to the resolved `context`, which
+ * must be XML. A string context is parsed as XML; an already-parsed DOM node is
+ * used as-is. The criterion is met by the query's Effective Boolean Value
+ * (XPath 3.1 §19.1.2), as the Arazzo specification mandates — so a boolean
+ * predicate (`//status = 'ok'`), a non-empty node set, a non-zero number, and a
+ * non-empty string all evaluate to `true`.
+ *
+ * Only XPath 3.1 is supported (`fontoxpath`'s engine); version gating happens in
+ * the facade. Per Arazzo 1.1.0, a `null` or `undefined` context fails the
+ * condition. An invalid query throws {@link CriterionError}.
+ * @public
+ */
+class XPathCriterionEvaluator {
+  /**
+   * Evaluates the XPath `condition` against the resolved context value, returning
+   * its Effective Boolean Value.
+   *
+   * Returns `false` when the context is `null` or `undefined`. Throws
+   * {@link CriterionError} when the context is not XML or the query is invalid.
+   */
+  evaluate(condition, context) {
+    if (context === null || context === undefined) return false;
+    const node = this.#toNode(condition, context);
+    try {
+      return evaluateXPathToBoolean(condition, node, null, null, {
+        language: evaluateXPath.XPATH_3_1_LANGUAGE
+      });
+    } catch (error) {
+      throw new _CriterionError.default(`Invalid xpath criterion condition "${condition}"`, {
+        cause: error,
+        condition,
+        type: 'xpath',
+        reason: 'invalid-xpath'
+      });
+    }
+  }
+
+  /**
+   * Coerces the resolved context to an XML DOM node: an already-parsed node is
+   * used as-is, a string is parsed as XML. Any other value cannot be an XPath
+   * context and throws.
+   */
+  #toNode(condition, context) {
+    if (this.#isNode(context)) return context;
+    if (typeof context !== 'string') {
+      throw new _CriterionError.default('xpath criterion context is not XML', {
+        condition,
+        type: 'xpath',
+        reason: 'invalid-context'
+      });
+    }
+
+    // capture parse errors via `onError` rather than the default handler: this
+    // both suppresses the parser writing to the console and catches *recoverable*
+    // errors (e.g. an undefined entity, stray text) that do not throw but would
+    // otherwise yield a degraded document evaluated silently.
+    let parseError;
+    try {
+      const document = new _xmldom.DOMParser({
+        onError: (_level, message) => {
+          parseError ??= message;
+        }
+      }).parseFromString(context, 'text/xml');
+      if (parseError !== undefined) {
+        throw new _CriterionError.default('xpath criterion context is not valid XML', {
+          cause: parseError,
+          condition,
+          type: 'xpath',
+          reason: 'invalid-context'
+        });
+      }
+      return document;
+    } catch (error) {
+      if (error instanceof _CriterionError.default) throw error;
+      throw new _CriterionError.default('xpath criterion context is not valid XML', {
+        cause: error,
+        condition,
+        type: 'xpath',
+        reason: 'invalid-context'
+      });
+    }
+  }
+
+  /**
+   * Duck-types a DOM node, so a caller may pass an already-parsed document
+   * instead of an XML string. Requires both a numeric `nodeType` and a string
+   * `nodeName` so a plain JSON value that happens to carry a `nodeType` property
+   * is not mistaken for a node (and is instead rejected as a non-XML context).
+   */
+  #isNode(value) {
+    if (typeof value !== 'object' || value === null) return false;
+    const node = value;
+    return typeof node.nodeType === 'number' && typeof node.nodeName === 'string';
+  }
+}
+var _default = exports.default = XPathCriterionEvaluator;