@getodk/xpath 0.1.0

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

@@ -0,0 +1,8 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { Evaluation } from '../../evaluations/Evaluation.ts';
+import type { 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;
+}

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

@@ -0,0 +1,12 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { FilterPathExprNode } from '../../static/grammar/SyntaxNode.ts';
+import type { ExpressionEvaluator } from './ExpressionEvaluator.ts';
+import { LocationPathEvaluator } from './LocationPathEvaluator.ts';
+import type { 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>;
+}

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

@@ -0,0 +1,16 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { Evaluation } from '../../evaluations/Evaluation.ts';
+import type { FunctionCallNode } from '../../static/grammar/SyntaxNode.ts';
+import type { ExpressionEvaluator } from './ExpressionEvaluator.ts';
+interface FunctionCallName {
+    readonly prefix: string | null;
+    readonly localName: string;
+}
+export declare class FunctionCallExpressionEvaluator implements ExpressionEvaluator {
+    readonly syntaxNode: FunctionCallNode;
+    readonly name: FunctionCallName;
+    readonly argumentExpressions: readonly ExpressionEvaluator[];
+    constructor(syntaxNode: FunctionCallNode);
+    evaluate(context: EvaluationContext): Evaluation;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { AbsoluteLocationPathNode, FilterPathExprNode, RelativeLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
+import { type PathExprSteps } from '../step/Step.ts';
+import type { ExpressionEvaluator } from './ExpressionEvaluator.ts';
+import { LocationPathExpressionEvaluator } from './LocationPathExpressionEvaluator.ts';
+type LocationPathNode = AbsoluteLocationPathNode | FilterPathExprNode | RelativeLocationPathNode;
+interface LocationPathExpressionOptions {
+    readonly isAbsolute: boolean;
+    readonly isFilterExprContext: boolean;
+    readonly isRoot: boolean;
+    readonly isSelf: boolean;
+}
+export declare class LocationPathEvaluator extends LocationPathExpressionEvaluator implements ExpressionEvaluator {
+    readonly syntaxNode: LocationPathNode;
+    protected isAbsolute: boolean;
+    protected isFilterExprContext: boolean;
+    protected isRoot: boolean;
+    protected isSelf: boolean;
+    protected steps: PathExprSteps;
+    constructor(syntaxNode: LocationPathNode, options: LocationPathExpressionOptions);
+    evaluateNodes(context: EvaluationContext): Iterable<Node>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { Evaluation } from '../../evaluations/Evaluation.ts';
+import type { 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'>;
+}

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

@@ -0,0 +1,10 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import { NumberEvaluation } from '../../evaluations/NumberEvaluation.ts';
+import type { 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;
+}

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

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

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

@@ -0,0 +1,12 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import { NumberEvaluation } from '../../evaluations/NumberEvaluation.ts';
+import type { 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;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import type { RelativeLocationPathNode } from '../../static/grammar/SyntaxNode.ts';
+import type { 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

@@ -0,0 +1,10 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import { StringEvaluation } from '../../evaluations/StringEvaluation.ts';
+import type { 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;
+}

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

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

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

@@ -0,0 +1,10 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { UnaryExprNode } from '../../static/grammar/SyntaxNode.ts';
+import type { 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;
+}

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

@@ -0,0 +1,11 @@
+import type { EvaluationContext } from '../../context/EvaluationContext.ts';
+import type { UnionExprNode } from '../../static/grammar/SyntaxNode.ts';
+import type { 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>;
+}

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

@@ -0,0 +1,5 @@
+import type { AnyExprNode, ArgumentNode, ExprNode, XPathNode } from '../../static/grammar/SyntaxNode.ts';
+import type { 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

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

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

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

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

@@ -0,0 +1,39 @@
+import type { IterableReadonlyTuple } from '../../../../common/types/collections/IterableReadonlyTuple.ts';
+import type { Context } from '../../context/Context.ts';
+import type { Evaluation } from '../../evaluations/Evaluation.ts';
+import type { EvaluationType } from '../../evaluations/EvaluationType.ts';
+import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
+export declare class UnknownFunctionError extends Error {
+    constructor(functionName: string);
+}
+export declare class InvalidArgumentError extends Error {
+    constructor(argumentIndex: number, parameter: Parameter | null);
+}
+export type ParameterArityType = 'optional' | 'required' | 'variadic';
+export type ParameterTypeHint = 'any' | 'boolean' | 'node' | 'number' | 'string';
+export interface Parameter {
+    readonly arityType: ParameterArityType;
+    readonly typeHint?: ParameterTypeHint;
+}
+export type FunctionSignature<Length extends number> = IterableReadonlyTuple<Parameter, Length>;
+export interface EvaluableArgument {
+    evaluate(context: Context): Evaluation<EvaluationType>;
+}
+export type ValidArguments<Arguments extends readonly EvaluableArgument[], IsValid extends boolean> = [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> {
+    readonly localName: string;
+    readonly signature: FunctionSignature<Length>;
+    readonly arity: FunctionArity;
+    protected readonly callable: FunctionCallable;
+    constructor(localName: string, signature: FunctionSignature<Length>, runtimeImplementation: FunctionCallable | FunctionImplementation<any>);
+    call(context: LocationPathEvaluation, args: readonly EvaluableArgument[]): Evaluation;
+    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

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

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

@@ -0,0 +1,41 @@
+import type { Context } from '../../context/Context.ts';
+import type { FunctionImplementation } from './FunctionImplementation.ts';
+import type { FunctionLibrary } from './FunctionLibrary.ts';
+interface BaseFunctionNameLookup {
+    readonly namespaceURI?: string | null;
+    readonly prefix?: string | null;
+    readonly localName: string;
+}
+interface NamespacedFunctionNameLookup extends BaseFunctionNameLookup {
+    readonly namespaceURI: string | null;
+}
+interface PrefixedFunctionNameLookup extends BaseFunctionNameLookup {
+    readonly prefix: string | null;
+}
+type FunctionNameLookup = NamespacedFunctionNameLookup | PrefixedFunctionNameLookup;
+interface FunctionLibraryCollectionOptions {
+    /**
+     * @default ['http://www.w3.org/2005/xpath-functions']
+     */
+    readonly defaultNamespaceURIs?: readonly string[];
+}
+export declare class FunctionLibraryCollection {
+    /**
+     * Default function libraries determine, for a given Evaluator instance and
+     * its corresponding FunctionLibraryCollection instance, which function calls
+     * may be resolved without a prefix.
+     *
+     * Unprefixed functions are looked up by local name in each successive default
+     * library until one is matched. For example, when both the `xf` and `fn`
+     * libraries are defaults (in that order), `number` will resolve to the `xf`
+     * namespace because it provides a function with `localName: number`
+     * (overriding the default `fn:number`), whereas `string` will resolve to the
+     * `fn` namespace, because the `xf` namespace does not override it.
+     */
+    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;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
+import type { EvaluableArgument, FunctionSignature } from './FunctionImplementation.ts';
+import { 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);
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { Evaluation } from '../../evaluations/Evaluation';
+import { LocationPathEvaluation } from '../../evaluations/LocationPathEvaluation.ts';
+import type { EvaluableArgument, FunctionSignature } from './FunctionImplementation.ts';
+import { 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>);
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,34 @@
+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;
+    static readonly ANY_TYPE: 0;
+    static readonly NUMBER_TYPE: 1;
+    static readonly STRING_TYPE: 2;
+    static readonly BOOLEAN_TYPE: 3;
+    static readonly UNORDERED_NODE_ITERATOR_TYPE: 4;
+    static readonly ORDERED_NODE_ITERATOR_TYPE: 5;
+    static readonly UNORDERED_NODE_SNAPSHOT_TYPE: 6;
+    static readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
+    static readonly ANY_UNORDERED_NODE_TYPE: 8;
+    static readonly FIRST_ORDERED_NODE_TYPE: 9;
+    readonly ANY_TYPE: 0;
+    readonly NUMBER_TYPE: 1;
+    readonly STRING_TYPE: 2;
+    readonly BOOLEAN_TYPE: 3;
+    readonly UNORDERED_NODE_ITERATOR_TYPE: 4;
+    readonly ORDERED_NODE_ITERATOR_TYPE: 5;
+    readonly UNORDERED_NODE_SNAPSHOT_TYPE: 6;
+    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;
+    abstract readonly booleanValue: boolean;
+    abstract readonly numberValue: number;
+    abstract readonly stringValue: string;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import type { XPathResult } from '../../shared/index.ts';
+import type { 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;
+    protected readonly nodes: null;
+    readonly booleanValue: boolean;
+    readonly numberValue: number;
+    readonly stringValue: string;
+    constructor(evaluation: Evaluation);
+}

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

@@ -0,0 +1,55 @@
+import type { XPathResult, XPathResultType } from '../../shared/index.ts';
+import { Reiterable } from '../../lib/iterators/index.ts';
+import type { NodeSetResultType } from './BaseResult.ts';
+import { BaseResult } from './BaseResult.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>;
+    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 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>;
+    readonly snapshotLength: number;
+    readonly invalidIteratorState: boolean;
+    readonly singleNodeValue: Node | null;
+    constructor(resultType: XPathResultType, nodes: Iterable<Node>);
+    iterateNext(): Node | null;
+    snapshotItem(index: number): Node | null;
+}
+export declare class NodeSetIteratorResult extends NodeSetResult {
+    readonly resultType: XPathResultType;
+    protected activeIterator: IterableIterator<Node> | null;
+    protected nodes: Reiterable<Node>;
+    readonly invalidIteratorState: boolean;
+    protected computedSingleNodeValue: Node | null | undefined;
+    get singleNodeValue(): Node | null;
+    get snapshotLength(): number;
+    constructor(resultType: XPathResultType, nodes: Iterable<Node>);
+    protected activateIterator(): IterableIterator<Node>;
+    iterateNext(): Node | null;
+    snapshotItem(_index: number): Node | null;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import type { XPathResult } from '../../shared/index.ts';
+import type { 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;
+    protected readonly nodes: null;
+    readonly booleanValue: boolean;
+    readonly numberValue: number;
+    readonly stringValue: string;
+    constructor(evaluation: Evaluation);
+}

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

@@ -0,0 +1,12 @@
+import type { XPathResult, XPathResultType } from '../../shared/index.ts';
+import type { PrimitiveResultType } from './BaseResult.ts';
+import { 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;
+    get snapshotLength(): number;
+    readonly invalidIteratorState = true;
+    iterateNext(): Node | null;
+    snapshotItem(_index?: number): Node | null;
+}

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

@@ -0,0 +1,13 @@
+export declare const ResultTypes: {
+    readonly BOOLEAN_TYPE: 3;
+    readonly NUMBER_TYPE: 1;
+    readonly STRING_TYPE: 2;
+    readonly UNORDERED_NODE_ITERATOR_TYPE: 4;
+    readonly ORDERED_NODE_ITERATOR_TYPE: 5;
+    readonly UNORDERED_NODE_SNAPSHOT_TYPE: 6;
+    readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
+    readonly ANY_UNORDERED_NODE_TYPE: 8;
+    readonly FIRST_ORDERED_NODE_TYPE: 9;
+};
+export type ResultTypes = typeof ResultTypes;
+export type ResultType = ResultTypes[keyof ResultTypes];

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

@@ -0,0 +1,12 @@
+import type { XPathResult } from '../../shared/index.ts';
+import type { 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;
+    protected readonly nodes: null;
+    readonly booleanValue: boolean;
+    readonly numberValue: number;
+    readonly stringValue: string;
+    constructor(evaluation: Evaluation);
+}

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

@@ -0,0 +1,7 @@
+import type { Evaluation } from '../../evaluations/Evaluation.ts';
+import type { XPathResultType } from '../../shared/index.ts';
+import { BooleanResult } from './BooleanResult';
+import { NodeSetIteratorResult, NodeSetSnapshotResult } from './NodeSetResult';
+import { NumberResult } from './NumberResult';
+import { StringResult } from './StringResult';
+export declare const toXPathResult: (resultType: XPathResultType, evaluation: Evaluation) => BooleanResult | NodeSetSnapshotResult | NodeSetIteratorResult | NumberResult | StringResult;

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

@@ -0,0 +1,129 @@
+import type { 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';
+type NodeType = '__NAMED__' | 'comment' | 'node' | 'processing-instruction' | 'text';
+type StepType = 'NodeTypeTest' | 'ProcessingInstructionNameTest' | 'QualifiedNameTest' | 'NodeNameTest' | 'QualifiedWildcardTest' | 'UnqualifiedWildcardTest';
+export declare abstract class BaseStep {
+    readonly axisType: AxisType | '__ROOT__';
+    abstract readonly stepType: StepType;
+    abstract readonly nodeType: NodeType;
+    abstract readonly localName: string | null | undefined;
+    abstract readonly prefix: string | null | undefined;
+    abstract readonly nodeName: string | undefined;
+    abstract readonly processingInstructionName: string | undefined;
+    abstract readonly predicates: readonly PredicateNode[];
+    constructor(axisType: AxisType | '__ROOT__');
+}
+export declare class RootContextStep extends BaseStep {
+    readonly axisType = "__ROOT__";
+    readonly stepType = "NodeTypeTest";
+    readonly nodeType = "node";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    readonly predicates: readonly [];
+    constructor();
+}
+interface NonRootStep extends BaseStep {
+    readonly axisType: AxisType;
+}
+export declare class EvaluationContextNodeStep extends BaseStep implements NonRootStep {
+    readonly stepType = "NodeTypeTest";
+    readonly axisType = "self";
+    readonly nodeType = "node";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    readonly predicates: readonly [];
+    constructor();
+}
+export declare class FilterExprContextNodeStep extends BaseStep implements NonRootStep {
+    readonly stepType = "NodeTypeTest";
+    readonly axisType = "self";
+    readonly nodeType = "node";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    readonly predicates: readonly [];
+    constructor();
+}
+export type PathExprContextStep = EvaluationContextNodeStep | FilterExprContextNodeStep | RootContextStep;
+type UnnamedNodeType = Exclude<NodeType, '__NAMED__'>;
+export declare class NodeTypeTestStep extends BaseStep implements NonRootStep {
+    readonly axisType: AxisType;
+    readonly nodeType: UnnamedNodeType;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "NodeTypeTest";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    constructor(axisType: AxisType, nodeType: UnnamedNodeType, predicates: readonly PredicateNode[]);
+}
+export declare abstract class BaseNameTestStep extends BaseStep implements NonRootStep {
+    abstract readonly stepType: Exclude<StepType, 'NodeTypeTest'>;
+    abstract readonly axisType: AxisType;
+    readonly nodeType = "__NAMED__";
+}
+export declare class ProcessingInstructionNameTestStep extends BaseStep implements NonRootStep {
+    readonly axisType: AxisType;
+    readonly processingInstructionName: string;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "ProcessingInstructionNameTest";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly nodeName: undefined;
+    readonly nodeType = "processing-instruction";
+    constructor(axisType: AxisType, processingInstructionName: string, predicates: readonly PredicateNode[]);
+}
+export declare class QualifiedNameTestStep extends BaseNameTestStep {
+    readonly axisType: AxisType;
+    readonly prefix: string;
+    readonly localName: string;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "QualifiedNameTest";
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    constructor(axisType: AxisType, prefix: string, localName: string, predicates: readonly PredicateNode[]);
+}
+export declare class NodeNameTestStep extends BaseNameTestStep {
+    readonly axisType: AxisType;
+    readonly nodeName: string;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "NodeNameTest";
+    readonly localName: undefined;
+    readonly prefix: undefined;
+    readonly processingInstructionName: undefined;
+    constructor(axisType: AxisType, nodeName: string, predicates: readonly PredicateNode[]);
+}
+export declare class QualifiedWildcardTestStep extends BaseNameTestStep {
+    readonly axisType: AxisType;
+    readonly prefix: string;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "QualifiedWildcardTest";
+    readonly localName: null;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    constructor(axisType: AxisType, prefix: string, predicates: readonly PredicateNode[]);
+}
+export declare class UnqualifiedWildcardTestStep extends BaseNameTestStep {
+    readonly axisType: AxisType;
+    readonly predicates: readonly PredicateNode[];
+    readonly stepType = "UnqualifiedWildcardTest";
+    readonly localName: null;
+    readonly prefix: null;
+    readonly nodeName: undefined;
+    readonly processingInstructionName: undefined;
+    constructor(axisType: AxisType, predicates: readonly PredicateNode[]);
+}
+export type NameTestStep = NodeNameTestStep | ProcessingInstructionNameTestStep | QualifiedNameTestStep | QualifiedWildcardTestStep | UnqualifiedWildcardTestStep;
+export type AnyStep = NameTestStep | NodeTypeTestStep;
+type AnyLocationPathExprNode = AbsoluteLocationPathNode | FilterPathExprNode | RelativeLocationPathNode;
+type ContextualizedStep = Exclude<AnyStep, {
+    readonly axisType: '__ROOT__';
+}>;
+export type PathExprSteps = readonly [context: PathExprContextStep, ...steps: ContextualizedStep[]];
+export declare const pathExprSteps: (syntaxNode: AnyLocationPathExprNode) => PathExprSteps;
+export {};