@getodk/xpath 0.2.0 → 0.3.0

package/dist/context/EvaluationContext.d.ts

@@ -1,49 +1,38 @@
 import { Temporal } from '@js-temporal/polyfill';
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
+import { AdapterDocument, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
+import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
 import { LocationPathEvaluation } from '../evaluations/LocationPathEvaluation.ts';
 import { Evaluator } from '../evaluator/Evaluator.ts';
+import { NamespaceResolver } from '../evaluator/NamespaceResolver.ts';
 import { FunctionLibraryCollection } from '../evaluator/functions/FunctionLibraryCollection.ts';
-import { FilteredTreeWalker, FilteredTreeWalkers } from '../lib/dom/traversal.ts';
-import { ContextDocument, ContextNode, ContextParentNode } from '../lib/dom/types.ts';
-import { XPathNamespaceResolverObject } from '../shared/interface.ts';
 import { Context } from './Context.ts';
-
-declare class EvaluationContextTreeWalkers implements FilteredTreeWalkers {
-    readonly ANY: FilteredTreeWalker<'ANY'>;
-    readonly COMMENT: FilteredTreeWalker<'COMMENT'>;
-    readonly ELEMENT: FilteredTreeWalker<'ELEMENT'>;
-    readonly PROCESSING_INSTRUCTION: FilteredTreeWalker<'PROCESSING_INSTRUCTION'>;
-    readonly TEXT: FilteredTreeWalker<'TEXT'>;
-    constructor(contextDocument: ContextDocument, rootNode: ContextParentNode);
-}
-export type { EvaluationContextTreeWalkers };
-export interface EvaluationContextOptions {
-    readonly document: ContextDocument;
-    readonly rootNode: ContextParentNode;
+export interface EvaluationContextOptions<T extends XPathNode> {
+    readonly rootNode: AdapterParentNode<T> | null;
     readonly functions: FunctionLibraryCollection;
-    readonly namespaceResolver: XPathNamespaceResolverObject;
+    readonly namespaceResolver: XPathNSResolver | null;
     readonly timeZone: Temporal.TimeZone;
-    readonly treeWalkers: EvaluationContextTreeWalkers;
 }
 /**
  * The context in which an XPath expression (**not** a sub-expression)
  * is evaluated.
  */
-export declare class EvaluationContext implements Context {
-    readonly evaluator: Evaluator;
+export declare class EvaluationContext<T extends XPathNode> implements Context<T> {
+    readonly evaluator: Evaluator<T>;
+    readonly domProvider: XPathDOMProvider<T>;
     /**
      * @see {@link Context.evaluationContextNode}
      */
-    readonly evaluationContextNode: ContextNode;
-    readonly contextDocument: ContextDocument;
-    readonly rootNode: ContextParentNode;
-    readonly contextNodes: Iterable<ContextNode>;
+    readonly evaluationContextNode: T;
+    readonly contextDocument: AdapterDocument<T>;
+    readonly rootNode: AdapterParentNode<T>;
+    readonly contextNodes: Iterable<T>;
     readonly functions: FunctionLibraryCollection;
-    readonly namespaceResolver: XPathNamespaceResolverObject;
+    readonly namespaceResolver: NamespaceResolver<T>;
     readonly timeZone: Temporal.TimeZone;
-    readonly treeWalkers: EvaluationContextTreeWalkers;
-    constructor(evaluator: Evaluator, contextNode: ContextNode, options?: Partial<EvaluationContextOptions>);
+    constructor(evaluator: Evaluator<T>, contextNode: T, options?: Partial<EvaluationContextOptions<T>>);
     contextPosition(): number;
     contextSize(): number;
-    currentContext(): LocationPathEvaluation;
-    rootContext(): LocationPathEvaluation;
+    currentContext<U extends XPathNode>(this: EvaluationContext<U>): LocationPathEvaluation<U>;
+    rootContext<U extends XPathNode>(this: EvaluationContext<U>): LocationPathEvaluation<U>;
 }

package/dist/error/IncompatibleRuntimeEnvironmentError.d.ts

@@ -0,0 +1,2 @@
+export declare class IncompatibleRuntimeEnvironmentError extends Error {
+}

package/dist/evaluations/BooleanEvaluation.d.ts

@@ -1,13 +1,13 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';
-
-export declare class BooleanEvaluation extends ValueEvaluation<'BOOLEAN'> {
-    readonly context: LocationPathEvaluation;
+export declare class BooleanEvaluation<T extends XPathNode> extends ValueEvaluation<T, 'BOOLEAN'> {
+    readonly context: LocationPathEvaluation<T>;
     readonly value: boolean;
     readonly type = "BOOLEAN";
     readonly nodes: null;
     protected readonly booleanValue: boolean;
     protected readonly numberValue: number;
     protected readonly stringValue: string;
-    constructor(context: LocationPathEvaluation, value: boolean);
+    constructor(context: LocationPathEvaluation<T>, value: boolean);
 }

package/dist/evaluations/DateTimeLikeEvaluation.d.ts

@@ -1,14 +1,14 @@
 import { Temporal } from '@js-temporal/polyfill';
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';
-
 interface PrecomputedXPathValues {
     readonly booleanValue?: boolean;
     readonly numberValue?: number;
     readonly stringValue?: string;
 }
-export declare class DateTimeLikeEvaluation extends ValueEvaluation<'NUMBER'> {
-    readonly context: LocationPathEvaluation;
+export declare class DateTimeLikeEvaluation<T extends XPathNode> extends ValueEvaluation<T, 'NUMBER'> {
+    readonly context: LocationPathEvaluation<T>;
     protected dateTime: Temporal.ZonedDateTime | null;
     readonly type = "NUMBER";
     readonly nodes: null;
@@ -19,6 +19,6 @@ export declare class DateTimeLikeEvaluation extends ValueEvaluation<'NUMBER'> {
     protected readonly milliseconds: number;
     protected readonly dateString: string;
     protected readonly dateTimeString: string;
-    constructor(context: LocationPathEvaluation, dateTime: Temporal.ZonedDateTime | null, precomputedValues?: PrecomputedXPathValues);
+    constructor(context: LocationPathEvaluation<T>, dateTime: Temporal.ZonedDateTime | null, precomputedValues?: PrecomputedXPathValues);
 }
 export {};

package/dist/evaluations/Evaluation.d.ts

@@ -1,19 +1,19 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { EvaluationType } from './EvaluationType.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
-
-export interface Evaluation<Type extends EvaluationType = EvaluationType> extends Iterable<Evaluation<Type>> {
-    readonly context: LocationPathEvaluation;
+export interface Evaluation<T extends XPathNode, Type extends EvaluationType = EvaluationType> extends Iterable<Evaluation<T, Type>> {
+    readonly context: LocationPathEvaluation<T>;
     readonly type: Type;
-    first(): Evaluation<Type> | null;
-    values(): Iterable<Evaluation<Type>>;
-    eq(operand: Evaluation): boolean;
-    ne(operand: Evaluation): boolean;
-    lt(operand: Evaluation): boolean;
-    lte(operand: Evaluation): boolean;
-    gt(operand: Evaluation): boolean;
-    gte(operand: Evaluation): boolean;
+    first(): Evaluation<T, Type> | null;
+    values(): Iterable<Evaluation<T, Type>>;
+    eq(operand: Evaluation<T>): boolean;
+    ne(operand: Evaluation<T>): boolean;
+    lt(operand: Evaluation<T>): boolean;
+    lte(operand: Evaluation<T>): boolean;
+    gt(operand: Evaluation<T>): boolean;
+    gte(operand: Evaluation<T>): boolean;
     toBoolean(): boolean;
     toNumber(): number;
     toString(): string;
-    readonly nodes: Type extends 'NODE' ? Iterable<Node> : null;
+    readonly nodes: Type extends 'NODE' ? Iterable<T> : null;
 }

package/dist/evaluations/EvaluationType.d.ts

@@ -1,7 +1,9 @@
-export interface EvaluationTypes {
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
+export interface EvaluationTypes<T extends XPathNode> {
     readonly BOOLEAN: boolean;
-    readonly NODE: Node;
+    readonly NODE: T;
     readonly NUMBER: number;
     readonly STRING: string;
 }
-export type EvaluationType = keyof EvaluationTypes;
+export type PrimitiveEvaluationType = 'BOOLEAN' | 'NUMBER' | 'STRING';
+export type EvaluationType = PrimitiveEvaluationType | 'NODE';

package/dist/evaluations/LocationPathEvaluation.d.ts

@@ -1,61 +1,51 @@
 import { Temporal } from '@js-temporal/polyfill';
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
+import { AdapterDocument, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
+import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
 import { Context } from '../context/Context.ts';
-import { EvaluationContext, EvaluationContextTreeWalkers } from '../context/EvaluationContext.ts';
+import { EvaluationContext } from '../context/EvaluationContext.ts';
 import { Evaluator } from '../evaluator/Evaluator.ts';
+import { NamespaceResolver } from '../evaluator/NamespaceResolver.ts';
 import { FilterPathExpressionEvaluator } from '../evaluator/expression/FilterPathExpressionEvaluator.ts';
 import { LocationPathEvaluator } from '../evaluator/expression/LocationPathEvaluator.ts';
 import { LocationPathExpressionEvaluator } from '../evaluator/expression/LocationPathExpressionEvaluator.ts';
 import { FunctionLibraryCollection } from '../evaluator/functions/FunctionLibraryCollection.ts';
 import { NodeSetFunction } from '../evaluator/functions/NodeSetFunction.ts';
 import { AnyStep } from '../evaluator/step/Step.ts';
-import { ContextDocument, ContextNode, ContextParentNode } from '../lib/dom/types.ts';
 import { Reiterable } from '../lib/iterators/Reiterable.ts';
-import { XPathNamespaceResolverObject } from '../shared/interface.ts';
 import { Evaluation } from './Evaluation.ts';
 import { NodeEvaluation } from './NodeEvaluation.ts';
-
-type LocationPathParentContext = EvaluationContext | LocationPathEvaluation;
-type EvaluationComparator = (lhs: Evaluation, rhs: Evaluation) => boolean;
-export declare enum AxisName {
-    ANCESTOR = "ancestor",
-    ANCESTOR_OR_SELF = "ancestor-or-self",
-    ATTRIBUTE = "attribute",
-    CHILD = "child",
-    DESCENDANT = "descendant",
-    DESCENDANT_OR_SELF = "descendant-or-self",
-    FOLLOWING = "following",
-    FOLLOWING_SIBLING = "following-sibling",
-    NAMESPACE = "namespace",
-    PARENT = "parent",
-    PRECEDING = "preceding",
-    PRECEDING_SIBLING = "preceding-sibling",
-    SELF = "self"
-}
+type LocationPathParentContext<T extends XPathNode> = EvaluationContext<T> | LocationPathEvaluation<T>;
+type EvaluationComparator<T extends XPathNode> = (lhs: Evaluation<T>, rhs: Evaluation<T>) => boolean;
 interface LocationPathEvaluationOptions {
     readonly contextPosition?: number;
     contextSize?: () => number;
 }
-type ArbitraryNodesTemporaryCallee = FilterPathExpressionEvaluator | LocationPathEvaluator | NodeSetFunction<any>;
-export declare class LocationPathEvaluation implements Evaluation<'NODE'>, Context, Iterable<LocationPathEvaluation> {
-    readonly parentContext: LocationPathParentContext;
+type ArbitraryNodesTemporaryCallee = FilterPathExpressionEvaluator | LocationPathEvaluator | NodeSetFunction;
+type AssertLocationPathEvaluationInstance = <T extends XPathNode>(context: EvaluationContext<T>, value: unknown, message?: string) => asserts value is LocationPathEvaluation<T>;
+export declare class LocationPathEvaluation<T extends XPathNode> implements Evaluation<T, 'NODE'>, Context<T>, EvaluationContext<T>, Iterable<LocationPathEvaluation<T>> {
+    readonly parentContext: LocationPathParentContext<T>;
+    protected static isInstance<T extends XPathNode>(context: Context<T>, value: unknown): value is LocationPathEvaluation<T>;
+    static readonly assertInstance: AssertLocationPathEvaluationInstance;
+    readonly domProvider: XPathDOMProvider<T>;
     readonly type = "NODE";
-    protected readonly nodeEvaluations: Reiterable<NodeEvaluation>;
-    readonly evaluator: Evaluator;
-    readonly context: LocationPathEvaluation;
+    protected readonly nodeEvaluations: Reiterable<NodeEvaluation<T>>;
+    readonly evaluator: Evaluator<T>;
+    readonly context: LocationPathEvaluation<T>;
     /**
      * @see {@link Context.evaluationContextNode}
      */
-    readonly evaluationContextNode: ContextNode;
-    readonly contextDocument: ContextDocument;
-    readonly rootNode: ContextParentNode;
-    nodes: Iterable<ContextNode>;
-    get contextNodes(): IterableIterator<ContextNode>;
+    readonly evaluationContextNode: T;
+    readonly contextDocument: AdapterDocument<T>;
+    readonly rootNode: AdapterParentNode<T>;
+    private _nodes;
+    get nodes(): Iterable<T>;
+    get contextNodes(): IterableIterator<T>;
     protected computedContextSize: number | null;
     protected readonly optionsContextSize?: () => number;
     protected readonly initializedContextPosition: number;
     readonly functions: FunctionLibraryCollection;
-    readonly namespaceResolver: XPathNamespaceResolverObject;
-    readonly treeWalkers: EvaluationContextTreeWalkers;
+    readonly namespaceResolver: NamespaceResolver<T>;
     readonly timeZone: Temporal.TimeZone;
     /**
      * TODO: this is a temporary accommodation for these cases which are presently
@@ -67,48 +57,34 @@ export declare class LocationPathEvaluation implements Evaluation<'NODE'>, Conte
      * - Nodes filtered by predicate in {@link LocationPathExpression}. Such
      *   filtering almost certainly should be performed here, in {@link step}.
      */
-    static fromArbitraryNodes(currentContext: LocationPathParentContext, nodes: Iterable<ContextNode>, _temporaryCallee: ArbitraryNodesTemporaryCallee): LocationPathEvaluation;
-    static fromCurrentContext(evaluationContext: EvaluationContext): LocationPathEvaluation;
-    static fromRoot(parentContext: LocationPathParentContext): LocationPathEvaluation;
-    protected constructor(parentContext: LocationPathParentContext, contextNodes: Iterable<ContextNode>, options?: LocationPathEvaluationOptions);
+    static fromArbitraryNodes<T extends XPathNode>(currentContext: LocationPathParentContext<T>, nodes: Iterable<T>, _temporaryCallee: ArbitraryNodesTemporaryCallee): LocationPathEvaluation<T>;
+    static fromCurrentContext<T extends XPathNode>(evaluationContext: EvaluationContext<T>): LocationPathEvaluation<T>;
+    static fromRoot<T extends XPathNode>(parentContext: LocationPathParentContext<T>): LocationPathEvaluation<T>;
+    protected constructor(parentContext: LocationPathParentContext<T>, contextNodes: Iterable<T>, options?: LocationPathEvaluationOptions);
     [Symbol.iterator](): {
-        next: () => IteratorResult<LocationPathEvaluation>;
+        next: () => IteratorResult<LocationPathEvaluation<T>>;
     };
-    values(): Iterable<NodeEvaluation>;
+    values(): Iterable<NodeEvaluation<T>>;
     contextPosition(): number;
     contextSize(): number;
-    currentContext(): LocationPathEvaluation;
-    rootContext(): LocationPathEvaluation;
-    protected _first?: NodeEvaluation | null;
-    first(): NodeEvaluation | null;
+    currentContext<U extends XPathNode>(this: LocationPathEvaluation<U>): LocationPathEvaluation<U>;
+    rootContext<U extends XPathNode>(this: LocationPathEvaluation<U>): LocationPathEvaluation<U>;
+    protected _first?: NodeEvaluation<T> | null;
+    first(): NodeEvaluation<T> | null;
     protected _isEmpty: boolean | null;
     protected isEmpty(): boolean;
-    some(predicate: (evaluation: NodeEvaluation) => boolean): boolean;
+    some(predicate: (evaluation: NodeEvaluation<T>) => boolean): boolean;
     toBoolean(): boolean;
     toNumber(): number;
     toString(): string;
-    protected compare(comparator: EvaluationComparator, operand: Evaluation): boolean;
-    eq(operand: Evaluation): boolean;
-    ne(operand: Evaluation): boolean;
-    lt(operand: Evaluation): boolean;
-    lte(operand: Evaluation): boolean;
-    gt(operand: Evaluation): boolean;
-    gte(operand: Evaluation): boolean;
-    protected getTreeWalker(step: AnyStep): TreeWalker;
-    protected ancestor(step: AnyStep): Iterable<ContextNode>;
-    protected ancestorOrSelf(step: AnyStep): Iterable<ContextNode>;
-    protected attribute(): Iterable<ContextNode>;
-    protected child(step: AnyStep): Iterable<ContextNode>;
-    protected descendant(step: AnyStep): Iterable<ContextNode>;
-    protected descendantOrSelf(step: AnyStep): Iterable<ContextNode>;
-    protected following(step: AnyStep): Iterable<ContextNode>;
-    protected followingSibling(step: AnyStep): Iterable<ContextNode>;
-    protected namespace(): Iterable<ContextNode>;
-    protected parent(step: AnyStep): Iterable<ContextNode>;
-    protected preceding(step: AnyStep): Iterable<ContextNode>;
-    protected precedingSibling(step: AnyStep): Iterable<ContextNode>;
-    protected self(): Iterable<ContextNode>;
-    step(step: AnyStep): LocationPathEvaluation;
-    evaluateLocationPathExpression(expression: LocationPathExpressionEvaluator): LocationPathEvaluation;
+    protected compare(comparator: EvaluationComparator<T>, operand: Evaluation<T>): boolean;
+    eq(operand: Evaluation<T>): boolean;
+    ne(operand: Evaluation<T>): boolean;
+    lt(operand: Evaluation<T>): boolean;
+    lte(operand: Evaluation<T>): boolean;
+    gt(operand: Evaluation<T>): boolean;
+    gte(operand: Evaluation<T>): boolean;
+    step(step: AnyStep): LocationPathEvaluation<T>;
+    evaluateLocationPathExpression(expression: LocationPathExpressionEvaluator): LocationPathEvaluation<T>;
 }
 export {};

package/dist/evaluations/NodeEvaluation.d.ts

@@ -1,23 +1,23 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';
-
 interface NodeEvaluationComputedValues {
     readonly booleanValue: boolean;
     readonly isEmpty: boolean;
     readonly numberValue: number;
     readonly stringValue: string;
 }
-export declare class NodeEvaluation extends ValueEvaluation<'NODE'> {
-    readonly context: LocationPathEvaluation;
-    readonly value: Node;
+export declare class NodeEvaluation<T extends XPathNode> extends ValueEvaluation<T, 'NODE'> {
+    readonly context: LocationPathEvaluation<T>;
+    readonly value: T;
     readonly type = "NODE";
-    readonly nodes: Iterable<Node>;
+    readonly nodes: Iterable<T>;
     protected computedValues: NodeEvaluationComputedValues | null;
     protected get booleanValue(): boolean;
     protected get numberValue(): number;
     protected get stringValue(): string;
     get isEmpty(): boolean;
-    constructor(context: LocationPathEvaluation, value: Node);
+    constructor(context: LocationPathEvaluation<T>, value: T);
     protected computeValues(): NodeEvaluationComputedValues;
 }
 export {};

package/dist/evaluations/NumberEvaluation.d.ts

@@ -1,13 +1,13 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';
-
-export declare class NumberEvaluation extends ValueEvaluation<'NUMBER'> {
-    readonly context: LocationPathEvaluation;
+export declare class NumberEvaluation<T extends XPathNode> extends ValueEvaluation<T, 'NUMBER'> {
+    readonly context: LocationPathEvaluation<T>;
     readonly value: number;
     readonly type = "NUMBER";
     readonly nodes: null;
     protected readonly booleanValue: boolean;
     protected readonly numberValue: number;
     protected readonly stringValue: string;
-    constructor(context: LocationPathEvaluation, value: number);
+    constructor(context: LocationPathEvaluation<T>, value: number);
 }

package/dist/evaluations/StringEvaluation.d.ts

@@ -1,8 +1,8 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';
-
-export declare class StringEvaluation extends ValueEvaluation<'STRING'> {
-    readonly context: LocationPathEvaluation;
+export declare class StringEvaluation<T extends XPathNode> extends ValueEvaluation<T, 'STRING'> {
+    readonly context: LocationPathEvaluation<T>;
     readonly value: string;
     readonly isEmpty: boolean;
     readonly type = "STRING";
@@ -10,5 +10,5 @@ export declare class StringEvaluation extends ValueEvaluation<'STRING'> {
     protected readonly booleanValue: boolean;
     protected readonly numberValue: number;
     protected readonly stringValue: string;
-    constructor(context: LocationPathEvaluation, value: string, isEmpty?: boolean);
+    constructor(context: LocationPathEvaluation<T>, value: string, isEmpty?: boolean);
 }

package/dist/evaluations/ValueEvaluation.d.ts

@@ -1,12 +1,12 @@
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { Evaluation } from './Evaluation.ts';
 import { EvaluationType, EvaluationTypes } from './EvaluationType.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
-
-export declare abstract class ValueEvaluation<Type extends EvaluationType> implements Evaluation<Type> {
-    abstract readonly context: LocationPathEvaluation;
+export declare abstract class ValueEvaluation<T extends XPathNode, Type extends EvaluationType> implements Evaluation<T, Type> {
+    abstract readonly context: LocationPathEvaluation<T>;
     abstract readonly type: Type;
-    abstract readonly value: EvaluationTypes[Type];
-    abstract readonly nodes: Type extends 'NODE' ? Iterable<Node> : null;
+    abstract readonly value: EvaluationTypes<T>[Type];
+    abstract readonly nodes: Type extends 'NODE' ? Iterable<T> : null;
     protected abstract readonly booleanValue: boolean;
     protected abstract readonly numberValue: number;
     protected abstract readonly stringValue: string;
@@ -16,10 +16,10 @@ export declare abstract class ValueEvaluation<Type extends EvaluationType> imple
     toBoolean(): boolean;
     toNumber(): number;
     toString(): string;
-    eq(operand: Evaluation): boolean;
-    ne(operand: Evaluation): boolean;
-    lt(operand: Evaluation): boolean;
-    lte(operand: Evaluation): boolean;
-    gt(operand: Evaluation): boolean;
-    gte(operand: Evaluation): boolean;
+    eq(operand: Evaluation<T>): boolean;
+    ne(operand: Evaluation<T>): boolean;
+    lt(operand: Evaluation<T>): boolean;
+    lte(operand: Evaluation<T>): boolean;
+    gt(operand: Evaluation<T>): boolean;
+    gte(operand: Evaluation<T>): boolean;
 }

package/dist/evaluator/DefaultEvaluator.d.ts

@@ -0,0 +1,16 @@
+import { DefaultDOMAdapterNode } from '../adapter/defaults.ts';
+import { EvaluatorOptions, Evaluator } from './Evaluator.ts';
+export interface DefaultEvaluatorOptions extends Omit<EvaluatorOptions<DefaultDOMAdapterNode>, 'domAdapter'> {
+}
+/**
+ * The default {@link Evaluator} implementation is suitable for use in a browser
+ * runtime, or in a browser DOM compatibility environment.
+ *
+ * @todo Give this a more descriptive name? Make {@link Evaluator} the actual
+ * default, and give {@link Evaluator} itself a more descriptive name? I.e.
+ * describing the fact that it supports—and requires—an explicit
+ * {@link XPathDOMAdapter} option.
+ */
+export declare class DefaultEvaluator extends Evaluator<DefaultDOMAdapterNode> {
+    constructor(options?: DefaultEvaluatorOptions);
+}

package/dist/evaluator/Evaluator.d.ts

@@ -1,42 +1,48 @@
 import { Temporal } from '@js-temporal/polyfill';
-import { EvaluationContextOptions } from '../context/EvaluationContext.ts';
-import { AnyParentNode } from '../lib/dom/types.ts';
-import { AnyXPathEvaluator, XPathNSResolver, XPathResultType } from '../shared/index.ts';
+import { UnwrapAdapterNode } from '../adapter/interface/XPathCustomUnwrappableNode.ts';
+import { XPathDOMAdapter } from '../adapter/interface/XPathDOMAdapter.ts';
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
+import { AdapterElement, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
+import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
+import { EvaluationContext } from '../context/EvaluationContext.ts';
 import { ExpressionParser, ParseOptions } from '../static/grammar/ExpressionParser.ts';
 import { FunctionLibraryCollection } from './functions/FunctionLibraryCollection.ts';
-import { ResultTypes } from './result/ResultType.ts';
-
-export interface EvaluatorOptions {
+import { XPathEvaluationResult, XPathEvaluationResultType } from './result/XPathEvaluationResult.ts';
+type EvaluatorRootNodeOption<T extends XPathNode> = AdapterParentNode<T> | UnwrapAdapterNode<AdapterParentNode<T>>;
+export interface EvaluatorOptions<T extends XPathNode> {
+    readonly domAdapter: XPathDOMAdapter<T>;
     readonly functions?: FunctionLibraryCollection;
     readonly parseOptions?: ParseOptions;
-    readonly rootNode?: AnyParentNode | null | undefined;
+    readonly rootNode?: EvaluatorRootNodeOption<T> | null | undefined;
     readonly timeZoneId?: string | undefined;
 }
-export interface EvaluatorConvenienceMethodOptions {
-    readonly contextNode?: Node;
+export interface EvaluatorConvenienceMethodOptions<T extends XPathNode> {
+    readonly contextNode?: T | UnwrapAdapterNode<T>;
 }
-export interface EvaluatorNodeConvenienceMethodOptions<AssertExists extends boolean = false> extends EvaluatorConvenienceMethodOptions {
+export interface EvaluatorNodeConvenienceMethodOptions<T extends XPathNode, AssertExists extends boolean = false> extends EvaluatorConvenienceMethodOptions<T> {
     readonly assertExists?: AssertExists;
 }
-type EvaluatedNode<AssertExists extends boolean, T extends Node> = AssertExists extends true ? T : T | null;
-export declare class Evaluator implements AnyXPathEvaluator {
+type EvaluatedNode<T extends XPathNode, U extends T | UnwrapAdapterNode<T>, AssertExists extends boolean> = AssertExists extends true ? U : U | null;
+export declare class Evaluator<T extends XPathNode> {
+    readonly domProvider: XPathDOMProvider<T>;
     protected readonly parser: ExpressionParser;
     readonly functions: FunctionLibraryCollection;
     readonly parseOptions: ParseOptions;
-    readonly resultTypes: ResultTypes;
-    readonly rootNodeDocument: Document | XMLDocument | null;
-    readonly rootNode: AnyParentNode | null;
-    readonly sharedContextOptions: Partial<EvaluationContextOptions>;
+    readonly rootNode: AdapterParentNode<T> | null;
     readonly timeZone: Temporal.TimeZone;
-    constructor(options?: EvaluatorOptions);
-    evaluate(expression: string, contextNode: Node, namespaceResolver: XPathNSResolver | null, resultType: XPathResultType | null): import('./result/BooleanResult.ts').BooleanResult | import('./result/NodeSetResult.ts').NodeSetSnapshotResult | import('./result/NodeSetResult.ts').NodeSetIteratorResult | import('./result/NumberResult.ts').NumberResult | import('./result/StringResult.ts').StringResult;
-    protected getContextNode(options: EvaluatorConvenienceMethodOptions): Node;
-    evaluateBoolean(expression: string, options?: EvaluatorConvenienceMethodOptions): boolean;
-    evaluateNumber(expression: string, options?: EvaluatorConvenienceMethodOptions): number;
-    evaluateString(expression: string, options?: EvaluatorConvenienceMethodOptions): string;
-    evaluateNode<T extends Node, AssertExists extends boolean = false>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions<AssertExists>): EvaluatedNode<AssertExists, T>;
-    evaluateElement<AssertExists extends boolean = false>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions<AssertExists>): EvaluatedNode<AssertExists, Element>;
-    evaluateNonNullElement(expression: string, options?: Omit<EvaluatorNodeConvenienceMethodOptions<true>, 'assertExists'>): Element;
-    evaluateNodes<T extends Node>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions): T[];
+    constructor(options: EvaluatorOptions<T>);
+    /**
+     * @package - exposed for testing
+     */
+    getEvaluationContext(contextNode: T | UnwrapAdapterNode<T>, namespaceResolver: Extract<T, XPathNSResolver> | XPathNSResolver | null): EvaluationContext<T>;
+    evaluate(expression: string, contextNode: T | UnwrapAdapterNode<T>, namespaceResolver: XPathNSResolver | null, resultType: XPathEvaluationResultType | null): XPathEvaluationResult<T>;
+    protected getContextNode(options: EvaluatorConvenienceMethodOptions<T>): T;
+    evaluateBoolean(expression: string, options?: EvaluatorConvenienceMethodOptions<T>): boolean;
+    evaluateNumber(expression: string, options?: EvaluatorConvenienceMethodOptions<T>): number;
+    evaluateString(expression: string, options?: EvaluatorConvenienceMethodOptions<T>): string;
+    evaluateNode<U extends T | UnwrapAdapterNode<T> = T, AssertExists extends boolean = false>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions<T, AssertExists>): EvaluatedNode<T, U, AssertExists>;
+    evaluateElement<U extends AdapterElement<T> | UnwrapAdapterNode<AdapterElement<T>> = AdapterElement<T>, AssertExists extends boolean = false>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions<T, AssertExists>): EvaluatedNode<T, U, AssertExists>;
+    evaluateNonNullElement<U extends AdapterElement<T> | UnwrapAdapterNode<AdapterElement<T>> = AdapterElement<T>>(expression: string, options?: Omit<EvaluatorNodeConvenienceMethodOptions<T, true>, 'assertExists'>): U;
+    evaluateNodes<U extends T | UnwrapAdapterNode<T>>(expression: string, options?: EvaluatorNodeConvenienceMethodOptions<T>): U[];
 }
 export {};

package/dist/evaluator/NamespaceResolver.d.ts

@@ -1,7 +1,8 @@
 import { ENKETO_NAMESPACE_URI, ENKETO_PREFIX, FN_NAMESPACE_URI, FN_PREFIX, HTML_NAMESPACE_URI, HTML_PREFIX, JAVAROSA_NAMESPACE_URI, JAVAROSA_PREFIX, ODK_NAMESPACE_URI, ODK_PREFIX, OPENROSA_XFORMS_NAMESPACE_URI, OPENROSA_XFORMS_PREFIX, XFORMS_NAMESPACE_URI, XFORMS_PREFIX, XHTML_NAMESPACE_URI, XML_NAMESPACE_URI, XML_PREFIX, XMLNS_NAMESPACE_URI, XMLNS_PREFIX } from '../../../common/src/constants/xmlns.ts';
-import { ContextParentNode } from '../lib/dom/types.ts';
-import { XPathNamespaceResolverObject } from '../shared/interface.ts';
-
+import { UnwrapAdapterNode } from '../adapter/interface/XPathCustomUnwrappableNode.ts';
+import { XPathNode } from '../adapter/interface/XPathNode.ts';
+import { AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
+import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
 export { ENKETO_NAMESPACE_URI, ENKETO_PREFIX, FN_NAMESPACE_URI, FN_PREFIX, HTML_NAMESPACE_URI, HTML_PREFIX, JAVAROSA_NAMESPACE_URI, JAVAROSA_PREFIX, ODK_NAMESPACE_URI, ODK_PREFIX, OPENROSA_XFORMS_NAMESPACE_URI, OPENROSA_XFORMS_PREFIX, XFORMS_NAMESPACE_URI, XFORMS_PREFIX, XHTML_NAMESPACE_URI, XML_NAMESPACE_URI, XML_PREFIX, XMLNS_NAMESPACE_URI, XMLNS_PREFIX, };
 export interface StaticNamespaces<DefaultPrefix extends string, DefaultURI extends string, Mapping extends Record<string, string>> {
     get<Key extends string | null>(key: Key): Key extends null ? DefaultURI : Key extends DefaultPrefix ? DefaultURI : Key extends keyof Mapping ? Mapping[Key] : undefined;
@@ -30,13 +31,18 @@ export declare const staticNamespaces: StaticNamespaces<"xf", "http://www.w3.org
     readonly xml: "http://www.w3.org/XML/1998/namespace";
     readonly xmlns: "http://www.w3.org/2000/xmlns/";
 }>;
-export declare class NamespaceResolver implements XPathNamespaceResolverObject {
-    protected readonly rootNode: ContextParentNode;
-    protected readonly referenceNode?: (XPathNamespaceResolverObject | null) | undefined;
-    protected readonly contextResolver: XPathNamespaceResolverObject;
-    constructor(rootNode: ContextParentNode, referenceNode?: (XPathNamespaceResolverObject | null) | undefined);
-    protected lookupNodeNamespaceURI: (node: Node, prefix: string | null) => string | null;
-    protected lookupStaticNamespaceURI: (prefix: string | null) => "http://www.w3.org/2002/xforms" | null;
+type XPathNSResolverFunction = (prefix: string | null) => string | null;
+interface XPathNSResolverObject {
+    readonly lookupNamespaceURI: XPathNSResolverFunction;
+}
+export declare class NamespaceResolver<T extends XPathNode> implements XPathNSResolverObject {
+    protected readonly domProvider: XPathDOMProvider<T>;
+    protected readonly rootNode: AdapterParentNode<T>;
+    protected readonly referenceNode?: (T | null) | undefined;
+    private static isInstance;
+    static from<T extends XPathNode>(domProvider: XPathDOMProvider<T>, rootNode: AdapterParentNode<T> | UnwrapAdapterNode<AdapterParentNode<T>>, referenceNode?: T | UnwrapAdapterNode<T> | null, contextResolver?: XPathNSResolver | null): NamespaceResolver<T>;
+    protected readonly contextResolver: XPathNSResolverFunction;
+    private constructor();
     /**
      * Note: while it is likely consistent with the **spec** to resolve a `null`
      * prefix, it's not typical in a browser environment for the resolver to be

package/dist/evaluator/expression/AbsoluteLocationPathExpressionEvaluator.d.ts

@@ -1,7 +1,6 @@
 import { AbsoluteLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
 import { LocationPathEvaluator } from './LocationPathEvaluator.ts';
-
 export declare class AbsoluteLocationPathExpressionEvaluator extends LocationPathEvaluator implements ExpressionEvaluator {
     readonly syntaxNode: AbsoluteLocationPathNode;
     constructor(syntaxNode: AbsoluteLocationPathNode);

package/dist/evaluator/expression/BinaryExpressionEvaluator.d.ts

@@ -1,12 +1,12 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { AnyBinaryExprNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
-
 export declare abstract class BinaryExpressionEvaluator<Node extends AnyBinaryExprNode> implements ExpressionEvaluator {
     readonly syntaxNode: Node;
     readonly lhs: ExpressionEvaluator;
     readonly rhs: ExpressionEvaluator;
     constructor(syntaxNode: Node);
-    abstract evaluate(context: EvaluationContext): Evaluation;
+    abstract evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
 }

package/dist/evaluator/expression/BooleanBinaryExpressionEvaluator.d.ts

@@ -1,18 +1,18 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { BooleanEvaluation } from '../../evaluations/BooleanEvaluation.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { AndExprNode, EqExprNode, GtExprNode, GteExprNode, LtExprNode, LteExprNode, NeExprNode, OrExprNode } from '../../static/grammar/SyntaxNode.ts';
 import { BinaryExpressionEvaluator } from './BinaryExpressionEvaluator.ts';
-
 type BooleanBinaryExprNode = AndExprNode | EqExprNode | GteExprNode | GtExprNode | LteExprNode | LtExprNode | NeExprNode | OrExprNode;
 type BooleanOperator<Node extends BooleanBinaryExprNode> = Node extends AndExprNode ? 'and' : Node extends EqExprNode ? 'eq' : Node extends GtExprNode ? 'gt' : Node extends GteExprNode ? 'gte' : Node extends LtExprNode ? 'lt' : Node extends LteExprNode ? 'lte' : Node extends NeExprNode ? 'ne' : Node extends OrExprNode ? 'or' : never;
 type CompareOperator = 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'ne';
 export declare class BooleanBinaryExpressionEvaluator<Node extends BooleanBinaryExprNode> extends BinaryExpressionEvaluator<Node> {
     readonly operator: BooleanOperator<Node>;
     constructor(syntaxNode: Node);
-    protected and(context: EvaluationContext): Evaluation;
-    protected or(context: EvaluationContext): Evaluation;
-    protected compare(context: EvaluationContext, operator: CompareOperator): BooleanEvaluation;
-    evaluate(context: EvaluationContext): Evaluation;
+    protected and<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
+    protected or<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
+    protected compare<T extends XPathNode>(context: EvaluationContext<T>, operator: CompareOperator): BooleanEvaluation<T>;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
 }
 export {};