@getodk/xpath 0.1.0

package/dist/lib/collections/sort.d.ts

@@ -0,0 +1 @@
+export declare const seededRandomize: <T>(values: readonly T[], seed?: number) => T[];

package/dist/lib/datetime/coercion.d.ts

@@ -0,0 +1,4 @@
+import { Temporal } from '@js-temporal/polyfill';
+export declare const tryParseDateString: (value: string) => Date | null;
+export declare const dateTimeFromString: (timeZone: Temporal.TimeZone, value: string) => Temporal.ZonedDateTime | null;
+export declare const dateTimeFromNumber: (timeZone: Temporal.TimeZone, milliseconds: number) => Temporal.ZonedDateTime | null;

package/dist/lib/datetime/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DAY_MILLISECONDS: number;
+export declare const MILLISECOND_NANOSECONDS: bigint;
+export declare const ISO_DATE_LIKE_PATTERN: RegExp;
+export declare const ISO_TIME_LIKE_PATTERN: RegExp;
+export declare const ISO_DATE_TIME_LIKE_PATTERN: RegExp;
+export declare const ISO_DATE_OR_DATE_TIME_LIKE_PATTERN: RegExp;

package/dist/lib/datetime/functions.d.ts

@@ -0,0 +1,5 @@
+import { Temporal } from '@js-temporal/polyfill';
+export declare const currentLocalDateTimeString: (timeZone: Temporal.TimeZone) => string;
+export declare const localDateTimeString: (dateTime: Temporal.ZonedDateTime) => string;
+export declare const localDateTimeOrDateString: (dateTime: Temporal.ZonedDateTime) => string;
+export declare const now: (timeZone: Temporal.TimeZone) => Temporal.ZonedDateTime;

package/dist/lib/datetime/predicates.d.ts

@@ -0,0 +1,5 @@
+export declare const isISODateLike: (value: string) => boolean;
+export declare const isISOTimeLike: (value: string) => boolean;
+export declare const isISODateTimeLike: (value: string) => boolean;
+export declare const isISODateOrDateTimeLike: (value: string) => boolean;
+export declare const isValidTimeString: (value: string) => boolean;

package/dist/lib/dom/assertions.d.ts

@@ -0,0 +1,4 @@
+import type { ContextParentNode } from './types.ts';
+type AssertParentNode = (node: Node) => asserts node is ContextParentNode;
+export declare const assertParentNode: AssertParentNode;
+export {};

package/dist/lib/dom/predicates.d.ts

@@ -0,0 +1,11 @@
+import type { NamespaceAttribute } from './types';
+export declare const isAttributeNode: (node: Node) => node is Attr;
+export declare const isNamespaceAttribute: (attr: Attr) => attr is NamespaceAttribute;
+export declare const isNamespaceNode: (node: Node) => node is NamespaceAttribute;
+export declare const isCDataSection: (node: Node) => node is CDATASection;
+export declare const isCommentNode: (node: Node) => node is Comment;
+export declare const isDocumentNode: (node: Node) => node is Document;
+export declare const isDocumentFragmentNode: (node: Node) => node is DocumentFragment;
+export declare const isElementNode: (node: Node) => node is Element;
+export declare const isProcessingInstructionNode: (node: Node) => node is ProcessingInstruction;
+export declare const isTextNode: (node: Node) => node is Text;

package/dist/lib/dom/sort.d.ts

@@ -0,0 +1 @@
+export declare const sortDocumentOrder: (nodes: Iterable<Node>) => Node[];

package/dist/lib/dom/traversal.d.ts

@@ -0,0 +1,21 @@
+import type { ContextDocument, ContextNode, ContextParentNode } from './types.ts';
+export declare const getDocument: (node: Node) => Document;
+export declare const getRootNode: (node: ContextNode) => ContextParentNode;
+export declare const TreeWalkerFilter: {
+    readonly ANY: 975;
+    readonly ELEMENT: 1;
+    readonly TEXT: 12;
+    readonly COMMENT: 128;
+    readonly PROCESSING_INSTRUCTION: 64;
+};
+type TreeWalkerFilters = typeof TreeWalkerFilter;
+export type TreeWalkerFilter = keyof TreeWalkerFilters;
+export type TreeWalkerFilterFlag = TreeWalkerFilters[TreeWalkerFilter];
+export type FilteredTreeWalker<Filter extends TreeWalkerFilter = TreeWalkerFilter> = TreeWalker & {
+    readonly whatToShow: TreeWalkerFilters[Filter];
+};
+export declare const getTreeWalker: <Filter extends "ELEMENT" | "ANY" | "COMMENT" | "PROCESSING_INSTRUCTION" | "TEXT" = "ANY">(contextDocument: ContextDocument, contextNode?: ContextNode, filter?: Filter) => FilteredTreeWalker<Filter>;
+export type FilteredTreeWalkers = {
+    readonly [Filter in TreeWalkerFilter]: FilteredTreeWalker<Filter>;
+};
+export {};

package/dist/lib/dom/types.d.ts

@@ -0,0 +1,21 @@
+export type ContextDocument = Document | XMLDocument;
+type AnyContextNode = Attr | CDATASection | Comment | ContextDocument | DocumentType | Element | ProcessingInstruction | Text;
+type MaybeNode<T extends Node> = Node & Partial<Omit<T, keyof Node>>;
+export type MaybeAttrNode = MaybeNode<Attr>;
+export type MaybeElementNode = AnyContextNode & Node & Partial<Element>;
+export type MaybeProcessingInstructionNode = MaybeNode<ProcessingInstruction>;
+export type MaybeNamedNode = MaybeNode<MaybeAttrNode | MaybeElementNode>;
+export type ContextNode = AnyContextNode & Node;
+export type MaybeDocumentOrElementNode = MaybeElementNode & Partial<ContextDocument>;
+export type AnyParentNode = Extract<AnyContextNode, {
+    readonly children: any;
+}>;
+export type ContextParentNode = AnyParentNode & Node;
+type AnyNamedNode = Attr | Element | ProcessingInstruction;
+export type NamedNode = AnyNamedNode & Node;
+export type NamespaceAttribute = Attr & ({
+    readonly name: 'xmlns';
+} | {
+    readonly prefix: 'xmlns';
+});
+export {};

package/dist/lib/dom/xml.d.ts

@@ -0,0 +1 @@
+export declare const parseXMLDocument: (xml: string) => Document;

package/dist/lib/iterators/Reiterable.d.ts

@@ -0,0 +1,15 @@
+type BooleanPredicate<T> = (value: T) => boolean;
+export declare class Reiterable<T> implements Iterable<T> {
+    protected source: Iterable<T> | Iterator<T>;
+    static from<T>(source: Iterable<T> | Iterator<T>): Reiterable<T>;
+    protected active: IterableIterator<T>;
+    protected cache: T[];
+    protected constructor(source: Iterable<T> | Iterator<T>);
+    [Symbol.iterator](): Iterator<T>;
+    entries(): IterableIterator<readonly [key: number, value: T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    first(): T | void;
+    some(predicate: BooleanPredicate<T>): boolean;
+}
+export {};

package/dist/lib/iterators/common.d.ts

@@ -0,0 +1,17 @@
+type Iter<T> = Iterable<T> | Iterator<T>;
+export declare function toIterableIterator<T>(iter: Iter<T>): IterableIterator<T>;
+type MapIterated<T, U> = (value: T) => U;
+export type MapIterable<T, U> = (iterable: Iter<T>) => IterableIterator<U>;
+export declare const map: <T, U>(fn: MapIterated<T, U>) => MapIterable<T, U>;
+export declare const eager: <T>(iterable: Iter<T>) => IterableIterator<T>;
+type TypedGuardIterated<T, U extends T> = (value: T) => value is U;
+type PredicateGuardIterated<T> = (value: T) => boolean;
+type GuardIterated<T, U extends T> = PredicateGuardIterated<T & U> | TypedGuardIterated<T, U>;
+type UnguardedIterated<Guard extends GuardIterated<any, any>> = Guard extends TypedGuardIterated<infer T, any> ? T : Guard extends PredicateGuardIterated<infer T> ? T : never;
+type GuardedIterated<Guard extends GuardIterated<any, any>> = Guard extends TypedGuardIterated<infer T, infer U> ? T & U : Guard extends PredicateGuardIterated<infer T> ? T : never;
+type FilterIterable<Guard extends GuardIterated<any, any>> = MapIterable<UnguardedIterated<Guard>, GuardedIterated<Guard>>;
+export declare const filter: <Guard extends GuardIterated<any, any>>(guard: Guard) => FilterIterable<Guard>;
+export declare const distinct: <T>(iterable: Iterable<T>) => Generator<T, void, unknown>;
+type TeeResult<T> = [IterableIterator<T>, IterableIterator<T>];
+export declare const tee: <T>(input: Iterable<T> | Iterator<T, any, undefined>) => TeeResult<T>;
+export {};

package/dist/lib/iterators/index.d.ts

@@ -0,0 +1,3 @@
+export * from 'itertools-ts';
+export * from './common.ts';
+export * from './Reiterable.ts';

package/dist/lib/regex/escape.d.ts

@@ -0,0 +1 @@
+export declare const escapeRegExp: (value: string) => string;

package/dist/shared/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const XPathResultTypes: {
+    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;
+};
+export type XPathResultTypes = typeof XPathResultTypes;

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants.ts';
+export type * from './interface.ts';

package/dist/shared/interface.d.ts

@@ -0,0 +1,33 @@
+type LookupNamespaceURI = (prefix: string | null) => string | null;
+export interface XPathNamespaceResolverObject {
+    readonly lookupNamespaceURI: LookupNamespaceURI;
+}
+export type XPathNSResolver = LookupNamespaceURI | XPathNamespaceResolverObject;
+interface XPathResultStatic {
+    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;
+}
+export type XPathResultType = XPathResultStatic[keyof XPathResultStatic];
+export interface XPathResult extends XPathResultStatic {
+    readonly booleanValue: boolean;
+    readonly invalidIteratorState: boolean;
+    readonly numberValue: number;
+    readonly resultType: XPathResultType;
+    readonly singleNodeValue: Node | null;
+    readonly snapshotLength: number;
+    readonly stringValue: string;
+    iterateNext(): Node | null;
+    snapshotItem(index: number): Node | null;
+}
+export interface AnyXPathEvaluator {
+    evaluate(expression: string, contextNode: Node, namespaceResolver: XPathNSResolver | null, resultType: XPathResultType | null): XPathResult;
+}
+export {};

package/dist/static/grammar/ExpressionParser.d.ts

@@ -0,0 +1,27 @@
+import { UpsertableMap } from '../../../../common/src/lib/collections/UpsertableMap.ts';
+import type { SyntaxLanguageTypeName, SyntaxLanguage as TreeSitterLanguage } from './SyntaxLanguage.ts';
+import type { XPathNode } from './SyntaxNode.ts';
+import { type SyntaxTree as TreeSitterTree } from './SyntaxTree.ts';
+import { TreeSitterXPathParser, type WebAssemblyResourceSpecifiers } from './TreeSitterXPathParser.ts';
+declare class SyntaxLanguage implements TreeSitterLanguage {
+    readonly types: readonly SyntaxLanguageTypeName[];
+    constructor(tsLanguage: TreeSitterLanguage);
+}
+declare class SyntaxTree implements TreeSitterTree {
+    readonly language: SyntaxLanguage;
+    readonly rootNode: XPathNode;
+    constructor(tsTree: TreeSitterTree);
+}
+export interface ParseOptions {
+    readonly attemptErrorRecovery?: boolean;
+}
+export type BaseParser = ExpressionParser | TreeSitterXPathParser;
+export declare class ExpressionParser {
+    protected readonly xpathParser: TreeSitterXPathParser;
+    static from(baseParser: BaseParser): ExpressionParser;
+    static init(resources: WebAssemblyResourceSpecifiers): Promise<ExpressionParser>;
+    protected constructor(xpathParser: TreeSitterXPathParser);
+    protected readonly cache: UpsertableMap<string, SyntaxTree>;
+    parse(expression: string, options?: ParseOptions): SyntaxTree;
+}
+export {};

package/dist/static/grammar/SyntaxLanguage.d.ts

@@ -0,0 +1,5 @@
+import type { AnySyntaxType } from './type-names.ts';
+export type SyntaxLanguageTypeName = AnySyntaxType | undefined;
+export interface SyntaxLanguage {
+    readonly types: readonly SyntaxLanguageTypeName[];
+}

package/dist/static/grammar/SyntaxNode.d.ts

@@ -0,0 +1,144 @@
+import type { AbbreviatedAbsoluteLocationPathType, AbbreviatedAxisTestType, AbbreviatedStepType, AbsoluteLocationPathType, AbsoluteRootLocationPathType, AdditionExprType, AndExprType, AnyBinaryExprType, AnySyntaxType, AnyUnaryExprType, ArgumentType, AxisNameType, AxisTestType, DivisionExprType, EqExprType, ExprType, FilterExprType, FilterPathExprType, FunctionCallType, FunctionNameType, GteExprType, GtExprType, LiteralType, LocalPartType, LteExprType, LtExprType, ModuloExprType, MultiplicationExprType, NeExprType, NodeTestType, NodeTypeTestType, NumberType, OrExprType, ParentType, PredicateType, PrefixedNameType, PrefixedWildcardNameTestType, PrefixType, ProcessingInstructionNameTestType, RelativeLocationPathType, RelativeStepSyntaxLiteral, SelfType, StepType, SubtractionExprType, UnionExprType, UnprefixedNameType, UnprefixedWildcardNameTestType, VariableReferenceType, XPathType } from './type-names.ts';
+export interface SyntaxNode<Type extends AnySyntaxType, Children extends readonly UnknownSyntaxNode[], Text extends string = string> {
+    readonly type: Type;
+    readonly childCount: Children['length'];
+    readonly children: Children;
+    readonly text: Text;
+    child<Index extends number>(index: Index): `${Index}` extends keyof Children ? Children[Index] : Exclude<Children[Index], undefined> | null;
+    child(index: number): Exclude<Children[number], undefined> | null;
+}
+export interface ASyntaxNode extends SyntaxNode<AnySyntaxType, readonly ASyntaxNode[]> {
+}
+export interface UnknownSyntaxNode extends SyntaxNode<any, any> {
+}
+export interface TerminalSyntaxNode<Type extends AnySyntaxType> extends SyntaxNode<Type, readonly []> {
+}
+export interface UnaryExprSyntaxNode<Type extends AnyUnaryExprType> extends SyntaxNode<Type, readonly [AnyExprNode]> {
+}
+export interface BinaryExprSyntaxNode<Type extends AnyBinaryExprType> extends SyntaxNode<Type, readonly [AnyExprNode, AnyExprNode]> {
+}
+export interface TerminalTextLiteralSyntaxNode<Type extends AnySyntaxType, Text extends string> extends SyntaxNode<Type, readonly [], Text> {
+}
+export interface XPathNode extends SyntaxNode<XPathType, readonly [ExprNode]> {
+}
+export interface ExprNode extends SyntaxNode<ExprType, readonly [AnyExprNode]> {
+}
+export interface UnaryExprNode extends UnaryExprSyntaxNode<AnyUnaryExprType> {
+}
+export interface AdditionExprNode extends BinaryExprSyntaxNode<AdditionExprType> {
+}
+export interface AndExprNode extends BinaryExprSyntaxNode<AndExprType> {
+}
+export interface DivisionExprNode extends BinaryExprSyntaxNode<DivisionExprType> {
+}
+export interface EqExprNode extends BinaryExprSyntaxNode<EqExprType> {
+}
+export interface GtExprNode extends BinaryExprSyntaxNode<GtExprType> {
+}
+export interface GteExprNode extends BinaryExprSyntaxNode<GteExprType> {
+}
+export interface LtExprNode extends BinaryExprSyntaxNode<LtExprType> {
+}
+export interface LteExprNode extends BinaryExprSyntaxNode<LteExprType> {
+}
+export interface ModuloExprNode extends BinaryExprSyntaxNode<ModuloExprType> {
+}
+export interface MultiplicationExprNode extends BinaryExprSyntaxNode<MultiplicationExprType> {
+}
+export interface NeExprNode extends BinaryExprSyntaxNode<NeExprType> {
+}
+export interface OrExprNode extends BinaryExprSyntaxNode<OrExprType> {
+}
+export interface SubtractionExprNode extends BinaryExprSyntaxNode<SubtractionExprType> {
+}
+export interface UnionExprNode extends BinaryExprSyntaxNode<UnionExprType> {
+}
+type AnyUnaryExprNode = UnaryExprNode;
+export type AnyBinaryExprNode = AdditionExprNode | AndExprNode | DivisionExprNode | EqExprNode | GteExprNode | GtExprNode | LteExprNode | LtExprNode | ModuloExprNode | MultiplicationExprNode | NeExprNode | OrExprNode | SubtractionExprNode | UnionExprNode;
+export type FilterExprNodes = readonly [ExprNode] | readonly [FunctionCallNode] | readonly [LiteralNode] | readonly [NumberNode];
+export interface FilterExprNode extends SyntaxNode<FilterExprType, FilterExprNodes> {
+}
+export interface FilterPathExprNode extends SyntaxNode<FilterPathExprType, readonly [FilterExprNode, ...Array<RelativeStepSyntaxLiteralNode | StepNode>]> {
+}
+type AbsoluteLocationPathNodes = readonly [AbbreviatedAbsoluteLocationPathNode] | readonly [AbsoluteRootLocationPathNode, ...RelativeLocationPathNodes];
+export interface AbsoluteLocationPathNode extends SyntaxNode<AbsoluteLocationPathType, AbsoluteLocationPathNodes> {
+}
+export interface AbsoluteRootLocationPathNode extends TerminalTextLiteralSyntaxNode<AbsoluteRootLocationPathType, '/'> {
+}
+type RelativeLocationPathNodes = readonly [
+    StepNode,
+    ...Array<RelativeStepSyntaxLiteralNode | StepNode>
+];
+export interface RelativeLocationPathNode extends SyntaxNode<RelativeLocationPathType, RelativeLocationPathNodes> {
+}
+export interface AbbreviatedAbsoluteLocationPathNode extends SyntaxNode<AbbreviatedAbsoluteLocationPathType, readonly [RelativeStepSyntaxLiteralNode, ...RelativeLocationPathNodes]> {
+}
+export interface AbbreviatedAxisTestNode extends SyntaxNode<AbbreviatedAxisTestType, readonly [NameTestNode]> {
+}
+export interface AbbreviatedStepNode extends TerminalTextLiteralSyntaxNode<AbbreviatedStepType, '..' | '.'> {
+}
+export type AxisNameText = 'ancestor-or-self' | 'ancestor' | 'attribute' | 'child' | 'descendant-or-self' | 'descendant' | 'following-sibling' | 'following' | 'namespace' | 'parent' | 'preceding-sibling' | 'preceding' | 'self';
+export interface AxisNameNode extends TerminalTextLiteralSyntaxNode<AxisNameType, AxisNameText> {
+}
+export interface AxisTestNode extends SyntaxNode<AxisTestType, readonly [AxisNameNode, ...NodeTestNodes]> {
+}
+export type NameTestNode = ExplicitNameNode | PrefixedWildcardNameTestNode | UnprefixedWildcardNameTestNode;
+export type NodeTypeTest = 'comment' | 'node' | 'processing-instruction' | 'text';
+export type NodeTypeTestText = `${NodeTypeTest}${string}`;
+export interface NodeTypeTestNode extends TerminalTextLiteralSyntaxNode<NodeTypeTestType, NodeTypeTestText> {
+}
+export interface ProcessingInstructionNameTestNode extends SyntaxNode<ProcessingInstructionNameTestType, readonly [LiteralNode]> {
+}
+export type NodeTestNodes = readonly [NameTestNode] | readonly [NodeTypeTestNode] | readonly [ProcessingInstructionNameTestNode];
+export interface NodeTestNode extends SyntaxNode<NodeTestType, NodeTestNodes> {
+}
+type StepTestNode = AbbreviatedAxisTestNode | AxisTestNode | NodeTestNode;
+type StepNodes = readonly [AbbreviatedStepNode] | readonly [StepTestNode, ...PredicateNode[]];
+export interface StepNode extends SyntaxNode<StepType, StepNodes> {
+}
+export interface ParentNode extends TerminalTextLiteralSyntaxNode<ParentType, '..'> {
+}
+export interface SelfNode extends TerminalTextLiteralSyntaxNode<SelfType, '.'> {
+}
+export interface PredicateNode extends SyntaxNode<PredicateType, readonly [ExprNode]> {
+}
+export interface RelativeStepSyntaxLiteralNode extends TerminalTextLiteralSyntaxNode<RelativeStepSyntaxLiteral, '//'> {
+}
+type AnyLocationPathExprNode = AbsoluteLocationPathNode | FilterPathExprNode | RelativeLocationPathNode;
+type AnyLocationPathNode = AbbreviatedAbsoluteLocationPathNode | AbbreviatedAxisTestNode | AbbreviatedStepNode | AbsoluteRootLocationPathNode | AnyLocationPathExprNode | AxisNameNode | AxisTestNode | FilterExprNode | NodeTestNode | NodeTypeTestNode | ParentNode | PredicateNode | ProcessingInstructionNameTestNode | RelativeStepSyntaxLiteralNode | SelfNode | StepNode;
+export interface FunctionCallNode extends SyntaxNode<FunctionCallType, readonly [FunctionNameNode, ...ArgumentNode[]]> {
+}
+export interface FunctionNameNode extends SyntaxNode<FunctionNameType, readonly [ExplicitNameNode]> {
+}
+export interface ArgumentNode extends SyntaxNode<ArgumentType, readonly [ExprNode]> {
+}
+type AnyFunctionNode = ArgumentNode | FunctionCallNode | FunctionNameNode;
+export interface PrefixNode extends TerminalSyntaxNode<PrefixType> {
+}
+export interface LocalPartNode extends TerminalSyntaxNode<LocalPartType> {
+}
+export interface PrefixedWildcardNameTestNode extends SyntaxNode<PrefixedWildcardNameTestType, readonly [PrefixNode]> {
+}
+export interface UnprefixedWildcardNameTestNode extends TerminalSyntaxNode<UnprefixedWildcardNameTestType> {
+}
+export interface PrefixedNameNode extends SyntaxNode<PrefixedNameType, readonly [PrefixNode, LocalPartNode]> {
+}
+export interface UnprefixedNameNode extends TerminalSyntaxNode<UnprefixedNameType> {
+}
+type ExplicitNameNode = PrefixedNameNode | UnprefixedNameNode;
+export type AnyNameNode = LocalPartNode | PrefixedNameNode | PrefixedWildcardNameTestNode | PrefixNode | UnprefixedNameNode | UnprefixedWildcardNameTestNode;
+export interface NumberNode extends TerminalSyntaxNode<NumberType> {
+}
+export interface LiteralNode extends TerminalSyntaxNode<LiteralType> {
+}
+type AnyLiteralNode = LiteralNode | NumberNode;
+export interface VariableReferenceNode extends TerminalSyntaxNode<VariableReferenceType> {
+}
+type AnyContextuallyScopedNode = VariableReferenceNode;
+export type AnyExprNode = AdditionExprNode | AndExprNode | AnyLocationPathExprNode | DivisionExprNode | EqExprNode | FunctionCallNode | GteExprNode | GtExprNode | LiteralNode | LteExprNode | LtExprNode | ModuloExprNode | MultiplicationExprNode | NeExprNode | NumberNode | OrExprNode | SubtractionExprNode | UnaryExprNode | UnionExprNode;
+/**
+ * @alias {@link LiteralNode}
+ */
+export type StringLiteralNode = LiteralNode;
+export type AnySyntaxNode = AnyBinaryExprNode | AnyContextuallyScopedNode | AnyExprNode | AnyFunctionNode | AnyLiteralNode | AnyLocationPathNode | AnyNameNode | AnyUnaryExprNode | ExprNode | XPathNode;
+export {};

package/dist/static/grammar/SyntaxTree.d.ts

@@ -0,0 +1,6 @@
+import type { SyntaxLanguage } from './SyntaxLanguage.ts';
+import type { XPathNode } from './SyntaxNode.ts';
+export interface SyntaxTree {
+    readonly language: SyntaxLanguage;
+    readonly rootNode: XPathNode;
+}

package/dist/static/grammar/TreeSitterXPathParser.d.ts

@@ -0,0 +1,38 @@
+import WebTreeSitter from 'web-tree-sitter';
+type ParserConstructor = typeof WebTreeSitter;
+type Parser = InstanceType<ParserConstructor>;
+declare let Parser: ParserConstructor;
+export interface WebAssemblyResourceSpecifiers {
+    readonly webTreeSitter: string;
+    readonly xpathLanguage: string;
+}
+/**
+ * `TreeSitterXPathParser` is a separate entry provided by @getodk/xpath as a
+ * simpler means to handle various conditions where the tree-sitter and
+ * @getodk/tree-sitter-xpath WASM resources need to be loaded before we can
+ * begin parsing XPath expressions.
+ *
+ * Note: Loading these resources is (for now) inherently asynchronous, as they
+ * are expected to be loaded with either file system or network calls. This has
+ * two consequences:
+ *
+ * 1. The `TreeSitterXPathParser` constructor cannot be called directly, because
+ *    class constructors must be synchronous. As such, it is marked `protected`
+ *    here, with the public interface being the static, async `init` method.
+ *
+ * 2. While the `init` call itself can happen in any context suited to handle
+ *    its returned Promise, likely use cases (such as our own) will need to
+ *    perform this async initialization upfront before (otherwise synchronous)
+ *    XPath evaluation may proceed. This is more or less a solved problem for
+ *    e.g. @getodk/xforms-engine, which uses ESM in environments supporting
+ *    top-level `await`. But it will require extra consideration in environments
+ *    which currently initialize synchronously (such as enketo-core, should we
+ *    want to adopt this evaluator there).
+ */
+export declare class TreeSitterXPathParser {
+    protected readonly parser: Parser;
+    static init(resources: WebAssemblyResourceSpecifiers): Promise<TreeSitterXPathParser>;
+    protected constructor(parser: Parser);
+    parse(expression: string): WebTreeSitter.Tree;
+}
+export {};

package/dist/static/grammar/type-names.d.ts

@@ -0,0 +1,89 @@
+import type { SyntaxType, UnnamedType } from '@getodk/tree-sitter-xpath';
+/**
+ * The root node of any parsed XPath expression's syntax tree.
+ *
+ * {@link XPathType} will _always_ have one child, of type {@link ExprType}.
+ *
+ */
+export type XPathType = `${SyntaxType.Xpath}`;
+/**
+ * A node representing any complete XPath expression or sub-expression, which
+ * may be either:
+ *
+ * - The direct and only child of {@link XPathType}, representing the top level
+ *   of a parsed XPath expression.
+ *
+ * - A child of any node accepting a full sub-expression, e.g. those passed
+ *   as arguments to a {@link FunctionCallType}
+ */
+export type ExprType = `${SyntaxType.Expr}`;
+type NonOperationExprType = FilterExprType | FilterPathExprType;
+type OperationExprType = Exclude<Extract<SyntaxType, `${string}_expr`>, NonOperationExprType>;
+export type UnaryExprType = `${SyntaxType.UnaryExpr}`;
+export type AdditionExprType = `${SyntaxType.AdditionExpr}`;
+export type AndExprType = `${SyntaxType.AndExpr}`;
+export type DivisionExprType = `${SyntaxType.DivisionExpr}`;
+export type EqExprType = `${SyntaxType.EqExpr}`;
+export type GtExprType = `${SyntaxType.GtExpr}`;
+export type GteExprType = `${SyntaxType.GteExpr}`;
+export type LtExprType = `${SyntaxType.LtExpr}`;
+export type LteExprType = `${SyntaxType.LteExpr}`;
+export type ModuloExprType = `${SyntaxType.ModuloExpr}`;
+export type MultiplicationExprType = `${SyntaxType.MultiplicationExpr}`;
+export type NeExprType = `${SyntaxType.NeExpr}`;
+export type OrExprType = `${SyntaxType.OrExpr}`;
+export type SubtractionExprType = `${SyntaxType.SubtractionExpr}`;
+export type UnionExprType = `${SyntaxType.UnionExpr}`;
+export type BinaryExprType = AdditionExprType | AndExprType | DivisionExprType | EqExprType | GteExprType | GtExprType | LteExprType | LtExprType | ModuloExprType | MultiplicationExprType | NeExprType | OrExprType | SubtractionExprType | UnionExprType;
+export type FilterExprType = `${SyntaxType.FilterExpr}`;
+export type FilterPathExprType = `${SyntaxType.FilterPathExpr}`;
+export type AbsoluteLocationPathType = `${SyntaxType.AbsoluteLocationPath}`;
+export type AbsoluteRootLocationPathType = `${SyntaxType.AbsoluteRootLocationPath}`;
+export type RelativeLocationPathType = `${SyntaxType.RelativeLocationPath}`;
+/**
+ * @example ```xpath
+ * //any-descendant
+ * ```
+ */
+export type AbbreviatedAbsoluteLocationPathType = `${SyntaxType.AbbreviatedAbsoluteLocationPath}`;
+export type AbbreviatedAxisTestType = `${SyntaxType.AbbreviatedAxisTest}`;
+export type AbbreviatedStepType = `${SyntaxType.AbbreviatedStep}`;
+export type AxisNameType = `${SyntaxType.AxisName}`;
+export type AxisTestType = `${SyntaxType.AxisTest}`;
+export type NodeTestType = `${SyntaxType.NodeTest}`;
+export type NodeTypeTestType = `${SyntaxType.NodeTypeTest}`;
+export type ProcessingInstructionNameTestType = `${SyntaxType.ProcessingInstructionNameTest}`;
+export type StepType = `${SyntaxType.Step}`;
+export type ParentType = `${SyntaxType.Parent}`;
+export type SelfType = `${SyntaxType.Self}`;
+export type RelativeStepSyntaxLiteral = Extract<UnnamedType, '//'>;
+export type PredicateType = `${SyntaxType.Predicate}`;
+export type FunctionCallType = `${SyntaxType.FunctionCall}`;
+export type FunctionNameType = `${SyntaxType.FunctionName}`;
+export type ArgumentType = `${SyntaxType.Argument}`;
+export type PrefixedNameType = `${SyntaxType.PrefixedName}`;
+export type PrefixType = `${SyntaxType.Prefix}`;
+export type LocalPartType = `${SyntaxType.LocalPart}`;
+export type PrefixedWildcardNameTestType = `${SyntaxType.PrefixedWildcardNameTest}`;
+export type UnprefixedNameType = `${SyntaxType.UnprefixedName}`;
+export type UnprefixedWildcardNameTestType = `${SyntaxType.UnprefixedWildcardNameTest}`;
+export type VariableReferenceType = `${SyntaxType.VariableReference}`;
+export type NumberType = `${SyntaxType.Number}`;
+export type LiteralType = `${SyntaxType.StringLiteral}`;
+/**
+ * @alias {@link LiteralType}
+ */
+export type StringLiteralType = LiteralType;
+export type ErrorType = `${SyntaxType.ERROR}`;
+type AnyApparentExprType = AdditionExprType | AndExprType | DivisionExprType | EqExprType | FilterPathExprType | FunctionCallType | GteExprType | GtExprType | LiteralType | LteExprType | LtExprType | ModuloExprType | MultiplicationExprType | NeExprType | NumberType | OrExprType | SubtractionExprType | UnaryExprType | UnionExprType;
+export type AnyExprType = AnyApparentExprType;
+export type AnyOperationExprType = OperationExprType;
+export type AnyBinaryExprType = BinaryExprType;
+export type AnyUnaryExprType = UnaryExprType;
+export type AnyLocationPathType = AbbreviatedAbsoluteLocationPathType | AbbreviatedAxisTestType | AbbreviatedStepType | AbsoluteLocationPathType | AbsoluteRootLocationPathType | AxisNameType | AxisTestType | FilterExprType | FilterPathExprType | NodeTestType | NodeTypeTestType | ParentType | PredicateType | ProcessingInstructionNameTestType | RelativeLocationPathType | RelativeStepSyntaxLiteral | SelfType | StepType;
+export type AnyFunctionType = ArgumentType | FunctionCallType | FunctionNameType;
+export type AnyNameType = LocalPartType | PrefixedNameType | PrefixedWildcardNameTestType | PrefixType | UnprefixedNameType | UnprefixedWildcardNameTestType;
+export type AnyLiteralType = LiteralType | NumberType;
+export type AnyContextuallyScopedType = VariableReferenceType;
+export type AnySyntaxType = AnyBinaryExprType | AnyContextuallyScopedType | AnyExprType | AnyFunctionType | AnyLiteralType | AnyLocationPathType | AnyNameType | AnyUnaryExprType | ExprType | XPathType;
+export {};

package/dist/xforms/XFormsItextTranslations.d.ts

@@ -0,0 +1,26 @@
+import type { KnownAttributeLocalNamedElement, LocalNamedElement } from '../../../common/types/dom.ts';
+import type { ModelElement, XFormsXPathEvaluator } from './XFormsXPathEvaluator.ts';
+export interface ItextRootElement extends LocalNamedElement<'itext'> {
+}
+export declare const getItextRoot: (modelElement: ModelElement) => ItextRootElement | null;
+type TranslationLanguage = string;
+interface TranslationTextElement extends KnownAttributeLocalNamedElement<'text', 'id'> {
+}
+type ItextID = string;
+export declare const getTranslationTextByLanguage: (modelElement: ModelElement, language: TranslationLanguage, itextID: ItextID) => TranslationTextElement | null;
+interface DefaultTextValueElement extends LocalNamedElement<'value'> {
+    getAttribute(name: 'form'): null;
+    getAttribute(name: string): string | null;
+}
+export declare const getDefaultTextValueElement: (textElement: TranslationTextElement) => DefaultTextValueElement | null;
+export declare class XFormsItextTranslations {
+    protected readonly evaluator: XFormsXPathEvaluator;
+    protected readonly defaultLanguage: string | null;
+    protected readonly languages: readonly string[];
+    protected activeLanguage: string | null;
+    constructor(evaluator: XFormsXPathEvaluator);
+    getLanguages(): readonly string[];
+    getActiveLanguage(): string | null;
+    setActiveLanguage(language: string | null): string | null;
+}
+export {};

package/dist/xforms/XFormsXPathEvaluator.d.ts

@@ -0,0 +1,18 @@
+import type { EvaluatorOptions } from '../evaluator/Evaluator.ts';
+import { Evaluator } from '../evaluator/Evaluator.ts';
+import type { AnyParentNode } from '../lib/dom/types.ts';
+import { XFormsItextTranslations } from './XFormsItextTranslations.ts';
+export interface ModelElement extends Element {
+    readonly localName: 'model';
+}
+interface XFormsXPathEvaluatorOptions extends EvaluatorOptions {
+    readonly rootNode: AnyParentNode;
+}
+export declare class XFormsXPathEvaluator extends Evaluator {
+    readonly rootNode: AnyParentNode;
+    readonly rootNodeDocument: XMLDocument;
+    readonly modelElement: ModelElement | null;
+    readonly translations: XFormsItextTranslations;
+    constructor(options: XFormsXPathEvaluatorOptions);
+}
+export {};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@getodk/xpath",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "description": "XPath implementation for ODK Web Forms",
+  "type": "module",
+  "author": "getodk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/getodk/web-forms",
+    "directory": "packages/xpath"
+  },
+  "bugs": "https://github.com/getodk/web-forms/issues",
+  "homepage": "https://getodk.org/",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./expressionParser.js": {
+      "types": "./dist/expressionParser.d.ts",
+      "default": "./dist/expressionParser.js"
+    },
+    "./static/grammar/*.js": {
+      "types": "./dist/static/grammar/*.d.ts",
+      "default": "./dist/static/grammar/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": "^18.19.1 || ^20.11.1",
+    "yarn": "1.22.19"
+  },
+  "scripts": {
+    "build": "npm-run-all -nl build:*",
+    "build:clean": "rimraf dist/",
+    "build:js": "vite build",
+    "dev": "vite",
+    "//": "echo '--continue-on-error is temporary, intent to show all test environments running in CI'",
+    "test": "npm-run-all --continue-on-error --print-name --print-label test-node:* test-browser:*",
+    "test-node:jsdom": "vitest run",
+    "test-browser:chromium": "BROWSER_NAME=chromium vitest run",
+    "test-browser:firefox": "BROWSER_NAME=firefox vitest run",
+    "test-browser:webkit": "BROWSER_NAME=webkit vitest run",
+    "test-watch:jsdom": "vitest",
+    "test-watch:chromium": "BROWSER_NAME=chromium vitest",
+    "test-watch:firefox": "BROWSER_NAME=firefox vitest",
+    "test-watch:webkit": "BROWSER_NAME=webkit vitest",
+    "test:types": "tsc --project ./tsconfig.json --emitDeclarationOnly false --noEmit"
+  },
+  "dependencies": {
+    "@js-temporal/polyfill": "^0.4.4",
+    "@getodk/common": "0.1.0",
+    "crypto-js": "^4.1.1",
+    "itertools-ts": "^1.23.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@getodk/tree-sitter-xpath": "0.1.0",
+    "@playwright/test": "^1.42.1",
+    "@types/crypto-js": "^4.1.2",
+    "@vitest/browser": "^1.3.1",
+    "babel-plugin-transform-jsbi-to-bigint": "^1.4.0",
+    "jsdom": "^24.0.0",
+    "vite": "^5.1.5",
+    "vite-plugin-babel": "^1.2.0",
+    "vite-plugin-dts": "^3.7.3",
+    "vite-plugin-no-bundle": "^3.0.0",
+    "vitest": "^1.3.1",
+    "vitest-github-actions-reporter": "^0.11.1",
+    "web-tree-sitter": "0.21.0"
+  }
+}