@getodk/xpath 0.2.0 → 0.3.0

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

@@ -1,9 +1,9 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { Evaluation } from '../../evaluations/Evaluation.ts';
 import { AbsoluteLocationPathNode, AnyExprNode, FilterPathExprNode, RelativeLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
-
 export type ExpressionNode = AbsoluteLocationPathNode | AnyExprNode | FilterPathExprNode | RelativeLocationPathNode;
 export interface ExpressionEvaluator {
     readonly syntaxNode: ExpressionNode;
-    evaluate(context: EvaluationContext): Evaluation;
+    evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T>;
 }

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

@@ -1,13 +1,13 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { EvaluationContext } from '../../context/EvaluationContext.ts';
 import { FilterPathExprNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
 import { LocationPathEvaluator } from './LocationPathEvaluator.ts';
 import { LocationPathExpressionEvaluator } from './LocationPathExpressionEvaluator.ts';
-
 export declare class FilterPathExpressionEvaluator extends LocationPathEvaluator implements ExpressionEvaluator {
     readonly syntaxNode: FilterPathExprNode;
     readonly filterExpression: LocationPathExpressionEvaluator;
     readonly hasSteps: boolean;
     constructor(syntaxNode: FilterPathExprNode);
-    evaluateNodes(context: EvaluationContext): Iterable<Node>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
 }

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

@@ -1,8 +1,8 @@
+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';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
-
 interface FunctionCallName {
     readonly prefix: string | null;
     readonly localName: string;
@@ -12,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,9 +1,9 @@
+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';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
 import { LocationPathExpressionEvaluator } from './LocationPathExpressionEvaluator.ts';
-
 type LocationPathNode = AbsoluteLocationPathNode | FilterPathExprNode | RelativeLocationPathNode;
 interface LocationPathExpressionOptions {
     readonly isAbsolute: boolean;
@@ -19,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,9 +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,11 +1,11 @@
+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';
-
 export declare abstract class NumberExpressionEvaluator<ConstValue extends number | null = null> implements ExpressionEvaluator {
     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/NumberLiteralExpressionEvaluator.d.ts

@@ -1,7 +1,6 @@
 import { NumberNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
 import { NumberExpressionEvaluator } from './NumberExpressionEvaluator.ts';
-
 export declare class NumberLiteralExpressionEvaluator extends NumberExpressionEvaluator<number> implements ExpressionEvaluator {
     readonly syntaxNode: NumberNode;
     constructor(syntaxNode: NumberNode);

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

@@ -1,13 +1,13 @@
+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';
 import { BinaryExpressionEvaluator } from './BinaryExpressionEvaluator.ts';
-
 type NumericBinaryExprNode = AdditionExprNode | DivisionExprNode | ModuloExprNode | MultiplicationExprNode | SubtractionExprNode;
 type NumericOperation<Node extends NumericBinaryExprNode> = Node extends AdditionExprNode ? 'addition' : Node extends DivisionExprNode ? 'division' : Node extends ModuloExprNode ? 'modulo' : Node extends MultiplicationExprNode ? 'multiplication' : Node extends SubtractionExprNode ? 'subtraction' : never;
 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/RelativeLocationPathExpressionEvaluator.d.ts

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

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

@@ -1,11 +1,11 @@
+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';
-
 export declare abstract class StringExpressionEvaluator<ConstValue extends string | null = null> implements ExpressionEvaluator {
     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/StringLiteralExpressionEvaluator.d.ts

@@ -1,7 +1,6 @@
 import { LiteralNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
 import { StringExpressionEvaluator } from './StringExpressionEvaluator.ts';
-
 export declare class StringLiteralExpressionEvaluator extends StringExpressionEvaluator<string> implements ExpressionEvaluator {
     readonly syntaxNode: LiteralNode;
     constructor(syntaxNode: LiteralNode);

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

@@ -1,11 +1,11 @@
+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';
 import { NumberExpressionEvaluator } from './NumberExpressionEvaluator.ts';
-
 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,12 +1,12 @@
+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';
 import { LocationPathExpressionEvaluator } from './LocationPathExpressionEvaluator.ts';
-
 export declare class UnionExpressionEvaluator extends LocationPathExpressionEvaluator {
     readonly syntaxNode: UnionExprNode;
     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/expression/factory.d.ts

@@ -1,6 +1,5 @@
 import { AnyExprNode, ArgumentNode, ExprNode, XPathNode } from '../../static/grammar/SyntaxNode.ts';
 import { ExpressionEvaluator } from './ExpressionEvaluator.ts';
-
 type EvaluableExprNode = AnyExprNode | ArgumentNode | ExprNode | XPathNode;
 export declare const createExpression: (syntaxNode: EvaluableExprNode) => ExpressionEvaluator;
 export {};

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

@@ -1,6 +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,5 +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,9 +1,8 @@
-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);
 }
@@ -16,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,22 +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,7 +1,7 @@
+import { XPathNode } from '../../adapter/interface/XPathNode.ts';
 import { Context } from '../../context/Context.ts';
 import { FunctionImplementation } from './FunctionImplementation.ts';
 import { FunctionLibrary } from './FunctionLibrary.ts';
-
 interface BaseFunctionNameLookup {
     readonly namespaceURI?: string | null;
     readonly prefix?: string | null;
@@ -36,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,7 +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,6 +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,6 +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,8 +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,13 +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,55 +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,13 +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,12 +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,13 +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>);
 }