@getodk/xpath 0.4.0 → 0.5.0

package/dist/.vite/manifest.json

@@ -1,6 +1,6 @@
 {
-  "_expressionParser-BYZuKGXg.js": {
-    "file": "expressionParser-BYZuKGXg.js",
+  "_expressionParser-BUM7qFCl.js": {
+    "file": "expressionParser-BUM7qFCl.js",
     "name": "expressionParser"
   },
   "src/expressionParser.ts": {
@@ -9,7 +9,7 @@
     "src": "src/expressionParser.ts",
     "isEntry": true,
     "imports": [
-      "_expressionParser-BYZuKGXg.js"
+      "_expressionParser-BUM7qFCl.js"
     ]
   },
   "src/index.ts": {
@@ -18,7 +18,7 @@
     "src": "src/index.ts",
     "isEntry": true,
     "imports": [
-      "_expressionParser-BYZuKGXg.js"
+      "_expressionParser-BUM7qFCl.js"
     ]
   }
 }

package/dist/adapter/interface/XPathDOMOptimizableOperations.d.ts

@@ -5,7 +5,7 @@ export interface XPathDOMOptimizableOperations<T extends XPathNode> {
     readonly getQualifiedNamedAttributeValue: (node: AdapterElement<T>, namespaceURI: string | null, localName: string) => string | null;
     readonly getLocalNamedAttributeValue: (node: AdapterElement<T>, localName: string) => string | null;
     readonly hasLocalNamedAttribute: (node: AdapterElement<T>, localName: string) => boolean;
-    readonly getChildrenByLocalName: (node: AdapterParentNode<T>, localName: string) => Iterable<AdapterElement<T>>;
+    readonly getChildrenByLocalName: (node: AdapterParentNode<T>, localName: string) => ReadonlyArray<AdapterElement<T>>;
     readonly getFirstChildNode: (node: T) => AdapterChildNode<T> | null;
     readonly getFirstChildElement: (node: T) => AdapterElement<T> | null;
     readonly getLastChildNode: (node: T) => AdapterChildNode<T> | null;

package/dist/adapter/interface/XPathTraversalAdapter.d.ts

@@ -12,11 +12,11 @@ export interface XPathTraversalAdapter<T extends XPathNode> {
      * mandatory optimization of that otherwise implicit expectation.
      */
     readonly getContainingDocument: (node: T) => AdapterDocument<T>;
-    readonly getNamespaceDeclarations: (node: T) => Iterable<AdapterNamespaceDeclaration<T>>;
-    readonly getAttributes: (node: T) => Iterable<AdapterAttribute<T>>;
+    readonly getNamespaceDeclarations: (node: T) => ReadonlyArray<AdapterNamespaceDeclaration<T>>;
+    readonly getAttributes: (node: T) => ReadonlyArray<AdapterAttribute<T>>;
     readonly getParentNode: (node: T) => AdapterParentNode<T> | null;
-    readonly getChildNodes: (node: T) => Iterable<AdapterChildNode<T>>;
-    readonly getChildElements: (node: T) => Iterable<AdapterElement<T>>;
+    readonly getChildNodes: (node: T) => ReadonlyArray<AdapterChildNode<T>>;
+    readonly getChildElements: (node: T) => ReadonlyArray<AdapterElement<T>>;
     readonly getPreviousSiblingNode: (node: T) => AdapterChildNode<T> | null;
     readonly getPreviousSiblingElement: (node: T) => AdapterElement<T> | null;
     readonly getNextSiblingNode: (node: T) => AdapterChildNode<T> | null;

package/dist/adapter/xpathDOMProvider.d.ts

@@ -26,21 +26,6 @@ interface NodeKindGuards<T extends XPathNode> {
     readonly isParentNode: NodeKindPredicate<T, AdapterParentNode<T>>;
     readonly isQualifiedNamedNode: NodeKindPredicate<T, AdapterQualifiedNamedNode<T>>;
 }
-type IterableNodeFilter<T extends XPathNode, U extends T> = (nodes: Iterable<T>) => Iterable<U>;
-/**
- * Provides frequently used operations, such as filtering and sorting, on
- * {@link Iterable} sequences of an {@link XPathDOMAdapter}'s node
- * representation.
- */
-interface IterableOperations<T extends XPathNode> {
-    readonly filterAttributes: IterableNodeFilter<T, AdapterAttribute<T>>;
-    readonly filterQualifiedNamedNodes: IterableNodeFilter<T, AdapterQualifiedNamedNode<T>>;
-    readonly filterComments: IterableNodeFilter<T, AdapterComment<T>>;
-    readonly filterNamespaceDeclarations: IterableNodeFilter<T, AdapterNamespaceDeclaration<T>>;
-    readonly filterProcessingInstructions: IterableNodeFilter<T, AdapterProcessingInstruction<T>>;
-    readonly filterTextNodes: IterableNodeFilter<T, AdapterText<T>>;
-    readonly sortInDocumentOrder: (nodes: Iterable<T>) => readonly T[];
-}
 /**
  * Omitting XPathDOMOptimizableOperations keys here allows them to be made
  * non-optional, without then repeating the exact same properties and their
@@ -74,7 +59,7 @@ declare const DERIVED_DOM_PROVIDER: unique symbol;
 interface DerivedDOMProvider {
     readonly [DERIVED_DOM_PROVIDER]: true;
 }
-export interface XPathDOMProvider<T extends XPathNode> extends OmitOptionalOptimizableOperations<XPathDOMAdapter<T>>, NodeKindGuards<T>, IterableOperations<T>, XPathDOMOptimizableOperations<T>, DerivedDOMProvider {
+export interface XPathDOMProvider<T extends XPathNode> extends OmitOptionalOptimizableOperations<XPathDOMAdapter<T>>, NodeKindGuards<T>, XPathDOMOptimizableOperations<T>, DerivedDOMProvider {
 }
 export declare const xpathDOMProvider: <T extends XPathNode>(adapter: XPathDOMAdapter<T>) => XPathDOMProvider<T>;
 export {};

package/dist/context/Context.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
+import { Temporal } from 'temporal-polyfill';
 import { XPathNode } from '../adapter/interface/XPathDOMAdapter.ts';
 import { AdapterDocument, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
 import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
@@ -21,10 +21,10 @@ export interface Context<T extends XPathNode> {
     readonly evaluationContextNode: T;
     readonly contextDocument: AdapterDocument<T>;
     readonly rootNode: AdapterParentNode<T>;
-    readonly contextNodes: Iterable<T>;
+    readonly contextNodes: ReadonlySet<T>;
     contextPosition(): number;
     contextSize(): number;
     readonly functions: FunctionLibraryCollection;
     readonly namespaceResolver: NamespaceResolver<T>;
-    readonly timeZone: Temporal.TimeZone;
+    readonly timeZone: Temporal.TimeZoneLike;
 }

package/dist/context/EvaluationContext.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
+import { Temporal } from 'temporal-polyfill';
 import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { AdapterDocument, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
 import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
@@ -11,7 +11,7 @@ export interface EvaluationContextOptions<T extends XPathNode> {
     readonly rootNode: AdapterParentNode<T> | null;
     readonly functions: FunctionLibraryCollection;
     readonly namespaceResolver: XPathNSResolver | null;
-    readonly timeZone: Temporal.TimeZone;
+    readonly timeZone: Temporal.TimeZoneLike;
 }
 /**
  * The context in which an XPath expression (**not** a sub-expression)
@@ -26,10 +26,10 @@ export declare class EvaluationContext<T extends XPathNode> implements Context<T
     readonly evaluationContextNode: T;
     readonly contextDocument: AdapterDocument<T>;
     readonly rootNode: AdapterParentNode<T>;
-    readonly contextNodes: Iterable<T>;
+    readonly contextNodes: ReadonlySet<T>;
     readonly functions: FunctionLibraryCollection;
     readonly namespaceResolver: NamespaceResolver<T>;
-    readonly timeZone: Temporal.TimeZone;
+    readonly timeZone: Temporal.TimeZoneLike;
     constructor(evaluator: Evaluator<T>, contextNode: T, options?: Partial<EvaluationContextOptions<T>>);
     contextPosition(): number;
     contextSize(): number;

package/dist/evaluations/DateTimeLikeEvaluation.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
+import { Temporal } from 'temporal-polyfill';
 import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 import { ValueEvaluation } from './ValueEvaluation.ts';

package/dist/evaluations/Evaluation.d.ts

@@ -5,7 +5,7 @@ export interface Evaluation<T extends XPathNode, Type extends EvaluationType = E
     readonly context: LocationPathEvaluation<T>;
     readonly type: Type;
     first(): Evaluation<T, Type> | null;
-    values(): Iterable<Evaluation<T, Type>>;
+    values(): ReadonlyArray<Evaluation<T, Type>>;
     eq(operand: Evaluation<T>): boolean;
     ne(operand: Evaluation<T>): boolean;
     lt(operand: Evaluation<T>): boolean;
@@ -15,5 +15,5 @@ export interface Evaluation<T extends XPathNode, Type extends EvaluationType = E
     toBoolean(): boolean;
     toNumber(): number;
     toString(): string;
-    readonly nodes: Type extends 'NODE' ? Iterable<T> : null;
+    readonly nodes: Type extends 'NODE' ? ReadonlySet<T> : null;
 }

package/dist/evaluations/LocationPathEvaluation.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
+import { Temporal } from 'temporal-polyfill';
 import { XPathNode } from '../adapter/interface/XPathNode.ts';
 import { AdapterDocument, AdapterParentNode } from '../adapter/interface/XPathNodeKindAdapter.ts';
 import { XPathDOMProvider } from '../adapter/xpathDOMProvider.ts';
@@ -12,24 +12,24 @@ import { LocationPathExpressionEvaluator } from '../evaluator/expression/Locatio
 import { FunctionLibraryCollection } from '../evaluator/functions/FunctionLibraryCollection.ts';
 import { NodeSetFunction } from '../evaluator/functions/NodeSetFunction.ts';
 import { AnyStep } from '../evaluator/step/Step.ts';
-import { Reiterable } from '../lib/iterators/Reiterable.ts';
 import { Evaluation } from './Evaluation.ts';
 import { NodeEvaluation } from './NodeEvaluation.ts';
 type LocationPathParentContext<T extends XPathNode> = EvaluationContext<T> | LocationPathEvaluation<T>;
 type EvaluationComparator<T extends XPathNode> = (lhs: Evaluation<T>, rhs: Evaluation<T>) => boolean;
 interface LocationPathEvaluationOptions {
     readonly contextPosition?: number;
-    contextSize?: () => number;
+    readonly contextSize?: number;
 }
 type ArbitraryNodesTemporaryCallee = FilterPathExpressionEvaluator | LocationPathEvaluator | NodeSetFunction;
 type AssertLocationPathEvaluationInstance = <T extends XPathNode>(context: EvaluationContext<T>, value: unknown, message?: string) => asserts value is LocationPathEvaluation<T>;
 export declare class LocationPathEvaluation<T extends XPathNode> implements Evaluation<T, 'NODE'>, Context<T>, EvaluationContext<T>, Iterable<LocationPathEvaluation<T>> {
     readonly parentContext: LocationPathParentContext<T>;
+    readonly contextNodes: ReadonlySet<T>;
     protected static isInstance<T extends XPathNode>(context: Context<T>, value: unknown): value is LocationPathEvaluation<T>;
     static readonly assertInstance: AssertLocationPathEvaluationInstance;
     readonly domProvider: XPathDOMProvider<T>;
     readonly type = "NODE";
-    protected readonly nodeEvaluations: Reiterable<NodeEvaluation<T>>;
+    protected readonly nodeEvaluations: ReadonlyArray<NodeEvaluation<T>>;
     readonly evaluator: Evaluator<T>;
     readonly context: LocationPathEvaluation<T>;
     /**
@@ -38,15 +38,12 @@ export declare class LocationPathEvaluation<T extends XPathNode> implements Eval
     readonly evaluationContextNode: T;
     readonly contextDocument: AdapterDocument<T>;
     readonly rootNode: AdapterParentNode<T>;
-    private _nodes;
-    get nodes(): Iterable<T>;
-    get contextNodes(): IterableIterator<T>;
-    protected computedContextSize: number | null;
-    protected readonly optionsContextSize?: () => number;
+    readonly nodes: ReadonlySet<T>;
+    protected computedContextSize: number;
     protected readonly initializedContextPosition: number;
     readonly functions: FunctionLibraryCollection;
     readonly namespaceResolver: NamespaceResolver<T>;
-    readonly timeZone: Temporal.TimeZone;
+    readonly timeZone: Temporal.TimeZoneLike;
     /**
      * TODO: this is a temporary accommodation for these cases which are presently
      * not especially well designed:
@@ -57,14 +54,14 @@ export declare class LocationPathEvaluation<T extends XPathNode> implements Eval
      * - Nodes filtered by predicate in {@link LocationPathExpression}. Such
      *   filtering almost certainly should be performed here, in {@link step}.
      */
-    static fromArbitraryNodes<T extends XPathNode>(currentContext: LocationPathParentContext<T>, nodes: Iterable<T>, _temporaryCallee: ArbitraryNodesTemporaryCallee): LocationPathEvaluation<T>;
+    static fromArbitraryNodes<T extends XPathNode>(currentContext: LocationPathParentContext<T>, nodes: readonly T[], _temporaryCallee: ArbitraryNodesTemporaryCallee): LocationPathEvaluation<T>;
     static fromCurrentContext<T extends XPathNode>(evaluationContext: EvaluationContext<T>): LocationPathEvaluation<T>;
     static fromRoot<T extends XPathNode>(parentContext: LocationPathParentContext<T>): LocationPathEvaluation<T>;
-    protected constructor(parentContext: LocationPathParentContext<T>, contextNodes: Iterable<T>, options?: LocationPathEvaluationOptions);
+    protected constructor(parentContext: LocationPathParentContext<T>, contextNodes: ReadonlySet<T>, options?: LocationPathEvaluationOptions);
     [Symbol.iterator](): {
         next: () => IteratorResult<LocationPathEvaluation<T>>;
     };
-    values(): Iterable<NodeEvaluation<T>>;
+    values(): ReadonlyArray<NodeEvaluation<T>>;
     contextPosition(): number;
     contextSize(): number;
     currentContext<U extends XPathNode>(this: LocationPathEvaluation<U>): LocationPathEvaluation<U>;

package/dist/evaluations/NodeEvaluation.d.ts

@@ -11,7 +11,7 @@ export declare class NodeEvaluation<T extends XPathNode> extends ValueEvaluation
     readonly context: LocationPathEvaluation<T>;
     readonly value: T;
     readonly type = "NODE";
-    readonly nodes: Iterable<T>;
+    readonly nodes: ReadonlySet<T>;
     protected computedValues: NodeEvaluationComputedValues | null;
     protected get booleanValue(): boolean;
     protected get numberValue(): number;

package/dist/evaluations/ValueEvaluation.d.ts

@@ -3,16 +3,17 @@ import { Evaluation } from './Evaluation.ts';
 import { EvaluationType, EvaluationTypes } from './EvaluationType.ts';
 import { LocationPathEvaluation } from './LocationPathEvaluation.ts';
 export declare abstract class ValueEvaluation<T extends XPathNode, Type extends EvaluationType> implements Evaluation<T, Type> {
+    protected readonly _values: readonly [this];
     abstract readonly context: LocationPathEvaluation<T>;
     abstract readonly type: Type;
     abstract readonly value: EvaluationTypes<T>[Type];
-    abstract readonly nodes: Type extends 'NODE' ? Iterable<T> : null;
+    abstract readonly nodes: Type extends 'NODE' ? ReadonlySet<T> : null;
     protected abstract readonly booleanValue: boolean;
     protected abstract readonly numberValue: number;
     protected abstract readonly stringValue: string;
-    [Symbol.iterator](): IterableIterator<this>;
+    [Symbol.iterator](): ArrayIterator<this>;
     first(): this;
-    values(): IterableIterator<this>;
+    values(): readonly this[];
     toBoolean(): boolean;
     toNumber(): number;
     toString(): string;

package/dist/evaluator/Evaluator.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
+import { Temporal } from 'temporal-polyfill';
 import { UnwrapAdapterNode } from '../adapter/interface/XPathCustomUnwrappableNode.ts';
 import { XPathDOMAdapter } from '../adapter/interface/XPathDOMAdapter.ts';
 import { XPathNode } from '../adapter/interface/XPathNode.ts';
@@ -29,7 +29,7 @@ export declare class Evaluator<T extends XPathNode> {
     readonly functions: FunctionLibraryCollection;
     readonly parseOptions: ParseOptions;
     readonly rootNode: AdapterParentNode<T> | null;
-    readonly timeZone: Temporal.TimeZone;
+    readonly timeZone: Temporal.TimeZoneLike;
     constructor(options: EvaluatorOptions<T>);
     /**
      * @package - exposed for testing

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

@@ -9,5 +9,5 @@ export declare class FilterPathExpressionEvaluator extends LocationPathEvaluator
     readonly filterExpression: LocationPathExpressionEvaluator;
     readonly hasSteps: boolean;
     constructor(syntaxNode: FilterPathExprNode);
-    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): ReadonlySet<T>;
 }

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

@@ -19,6 +19,6 @@ export declare class LocationPathEvaluator extends LocationPathExpressionEvaluat
     protected isSelf: boolean;
     protected steps: PathExprSteps;
     constructor(syntaxNode: LocationPathNode, options: LocationPathExpressionOptions);
-    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): ReadonlySet<T>;
 }
 export {};

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

@@ -4,6 +4,6 @@ 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<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
+    abstract evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): ReadonlySet<T>;
     evaluate<T extends XPathNode>(context: EvaluationContext<T>): Evaluation<T, 'NODE'>;
 }

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

@@ -8,5 +8,5 @@ export declare class UnionExpressionEvaluator extends LocationPathExpressionEval
     readonly lhs: ExpressionEvaluator;
     readonly rhs: ExpressionEvaluator;
     constructor(syntaxNode: UnionExprNode);
-    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): Iterable<T>;
+    evaluateNodes<T extends XPathNode>(context: EvaluationContext<T>): ReadonlySet<T>;
 }

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

@@ -35,7 +35,7 @@ export declare class FunctionLibraryCollection {
      */
     protected readonly defaultFunctionLibraries: readonly FunctionLibrary[];
     protected readonly namespacedFunctionLibraries: ReadonlyMap<string, FunctionLibrary>;
-    constructor(functionLibraries: Iterable<FunctionLibrary>, options?: FunctionLibraryCollectionOptions);
+    constructor(functionLibraries: readonly FunctionLibrary[], options?: FunctionLibraryCollectionOptions);
     getDefaultImplementation(localName: string): FunctionImplementation | null;
     getImplementation<T extends XPathNode>(context: Context<T>, name: FunctionNameLookup): FunctionImplementation | null;
 }

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 = <T extends XPathNode, Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Arguments) => Iterable<T>;
+export type NodeSetFunctionCallable = <T extends XPathNode, Arguments extends readonly EvaluableArgument[]>(context: LocationPathEvaluation<T>, args: Arguments) => readonly T[];
 export declare class NodeSetFunction extends FunctionImplementation {
     constructor(localName: string, signature: FunctionSignature, call: NodeSetFunctionCallable);
 }

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

@@ -24,7 +24,7 @@ export declare abstract class BaseResult<T extends XPathNode> implements XPathEv
     readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
     readonly ANY_UNORDERED_NODE_TYPE: 8;
     readonly FIRST_ORDERED_NODE_TYPE: 9;
-    protected abstract readonly nodes: Iterable<T> | null;
+    protected abstract readonly nodes: ReadonlySet<T> | null;
     abstract readonly resultType: XPathEvaluationResultType;
     abstract readonly invalidIteratorState: boolean;
     abstract readonly singleNodeValue: T | null;

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

@@ -1,6 +1,5 @@
 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 {
@@ -10,8 +9,7 @@ interface ComputedNodeSetResult {
 }
 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 readonly nodes: ReadonlySet<T>;
     protected computedBooleanValue: boolean | null;
     protected computedNumberValue: number | null;
     protected computedStringValue: string | null;
@@ -20,7 +18,7 @@ export declare abstract class NodeSetResult<T extends XPathNode> extends BaseRes
     get stringValue(): string;
     protected computedSnapshotValue: readonly T[] | null;
     abstract readonly resultType: NodeSetResultType;
-    constructor(domProvider: XPathDOMProvider<T>, value: Iterable<T>);
+    constructor(domProvider: XPathDOMProvider<T>, value: ReadonlySet<T>);
     protected compute(): ComputedNodeSetResult;
 }
 export declare class NodeSetSnapshotResult<T extends XPathNode> extends NodeSetResult<T> implements XPathEvaluationResult<T> {
@@ -30,20 +28,18 @@ export declare class NodeSetSnapshotResult<T extends XPathNode> extends NodeSetR
     readonly snapshotLength: number;
     readonly invalidIteratorState: boolean;
     readonly singleNodeValue: T | null;
-    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: Iterable<T>);
+    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: ReadonlySet<T>);
     iterateNext(): T | null;
     snapshotItem(index: number): T | null;
 }
 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>;
+    protected readonly activeIterator: IterableIterator<T>;
     readonly invalidIteratorState: boolean;
     protected computedSingleNodeValue: T | null | undefined;
     get singleNodeValue(): T | null;
     get snapshotLength(): number;
-    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: Iterable<T>);
-    protected activateIterator(): IterableIterator<T>;
+    constructor(domProvider: XPathDOMProvider<T>, resultType: NodeSetResultType, nodes: ReadonlySet<T>);
     iterateNext(): T | null;
     snapshotItem(_index: number): T | null;
 }