@getodk/xpath 0.2.1 → 0.3.0

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { FunctionCallNode } from '../../static/grammar/SyntaxNode.ts';
@@ -11,6 +12,6 @@ export declare class FunctionCallExpressionEvaluator implements ExpressionEvalua
     readonly name: FunctionCallName;
     readonly argumentExpressions: readonly ExpressionEvaluator[];
     constructor(syntaxNode: FunctionCallNode);
-    evaluate(context: EvaluationContext): Evaluation;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { AbsoluteLocationPathNode, FilterPathExprNode, RelativeLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
 import { PathExprSteps } from '../step/Step.ts';
@@ -18,6 +19,6 @@ export declare class LocationPathEvaluator extends LocationPathExpressionEvaluat
     protected isSelf: boolean;
     protected steps: PathExprSteps;
     constructor(syntaxNode: LocationPathNode, options: LocationPathExpressionOptions);
-    evaluateNodes(context: EvaluationContext): Iterable<Node>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
 }
 export {};

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

@@ -1,8 +1,9 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { ExpressionEvaluator, ExpressionNode } from './ExpressionEvaluator.ts';
 export declare abstract class LocationPathExpressionEvaluator implements ExpressionEvaluator {
     abstract readonly syntaxNode: ExpressionNode;
-    abstract evaluateNodes(context: EvaluationContext): Iterable<Node>;
-    evaluate(context: EvaluationContext): Evaluation<'NODE'>;
+    abstract evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T, 'NODE'>;
 }

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { NumberEvaluation } from '../../evaluations/NumberEvaluation.ts';
 import { ExpressionEvaluator, ExpressionNode } from './ExpressionEvaluator.ts';
@@ -5,6 +6,6 @@ export declare abstract class NumberExpressionEvaluator<ConstValue extends numbe
     protected readonly constValue: ConstValue;
     constructor(constValue: ConstValue);
     abstract readonly syntaxNode: ExpressionNode;
-    abstract evaluateNumber(context: EvaluationContext): number;
-    evaluate(context: EvaluationContext): NumberEvaluation;
+    abstract evaluateNumber<T extends XPathNode>(context: EvaluationContext<T>): number;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): NumberEvaluation<T>;
 }

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { NumberEvaluation } from '../../evaluations/NumberEvaluation.ts';
 import { AdditionExprNode, DivisionExprNode, ModuloExprNode, MultiplicationExprNode, SubtractionExprNode } from '../../static/grammar/SyntaxNode.ts';
@@ -7,6 +8,6 @@ type NumericOperation<Node extends NumericBinaryExprNode> = Node extends Additio
 export declare class NumericBinaryExpressionEvaluator<Node extends NumericBinaryExprNode> extends BinaryExpressionEvaluator<Node> {
     readonly operation: NumericOperation<Node>;
     constructor(node: Node);
-    evaluate(context: EvaluationContext): NumberEvaluation;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): NumberEvaluation<T>;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { StringEvaluation } from '../../evaluations/StringEvaluation.ts';
 import { ExpressionEvaluator, ExpressionNode } from './ExpressionEvaluator.ts';
@@ -5,6 +6,6 @@ export declare abstract class StringExpressionEvaluator<ConstValue extends strin
     protected readonly constValue: ConstValue;
     constructor(constValue: ConstValue);
     abstract readonly syntaxNode: ExpressionNode;
-    abstract evaluateString(context: EvaluationContext): string;
-    evaluate(context: EvaluationContext): StringEvaluation;
+    abstract evaluateString<T extends XPathNode>(context: EvaluationContext<T>): string;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): StringEvaluation<T>;
 }

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { UnaryExprNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
@@ -6,5 +7,5 @@ export declare class UnaryExpressionEvaluator extends NumberExpressionEvaluator
     readonly syntaxNode: UnaryExprNode;
     readonly operand: ExpressionEvaluator;
     constructor(syntaxNode: UnaryExprNode);
-    evaluateNumber(context: EvaluationContext): number;
+    evaluateNumber<T extends XPathNode>(context: EvaluationContext<T>): number;
 }

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

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { UnionExprNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
@@ -7,5 +8,5 @@ export declare class UnionExpressionEvaluator extends LocationPathExpressionEval
     readonly lhs: ExpressionEvaluator;
     readonly rhs: ExpressionEvaluator;
     constructor(syntaxNode: UnionExprNode);
-    evaluateNodes(context: EvaluationContext): Iterable<Node>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
 }

package/dist/evaluator/functions/BooleanFunction.d.ts

@@ -1,5 +1,5 @@
 import { FunctionSignature } from './FunctionImplementation.ts';
 import { TypedFunctionCallable, TypedFunctionImplementation } from './TypedFunctionImplementation.ts';
-export declare class BooleanFunction<Length extends number> extends TypedFunctionImplementation<boolean, Length> {
-    constructor(localName: string, signature: FunctionSignature<Length>, call: TypedFunctionCallable<boolean>);
+export declare class BooleanFunction extends TypedFunctionImplementation<boolean> {
+    constructor(localName: string, signature: FunctionSignature, call: TypedFunctionCallable<boolean>);
 }

package/dist/evaluator/functions/FunctionAlias.d.ts

@@ -1,4 +1,4 @@
 import { FunctionImplementation } from './FunctionImplementation.ts';
-export declare class FunctionAlias<Length extends number> extends FunctionImplementation<Length> {
-    constructor(localName: string, baseImplementation: FunctionImplementation<Length>);
+export declare class FunctionAlias extends FunctionImplementation {
+    constructor(localName: string, baseImplementation: FunctionImplementation);
 }

package/dist/evaluator/functions/FunctionImplementation.d.ts

@@ -1,7 +1,7 @@
-import { IterableReadonlyTuple } from '../../../../common/types/collections/IterableReadonlyTuple.ts';
-import { Context } from '../../context/Context.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
+import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
-import { EvaluationType } from '../../evaluations/EvaluationType.ts';
+import { EvaluationType, PrimitiveEvaluationType } from '../../evaluations/EvaluationType.ts';
 import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
 export declare class UnknownFunctionError extends Error {
     constructor(functionName: string);
@@ -15,25 +15,26 @@ export interface Parameter {
     readonly arityType: ParameterArityType;
     readonly typeHint?: ParameterTypeHint;
 }
-export type FunctionSignature<Length extends number> = IterableReadonlyTuple<Parameter, Length>;
+export type FunctionSignature = readonly Parameter[];
+export type ArgumentEvaluation<T extends XPathNode> = Evaluation<any, PrimitiveEvaluationType> | Evaluation<T, EvaluationType>;
 export interface EvaluableArgument {
-    evaluate(context: Context): Evaluation<EvaluationType>;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): ArgumentEvaluation<T>;
 }
-export type ValidArguments<Arguments extends readonly EvaluableArgument[], IsValid extends boolean> = [true] extends [IsValid] ? Arguments : never;
+type ValidArguments<Arguments extends readonly EvaluableArgument[], IsValid> = [
+    true
+] extends [IsValid] ? Arguments : never;
 interface FunctionArity {
     readonly min: number;
     readonly max: number;
 }
-export type FunctionCallable = <Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation, args: Arguments) => Evaluation;
-export declare class FunctionImplementation<Length extends number> {
+export type FunctionCallable = <T extends XPathNode, Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Arguments) => Evaluation<T>;
+export declare class FunctionImplementation {
     readonly localName: string;
-    readonly signature: FunctionSignature<Length>;
+    readonly signature: FunctionSignature;
     readonly arity: FunctionArity;
     protected readonly callable: FunctionCallable;
-    constructor(localName: string, signature: FunctionSignature<Length>, runtimeImplementation: FunctionCallable | FunctionImplementation<any>);
-    call(context: LocationPathEvaluation, args: readonly EvaluableArgument[]): Evaluation;
+    constructor(localName: string, signature: FunctionSignature, runtimeImplementation: FunctionCallable | FunctionImplementation);
+    call<T extends XPathNode, Args extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Args): Evaluation<T>;
     protected validateArguments<Arguments extends readonly EvaluableArgument[]>(args: Arguments): asserts args is ValidArguments<Arguments, true>;
 }
-export interface AnyFunctionImplementation extends FunctionImplementation<number> {
-}
 export {};

package/dist/evaluator/functions/FunctionLibrary.d.ts

@@ -1,21 +1,22 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
-import { AnyFunctionImplementation, EvaluableArgument, FunctionImplementation } from './FunctionImplementation.ts';
+import { EvaluableArgument, FunctionImplementation } from './FunctionImplementation.ts';
 type NamespaceURI = string | null;
 type LocalName = string;
 interface QualifiedName {
     readonly namespaceURI: NamespaceURI;
     readonly localName: LocalName;
 }
-export interface LibraryFunction extends AnyFunctionImplementation {
+export interface LibraryFunction extends FunctionImplementation {
     readonly qualifiedName: QualifiedName;
 }
 export declare class FunctionLibrary {
     readonly namespaceURI: string;
     protected readonly implementations: Map<LocalName, LibraryFunction>;
-    constructor(namespaceURI: string, entries: readonly AnyFunctionImplementation[]);
+    constructor(namespaceURI: string, entries: readonly FunctionImplementation[]);
     has(localName: LocalName): boolean;
-    call(localName: LocalName, context: LocationPathEvaluation, args: readonly EvaluableArgument[]): Evaluation;
-    getImplementation(localName: LocalName): FunctionImplementation<number> | null;
+    call<T extends XPathNode>(localName: LocalName, context: LocationPathEvaluation<T>, args: readonly EvaluableArgument[]): Evaluation<T>;
+    getImplementation(localName: LocalName): FunctionImplementation | null;
 }
 export {};

package/dist/evaluator/functions/FunctionLibraryCollection.d.ts

@@ -1,3 +1,4 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Context } from '../../context/Context.ts';
 import { FunctionImplementation } from './FunctionImplementation.ts';
 import { FunctionLibrary } from './FunctionLibrary.ts';
@@ -35,7 +36,7 @@ export declare class FunctionLibraryCollection {
     protected readonly defaultFunctionLibraries: readonly FunctionLibrary[];
     protected readonly namespacedFunctionLibraries: ReadonlyMap<string, FunctionLibrary>;
     constructor(functionLibraries: Iterable<FunctionLibrary>, options?: FunctionLibraryCollectionOptions);
-    getDefaultImplementation(localName: string): FunctionImplementation<number> | null;
-    getImplementation(context: Context, name: FunctionNameLookup): FunctionImplementation<any> | null;
+    getDefaultImplementation(localName: string): FunctionImplementation | null;
+    getImplementation<T extends XPathNode>(context: Context<T>, name: FunctionNameLookup): FunctionImplementation | null;
 }
 export {};

package/dist/evaluator/functions/NodeSetFunction.d.ts

@@ -1,6 +1,7 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
 import { EvaluableArgument, FunctionSignature, FunctionImplementation } from './FunctionImplementation.ts';
-export type NodeSetFunctionCallable = <Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation, args: Arguments) => Iterable<Node>;
-export declare class NodeSetFunction<Length extends number> extends FunctionImplementation<Length> {
-    constructor(localName: string, signature: FunctionSignature<Length>, call: NodeSetFunctionCallable);
+export type NodeSetFunctionCallable = <T extends XPathNode, Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Arguments) => Iterable<T>;
+export declare class NodeSetFunction extends FunctionImplementation {
+    constructor(localName: string, signature: FunctionSignature, call: NodeSetFunctionCallable);
 }

package/dist/evaluator/functions/NumberFunction.d.ts

@@ -1,5 +1,5 @@
 import { FunctionSignature } from './FunctionImplementation.ts';
 import { TypedFunctionCallable, TypedFunctionImplementation } from './TypedFunctionImplementation.ts';
-export declare class NumberFunction<Length extends number> extends TypedFunctionImplementation<number, Length> {
-    constructor(localName: string, signature: FunctionSignature<Length>, call: TypedFunctionCallable<number>);
+export declare class NumberFunction extends TypedFunctionImplementation<number> {
+    constructor(localName: string, signature: FunctionSignature, call: TypedFunctionCallable<number>);
 }

package/dist/evaluator/functions/StringFunction.d.ts

@@ -1,5 +1,5 @@
 import { FunctionSignature } from './FunctionImplementation.ts';
 import { TypedFunctionCallable, TypedFunctionImplementation } from './TypedFunctionImplementation.ts';
-export declare class StringFunction<Length extends number> extends TypedFunctionImplementation<string, Length> {
-    constructor(localName: string, signature: FunctionSignature<Length>, call: TypedFunctionCallable<string>);
+export declare class StringFunction extends TypedFunctionImplementation<string> {
+    constructor(localName: string, signature: FunctionSignature, call: TypedFunctionCallable<string>);
 }

package/dist/evaluator/functions/TypedFunctionImplementation.d.ts

@@ -1,7 +1,9 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Evaluation } from '../../evaluations/Evaluation';
 import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
 import { EvaluableArgument, FunctionSignature, FunctionImplementation } from './FunctionImplementation.ts';
-export type TypedFunctionCallable<Type> = <Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation, args: Arguments) => Type;
-export declare class TypedFunctionImplementation<Type, Length extends number> extends FunctionImplementation<Length> {
-    protected constructor(localName: string, TypedResult: new (context: LocationPathEvaluation, value: Type) => Evaluation, signature: FunctionSignature<Length>, call: TypedFunctionCallable<Type>);
+export type TypedFunctionCallable<R> = <T extends XPathNode, Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Arguments) => R;
+export type TypedFunctionResultFactory<R> = <T extends XPathNode>(context: LocationPathEvaluation<T>, value: R) => Evaluation<T>;
+export declare abstract class TypedFunctionImplementation<R> extends FunctionImplementation {
+    protected constructor(localName: string, signature: FunctionSignature, call: TypedFunctionCallable<R>, resultFactory: TypedFunctionResultFactory<R>);
 }

package/dist/evaluator/result/BaseResult.d.ts

@@ -1,11 +1,9 @@
-declare const NODE_SET_RESULT_TYPE = -1;
-export type NodeSetResultType = typeof NODE_SET_RESULT_TYPE;
-export type PrimitiveResultType = BaseResult['BOOLEAN_TYPE'] | BaseResult['NUMBER_TYPE'] | BaseResult['STRING_TYPE'];
-type BaseResultType = NodeSetResultType | PrimitiveResultType;
-export declare abstract class BaseResult {
-    protected abstract readonly type: BaseResultType;
-    protected abstract readonly nodes: Iterable<Node> | null;
-    abstract readonly isIntermediateResult: boolean;
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
+import { ANY_UNORDERED_NODE_TYPE, BOOLEAN_TYPE, FIRST_ORDERED_NODE_TYPE, NUMBER_TYPE, ORDERED_NODE_ITERATOR_TYPE, ORDERED_NODE_SNAPSHOT_TYPE, STRING_TYPE, UNORDERED_NODE_ITERATOR_TYPE, UNORDERED_NODE_SNAPSHOT_TYPE, XPathEvaluationResult, XPathEvaluationResultType } from './XPathEvaluationResult.ts';
+export type PrimitiveResultType = BOOLEAN_TYPE | NUMBER_TYPE | STRING_TYPE;
+export type NodeSetResultType = ANY_UNORDERED_NODE_TYPE | FIRST_ORDERED_NODE_TYPE | ORDERED_NODE_ITERATOR_TYPE | ORDERED_NODE_SNAPSHOT_TYPE | UNORDERED_NODE_ITERATOR_TYPE | UNORDERED_NODE_SNAPSHOT_TYPE;
+declare const NUMBER_TYPE: 1, STRING_TYPE: 2, BOOLEAN_TYPE: 3, UNORDERED_NODE_ITERATOR_TYPE: 4, ORDERED_NODE_ITERATOR_TYPE: 5, UNORDERED_NODE_SNAPSHOT_TYPE: 6, ORDERED_NODE_SNAPSHOT_TYPE: 7, ANY_UNORDERED_NODE_TYPE: 8, FIRST_ORDERED_NODE_TYPE: 9;
+export declare abstract class BaseResult<T extends XPathNode> implements XPathEvaluationResult<T> {
     static readonly ANY_TYPE: 0;
     static readonly NUMBER_TYPE: 1;
     static readonly STRING_TYPE: 2;
@@ -26,9 +24,15 @@ export declare abstract class BaseResult {
     readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
     readonly ANY_UNORDERED_NODE_TYPE: 8;
     readonly FIRST_ORDERED_NODE_TYPE: 9;
-    protected static readonly NODE_SET_RESULT_TYPE = -1;
+    protected abstract readonly nodes: Iterable<T> | null;
+    abstract readonly resultType: XPathEvaluationResultType;
+    abstract readonly invalidIteratorState: boolean;
+    abstract readonly singleNodeValue: T | null;
+    abstract readonly snapshotLength: number;
     abstract readonly booleanValue: boolean;
     abstract readonly numberValue: number;
     abstract readonly stringValue: string;
+    abstract iterateNext(): T | null;
+    abstract snapshotItem(index: number): T | null;
 }
 export {};

package/dist/evaluator/result/BooleanResult.d.ts

@@ -1,12 +1,12 @@
-import { XPathResult } from '../../shared/index.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { PrimitiveResult } from './PrimitiveResult.ts';
-export declare class BooleanResult extends PrimitiveResult implements XPathResult {
-    readonly isIntermediateResult = false;
-    protected readonly type: 3;
+import { XPathEvaluationResult } from './XPathEvaluationResult.ts';
+export declare class BooleanResult<T extends XPathNode> extends PrimitiveResult<T> implements XPathEvaluationResult<T> {
     protected readonly nodes: null;
+    readonly resultType: 3;
     readonly booleanValue: boolean;
     readonly numberValue: number;
     readonly stringValue: string;
-    constructor(evaluation: Evaluation);
+    constructor(evaluation: Evaluation<T>);
 }

package/dist/evaluator/result/NodeSetResult.d.ts

@@ -1,54 +1,50 @@
-import { XPathResult, XPathResultType } from '../../shared/index.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
+import { XPathDOMProvider } from '../../adapter/xpathDOMProvider.ts';
 import { Reiterable } from '../../lib/iterators/index.ts';
 import { NodeSetResultType, BaseResult } from './BaseResult.ts';
+import { XPathEvaluationResult } from './XPathEvaluationResult.ts';
 interface ComputedNodeSetResult {
     readonly computedBooleanValue: boolean;
     readonly computedNumberValue: number;
     readonly computedStringValue: string;
 }
-export declare abstract class NodeSetResult extends BaseResult implements XPathResult {
-    protected readonly value: Iterable<Node>;
-    readonly isIntermediateResult: boolean;
-    protected readonly type: NodeSetResultType;
-    protected readonly nodes: Iterable<Node>;
+export declare abstract class NodeSetResult<T extends XPathNode> extends BaseResult<T> implements XPathEvaluationResult<T> {
+    protected readonly domProvider: XPathDOMProvider<T>;
+    protected readonly value: Iterable<T>;
+    protected readonly nodes: Iterable<T>;
     protected computedBooleanValue: boolean | null;
     protected computedNumberValue: number | null;
     protected computedStringValue: string | null;
     get booleanValue(): boolean;
     get numberValue(): number;
     get stringValue(): string;
-    protected computedSnapshotValue: readonly Node[] | null;
-    abstract readonly resultType: XPathResultType;
-    abstract readonly invalidIteratorState: boolean;
-    abstract readonly singleNodeValue: Node | null;
-    abstract readonly snapshotLength: number;
-    constructor(value: Iterable<Node>);
+    protected computedSnapshotValue: readonly T[] | null;
+    abstract readonly resultType: NodeSetResultType;
+    constructor(domProvider: XPathDOMProvider<T>, value: Iterable<T>);
     protected compute(): ComputedNodeSetResult;
-    abstract iterateNext(): Node | null;
-    abstract snapshotItem(index: number): Node | null;
 }
-export declare class NodeSetSnapshotResult extends NodeSetResult {
-    readonly resultType: XPathResultType;
-    readonly snapshot: readonly Node[];
-    readonly snapshotIterator: IterableIterator<Node>;
+export declare class NodeSetSnapshotResult<T extends XPathNode> extends NodeSetResult<T> implements XPathEvaluationResult<T> {
+    readonly resultType: NodeSetResultType;
+    readonly snapshot: readonly T[];
+    readonly snapshotIterator: IterableIterator<T>;
     readonly snapshotLength: number;
     readonly invalidIteratorState: boolean;
-    readonly singleNodeValue: Node | null;
-    constructor(resultType: XPathResultType, nodes: Iterable<Node>);
-    iterateNext(): Node | null;
-    snapshotItem(index: number): Node | null;
+    readonly singleNodeValue: T | null;
+    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: Iterable<T>);
+    iterateNext(): T | null;
+    snapshotItem(index: number): T | null;
 }
-export declare class NodeSetIteratorResult extends NodeSetResult {
-    readonly resultType: XPathResultType;
-    protected activeIterator: IterableIterator<Node> | null;
-    protected nodes: Reiterable<Node>;
+export declare class NodeSetIteratorResult<T extends XPathNode> extends NodeSetResult<T> implements XPathEvaluationResult<T> {
+    readonly resultType: NodeSetResultType;
+    protected activeIterator: IterableIterator<T> | null;
+    protected nodes: Reiterable<T>;
     readonly invalidIteratorState: boolean;
-    protected computedSingleNodeValue: Node | null | undefined;
-    get singleNodeValue(): Node | null;
+    protected computedSingleNodeValue: T | null | undefined;
+    get singleNodeValue(): T | null;
     get snapshotLength(): number;
-    constructor(resultType: XPathResultType, nodes: Iterable<Node>);
-    protected activateIterator(): IterableIterator<Node>;
-    iterateNext(): Node | null;
-    snapshotItem(_index: number): Node | null;
+    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: Iterable<T>);
+    protected activateIterator(): IterableIterator<T>;
+    iterateNext(): T | null;
+    snapshotItem(_index: number): T | null;
 }
 export {};

package/dist/evaluator/result/NumberResult.d.ts

@@ -1,12 +1,12 @@
-import { XPathResult } from '../../shared/index.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { PrimitiveResult } from './PrimitiveResult.ts';
-export declare class NumberResult extends PrimitiveResult implements XPathResult {
-    readonly isIntermediateResult = false;
-    protected readonly type: 1;
+import { XPathEvaluationResult } from './XPathEvaluationResult.ts';
+export declare class NumberResult<T extends XPathNode> extends PrimitiveResult<T> implements XPathEvaluationResult<T> {
     protected readonly nodes: null;
+    readonly resultType: 1;
     readonly booleanValue: boolean;
     readonly numberValue: number;
     readonly stringValue: string;
-    constructor(evaluation: Evaluation);
+    constructor(evaluation: Evaluation<T>);
 }

package/dist/evaluator/result/PrimitiveResult.d.ts

@@ -1,11 +1,11 @@
-import { XPathResult, XPathResultType } from '../../shared/index.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { PrimitiveResultType, BaseResult } from './BaseResult.ts';
-export declare abstract class PrimitiveResult extends BaseResult implements XPathResult {
-    protected abstract readonly type: PrimitiveResultType;
-    get resultType(): XPathResultType;
-    get singleNodeValue(): Node | null;
+import { XPathEvaluationResult } from './XPathEvaluationResult.ts';
+export declare abstract class PrimitiveResult<T extends XPathNode> extends BaseResult<T> implements XPathEvaluationResult<T> {
+    abstract readonly resultType: PrimitiveResultType;
+    get singleNodeValue(): T | null;
     get snapshotLength(): number;
     readonly invalidIteratorState = true;
-    iterateNext(): Node | null;
-    snapshotItem(_index?: number): Node | null;
+    iterateNext(): T | null;
+    snapshotItem(_index?: number): T | null;
 }

package/dist/evaluator/result/StringResult.d.ts

@@ -1,12 +1,12 @@
-import { XPathResult } from '../../shared/index.ts';
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { PrimitiveResult } from './PrimitiveResult.ts';
-export declare class StringResult extends PrimitiveResult implements XPathResult {
-    readonly isIntermediateResult = false;
-    protected readonly type: 2;
+import { XPathEvaluationResult } from './XPathEvaluationResult.ts';
+export declare class StringResult<T extends XPathNode> extends PrimitiveResult<T> implements XPathEvaluationResult<T> {
     protected readonly nodes: null;
+    readonly resultType: 2;
     readonly booleanValue: boolean;
     readonly numberValue: number;
     readonly stringValue: string;
-    constructor(evaluation: Evaluation);
+    constructor(evaluation: Evaluation<T>);
 }

package/dist/evaluator/result/XPathEvaluationResult.d.ts

@@ -0,0 +1,61 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
+declare const ANY_TYPE: XPathResult['ANY_TYPE'];
+export type ANY_TYPE = typeof ANY_TYPE;
+declare const NUMBER_TYPE: XPathResult['NUMBER_TYPE'];
+export type NUMBER_TYPE = typeof NUMBER_TYPE;
+declare const STRING_TYPE: XPathResult['STRING_TYPE'];
+export type STRING_TYPE = typeof STRING_TYPE;
+declare const BOOLEAN_TYPE: XPathResult['BOOLEAN_TYPE'];
+export type BOOLEAN_TYPE = typeof BOOLEAN_TYPE;
+declare const UNORDERED_NODE_ITERATOR_TYPE: XPathResult['UNORDERED_NODE_ITERATOR_TYPE'];
+export type UNORDERED_NODE_ITERATOR_TYPE = typeof UNORDERED_NODE_ITERATOR_TYPE;
+declare const ORDERED_NODE_ITERATOR_TYPE: XPathResult['ORDERED_NODE_ITERATOR_TYPE'];
+export type ORDERED_NODE_ITERATOR_TYPE = typeof ORDERED_NODE_ITERATOR_TYPE;
+declare const UNORDERED_NODE_SNAPSHOT_TYPE: XPathResult['UNORDERED_NODE_SNAPSHOT_TYPE'];
+export type UNORDERED_NODE_SNAPSHOT_TYPE = typeof UNORDERED_NODE_SNAPSHOT_TYPE;
+declare const ORDERED_NODE_SNAPSHOT_TYPE: XPathResult['ORDERED_NODE_SNAPSHOT_TYPE'];
+export type ORDERED_NODE_SNAPSHOT_TYPE = typeof ORDERED_NODE_SNAPSHOT_TYPE;
+declare const ANY_UNORDERED_NODE_TYPE: XPathResult['ANY_UNORDERED_NODE_TYPE'];
+export type ANY_UNORDERED_NODE_TYPE = typeof ANY_UNORDERED_NODE_TYPE;
+declare const FIRST_ORDERED_NODE_TYPE: XPathResult['FIRST_ORDERED_NODE_TYPE'];
+export type FIRST_ORDERED_NODE_TYPE = typeof FIRST_ORDERED_NODE_TYPE;
+export declare const XPATH_EVALUATION_RESULT: {
+    ANY_TYPE: 0;
+    ANY_UNORDERED_NODE_TYPE: 8;
+    BOOLEAN_TYPE: 3;
+    FIRST_ORDERED_NODE_TYPE: 9;
+    NUMBER_TYPE: 1;
+    ORDERED_NODE_ITERATOR_TYPE: 5;
+    ORDERED_NODE_SNAPSHOT_TYPE: 7;
+    STRING_TYPE: 2;
+    UNORDERED_NODE_ITERATOR_TYPE: 4;
+    UNORDERED_NODE_SNAPSHOT_TYPE: 6;
+};
+export type XPathEvaluationResultType = ANY_TYPE | ANY_UNORDERED_NODE_TYPE | BOOLEAN_TYPE | FIRST_ORDERED_NODE_TYPE | NUMBER_TYPE | ORDERED_NODE_ITERATOR_TYPE | ORDERED_NODE_SNAPSHOT_TYPE | STRING_TYPE | UNORDERED_NODE_ITERATOR_TYPE | UNORDERED_NODE_SNAPSHOT_TYPE;
+/**
+ * Establishes baseline API compatibility with the WHAT Working Group DOM
+ * standard {@link XPathResult}, extended to support any
+ * {@link XPathDOMAdapter}'s arbitrary DOM implementation.
+ */
+export interface XPathEvaluationResult<T extends XPathNode> {
+    readonly booleanValue: boolean;
+    readonly invalidIteratorState: boolean;
+    readonly numberValue: number;
+    readonly resultType: XPathEvaluationResultType;
+    readonly singleNodeValue: T | null;
+    readonly snapshotLength: number;
+    readonly stringValue: string;
+    readonly ANY_TYPE: ANY_TYPE;
+    readonly ANY_UNORDERED_NODE_TYPE: ANY_UNORDERED_NODE_TYPE;
+    readonly BOOLEAN_TYPE: BOOLEAN_TYPE;
+    readonly FIRST_ORDERED_NODE_TYPE: FIRST_ORDERED_NODE_TYPE;
+    readonly NUMBER_TYPE: NUMBER_TYPE;
+    readonly ORDERED_NODE_ITERATOR_TYPE: ORDERED_NODE_ITERATOR_TYPE;
+    readonly ORDERED_NODE_SNAPSHOT_TYPE: ORDERED_NODE_SNAPSHOT_TYPE;
+    readonly STRING_TYPE: STRING_TYPE;
+    readonly UNORDERED_NODE_ITERATOR_TYPE: UNORDERED_NODE_ITERATOR_TYPE;
+    readonly UNORDERED_NODE_SNAPSHOT_TYPE: UNORDERED_NODE_SNAPSHOT_TYPE;
+    iterateNext(): T | null;
+    snapshotItem(index: number): T | null;
+}
+export {};

package/dist/evaluator/result/toXPathEvaluationResult.d.ts

@@ -0,0 +1,5 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
+import { XPathDOMProvider } from '../../adapter/xpathDOMProvider.ts';
+import { Evaluation } from '../../evaluations/Evaluation.ts';
+import { XPathEvaluationResult, XPathEvaluationResultType } from './XPathEvaluationResult.ts';
+export declare const toXPathEvaluationResult: <T extends XPathNode>(domProvider: XPathDOMProvider<T>, resultType: XPathEvaluationResultType, evaluation: Evaluation<T>) => XPathEvaluationResult<T>;

package/dist/evaluator/step/Step.d.ts

@@ -1,5 +1,5 @@
 import { AbsoluteLocationPathNode, FilterPathExprNode, PredicateNode, RelativeLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
-type AxisType = 'ancestor-or-self' | 'ancestor' | 'attribute' | 'child' | 'descendant-or-self' | 'descendant' | 'following-sibling' | 'following' | 'namespace' | 'parent' | 'preceding-sibling' | 'preceding' | 'self';
+export type AxisType = 'ancestor-or-self' | 'ancestor' | 'attribute' | 'child' | 'descendant-or-self' | 'descendant' | 'following-sibling' | 'following' | 'namespace' | 'parent' | 'preceding-sibling' | 'preceding' | 'self';
 type NodeType = '__NAMED__' | 'comment' | 'node' | 'processing-instruction' | 'text';
 type StepType = 'NodeTypeTest' | 'ProcessingInstructionNameTest' | 'QualifiedNameTest' | 'NodeNameTest' | 'QualifiedWildcardTest' | 'UnqualifiedWildcardTest';
 export declare abstract class BaseStep {

package/dist/{expressionParser-BVz9yCmv.js → expressionParser-DpqfmhIO.js}

@@ -3468,9 +3468,6 @@ class ExpressionParser {
       return new SyntaxTree(parsed);
     });
   }
-  [Symbol.dispose]() {
-    this.cache.clear();
-  }
 }
 
 const expressionParser = await ExpressionParser.init({
@@ -3479,4 +3476,4 @@ const expressionParser = await ExpressionParser.init({
 });
 
 export { UpsertableMap as U, getDefaultExportFromCjs as a, commonjsGlobal as c, expressionParser as e, getAugmentedNamespace as g };
-//# sourceMappingURL=expressionParser-BVz9yCmv.js.map
+//# sourceMappingURL=expressionParser-DpqfmhIO.js.map