@getodk/xforms-engine 0.12.0 → 0.14.0

package/dist/instance/RankControl.d.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
 import { RankDefinition, RankNode, RankValueOptions } from '../client/RankNode.ts';
 import { TextRange } from '../client/TextRange.ts';
@@ -23,7 +23,7 @@ interface RankControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly valueOptions: Accessor<RankValueOptions>;
 }
-export declare class RankControl extends ValueNode<'string', RankDefinition<'string'>, readonly string[], readonly string[]> implements RankNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
+export declare class RankControl extends ValueNode<'string', RankDefinition<'string'>, readonly string[], readonly string[]> implements RankNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode, XPathChoiceNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: RankDefinition): RankControl;
     private readonly mapOptionsByValue;
     protected readonly getInstanceValue: Accessor<string>;
@@ -37,5 +37,6 @@ export declare class RankControl extends ValueNode<'string', RankDefinition<'str
     private constructor();
     getValueLabel(value: string): TextRange<'item-label'> | null;
     setValues(valuesInOrder: readonly string[]): Root;
+    getChoiceName(value: string): string | null;
 }
 export {};

package/dist/instance/SelectControl.d.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
 import { SelectDefinition, SelectItem, SelectNode, SelectNodeAppearances, SelectValueOptions } from '../client/SelectNode.ts';
 import { TextRange } from '../client/TextRange.ts';
@@ -24,7 +24,7 @@ interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     readonly valueOptions: Accessor<SelectValueOptions>;
     readonly isSelectWithImages: Accessor<boolean>;
 }
-export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
+export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode, XPathChoiceNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: SelectDefinition): SelectControl;
     private readonly mapOptionsByValue;
     protected readonly getInstanceValue: Accessor<string>;
@@ -64,5 +64,6 @@ export declare class SelectControl extends ValueNode<'string', SelectDefinition<
     isSelected(value: string): boolean;
     selectValue(value: string | null): Root;
     selectValues(values: readonly string[]): Root;
+    getChoiceName(value: string): string | null;
 }
 export {};

package/dist/instance/hierarchy.d.ts

@@ -10,13 +10,12 @@ import { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
 import { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import { Root } from './Root.ts';
 import { SelectControl } from './SelectControl.ts';
-import { Subtree } from './Subtree.ts';
 import { TriggerControl } from './TriggerControl.ts';
 import { UploadControl } from './UploadControl.ts';
 export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
-export type AnyNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance | AnyNote | AnyModelValue | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
-export type AnyParentNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance;
-export type GeneralParentNode = Root | Group | Subtree | RepeatInstance;
-export type AnyChildNode = Root | Group | Subtree | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
-export type GeneralChildNode = Group | Subtree | RepeatRange | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
+export type AnyNode = PrimaryInstance | Root | Group | RepeatRange | RepeatInstance | AnyNote | AnyModelValue | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
+export type AnyParentNode = PrimaryInstance | Root | Group | RepeatRange | RepeatInstance;
+export type GeneralParentNode = Root | Group | RepeatInstance;
+export type AnyChildNode = Root | Group | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
+export type GeneralChildNode = Group | RepeatRange | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
 export type AnyValueNode = AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;

package/dist/instance/markdown/MarkdownNode.d.ts

@@ -0,0 +1,75 @@
+import { AnchorMarkdownNode, ChildMarkdownNode as ClientChildMarkdownNode, HtmlMarkdownNode as ClientHtmlMarkdownNode, ParentMarkdownNode as ClientParentMarkdownNode, StyledMarkdownNode as ClientStyledMarkdownNode, ElementName, MarkdownNode, MarkdownProperty } from '../../client';
+declare abstract class ParentMarkdownNode implements ClientParentMarkdownNode {
+    readonly children: MarkdownNode[];
+    readonly role = "parent";
+    abstract elementName: ElementName;
+    constructor(children: MarkdownNode[]);
+}
+export declare class Heading1 extends ParentMarkdownNode {
+    readonly elementName = "h1";
+}
+export declare class Heading2 extends ParentMarkdownNode {
+    readonly elementName = "h2";
+}
+export declare class Heading3 extends ParentMarkdownNode {
+    readonly elementName = "h3";
+}
+export declare class Heading4 extends ParentMarkdownNode {
+    readonly elementName = "h4";
+}
+export declare class Heading5 extends ParentMarkdownNode {
+    readonly elementName = "h5";
+}
+export declare class Heading6 extends ParentMarkdownNode {
+    readonly elementName = "h6";
+}
+export declare class Strong extends ParentMarkdownNode {
+    readonly elementName = "strong";
+}
+export declare class Underline extends ParentMarkdownNode {
+    readonly elementName = "u";
+}
+export declare class Emphasis extends ParentMarkdownNode {
+    readonly elementName = "em";
+}
+export declare class OrderedList extends ParentMarkdownNode {
+    readonly elementName = "ol";
+}
+export declare class UnorderedList extends ParentMarkdownNode {
+    readonly elementName = "ul";
+}
+export declare class ListItem extends ParentMarkdownNode {
+    readonly elementName = "li";
+}
+export declare class Anchor extends ParentMarkdownNode implements AnchorMarkdownNode {
+    readonly elementName = "a";
+    readonly url: string;
+    constructor(children: MarkdownNode[], url: string);
+}
+declare abstract class StyledMarkdownNode implements ClientParentMarkdownNode {
+    readonly children: MarkdownNode[];
+    readonly role = "parent";
+    abstract elementName: ElementName;
+    readonly properties: MarkdownProperty | undefined;
+    constructor(children: MarkdownNode[], properties: MarkdownProperty | undefined);
+}
+export declare class Paragraph extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "p";
+}
+export declare class Span extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "span";
+}
+export declare class Div extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "div";
+}
+export declare class ChildMarkdownNode implements ClientChildMarkdownNode {
+    readonly role = "child";
+    readonly value: string;
+    constructor(value: string);
+}
+export declare class Html implements ClientHtmlMarkdownNode {
+    readonly role = "html";
+    readonly unsafeHtml: string;
+    constructor(unsafeHtml: string);
+}
+export {};

package/dist/instance/text/TextChunk.d.ts

@@ -5,7 +5,6 @@ export declare class TextChunk implements ClientTextChunk {
     readonly context: TranslationContext;
     readonly source: TextChunkSource;
     readonly asString: string;
-    get formatted(): Record<PropertyKey, unknown>;
     get language(): ActiveLanguage;
     constructor(context: TranslationContext, source: TextChunkSource, asString: string);
 }

package/dist/instance/text/TextRange.d.ts

@@ -1,4 +1,5 @@
 import { JRResourceURL } from '../../../../common/src/jr-resources/JRResourceURL.ts';
+import { MarkdownNode } from '../../client/MarkdownNode.ts';
 import { TextRange as ClientTextRange, TextChunk, TextOrigin, TextRole } from '../../client/TextRange.ts';
 export interface MediaSources {
     image?: JRResourceURL;
@@ -11,7 +12,7 @@ export declare class TextRange<Role extends TextRole, Origin extends TextOrigin>
     protected readonly chunks: readonly TextChunk[];
     protected readonly mediaSources?: MediaSources | undefined;
     [Symbol.iterator](): Generator<TextChunk, void, unknown>;
-    get formatted(): Record<PropertyKey, unknown>;
+    get formatted(): MarkdownNode[];
     get asString(): string;
     get imageSource(): JRResourceURL | undefined;
     get audioSource(): JRResourceURL | undefined;

package/dist/instance/text/markdownFormat.d.ts

@@ -0,0 +1,3 @@
+import { MarkdownNode } from '../../client';
+import { TextChunk } from '../../client/TextRange.ts';
+export declare function format(chunks: readonly TextChunk[]): MarkdownNode[];

package/dist/lib/reactivity/createItemCollection.d.ts

@@ -1,13 +1,11 @@
 import { Accessor } from 'solid-js';
-import { SelectItem } from '../../client/SelectNode.ts';
-import { RankItem } from '../../client/RankNode.ts';
-import { SelectControl } from '../../instance/SelectControl.ts';
+import { BaseItem } from '../../client/BaseItem.ts';
 import { RankControl } from '../../instance/RankControl.ts';
-export type ItemCollectionControl = RankControl | SelectControl;
-type Item = RankItem | SelectItem;
+import { SelectControl } from '../../instance/SelectControl.ts';
+type ItemCollectionControl = RankControl | SelectControl;
 /**
  * Creates a reactive computation of a {@link ItemCollectionControl}'s
- * {@link Item}s, in support of the field's `valueOptions`.
+ * {@link BaseItem}s, in support of the field's `valueOptions`.
  *
  * - The control defined with static `<item>`s will compute to an corresponding
  *   static list of items.
@@ -17,5 +15,5 @@ type Item = RankItem | SelectItem;
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export declare const createItemCollection: (control: ItemCollectionControl) => Accessor<readonly Item[]>;
+export declare const createItemCollection: (control: ItemCollectionControl) => Accessor<readonly BaseItem[]>;
 export {};

package/dist/parse/body/BodyDefinition.d.ts

@@ -7,9 +7,7 @@ import { RankControlDefinition } from './control/RankControlDefinition.ts';
 import { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
-import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
-import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+import { GroupElementDefinition } from './GroupElementDefinition.ts';
 import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
 import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 export interface BodyElementParentContext {
@@ -18,14 +16,10 @@ export interface BodyElementParentContext {
     readonly element: Element;
 }
 export type ControlElementDefinition = AnySelectControlDefinition | InputControlDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
-type SupportedBodyElementDefinition = RepeatElementDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | ControlElementDefinition;
+type SupportedBodyElementDefinition = ControlElementDefinition | GroupElementDefinition | RepeatElementDefinition;
 export type AnyBodyElementDefinition = SupportedBodyElementDefinition | UnsupportedBodyElementDefinition;
 export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
 export type AnyBodyElementType = AnyBodyElementDefinition['type'];
-export type AnyGroupElementDefinition = Extract<AnyBodyElementDefinition, {
-    readonly type: `${string}-group`;
-}>;
-export declare const groupElementDefinition: (element: AnyBodyElementDefinition) => AnyGroupElementDefinition | null;
 export type AnyControlElementDefinition = Extract<AnyBodyElementDefinition, {
     readonly category: 'control';
 }>;

package/dist/parse/body/GroupElementDefinition.d.ts

@@ -0,0 +1,22 @@
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
+import { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+/**
+ * As per the spec: https://getodk.github.io/xforms-spec/#groups
+ *
+ * A group combines elements together.
+ * The group can have a label, and if so is referred to as a "presentation group".
+ * The group can have a ref, and if so is referred to as a "logical group".
+ */
+export declare class GroupElementDefinition extends BodyElementDefinition<'group'> {
+    readonly category = "structure";
+    readonly type = "group";
+    readonly children: BodyElementDefinitionArray;
+    readonly reference: string | null;
+    readonly appearances: StructureElementAppearanceDefinition;
+    readonly label: LabelDefinition | null;
+    static isCompatible(localName: string): boolean;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}

package/dist/parse/body/control/ItemsetDefinition.d.ts

@@ -1,11 +1,13 @@
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import { ItemsetElement } from '../../../lib/dom/query.ts';
+import { DependentExpression } from '../../expression/abstract/DependentExpression.ts';
 import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
 import { XFormDefinition } from '../../XFormDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 import { RankControlDefinition } from './RankControlDefinition.ts';
+import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
     readonly parent: AnySelectControlDefinition | RankControlDefinition;
     readonly category = "support";
@@ -15,4 +17,5 @@ export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'>
     readonly nodes: ItemsetNodesetExpression;
     readonly value: ItemsetValueExpression;
     constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemsetElement);
+    getPropertiesExpressions(propertiesNodes: StaticElement[]): Array<DependentExpression<'string'>>;
 }

package/dist/parse/expression/BindComputationExpression.d.ts

@@ -25,6 +25,6 @@ export declare class BindComputationExpression<Computation extends BindComputati
     readonly computation: Computation;
     static forComputation<Type extends BindComputationType>(bind: BindDefinition, computation: Type): BindComputationFactoryResult<Type>;
     readonly isDefaultExpression: boolean;
-    protected constructor(bind: BindDefinition, computation: Computation, expression: string | null);
+    protected constructor(computation: Computation, expression: string | null);
 }
 export {};

package/dist/parse/expression/ItemPropertyExpression.d.ts

@@ -0,0 +1,6 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+export declare class ItemPropertyExpression extends DependentExpression<'string'> {
+    static from(propertiesNodes: StaticElement[]): ItemPropertyExpression[];
+    constructor(propertyName: string);
+}

package/dist/parse/expression/ItemsetNodesetExpression.d.ts

@@ -1,5 +1,4 @@
-import { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 export declare class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
-    constructor(itemset: ItemsetDefinition, nodesetExpression: string);
+    constructor(nodesetExpression: string);
 }

package/dist/parse/expression/TextChunkExpression.d.ts

@@ -1,16 +1,18 @@
+import { JRResourceURLString, ResourceType } from '../../../../common/src/jr-resources/JRResourceURL.ts';
 import { TextChunkSource } from '../../client/TextRange.ts';
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 interface TextChunkExpressionOptions {
-    readonly isTranslated?: true;
+    readonly type?: ResourceType;
 }
 export declare class TextChunkExpression<T extends 'nodes' | 'string'> extends DependentExpression<T> {
     readonly source: TextChunkSource;
     readonly stringValue: string;
-    constructor(context: AnyTextRangeDefinition, resultType: T, expression: string, source: TextChunkSource, options?: TextChunkExpressionOptions, literalValue?: string);
-    static fromLiteral(context: AnyTextRangeDefinition, stringValue: string): TextChunkExpression<'string'>;
-    static fromReference(context: AnyTextRangeDefinition, ref: string): TextChunkExpression<'string'>;
-    static fromOutput(context: AnyTextRangeDefinition, element: Element): TextChunkExpression<'string'> | null;
-    static fromTranslation(context: AnyTextRangeDefinition, maybeExpression: string): TextChunkExpression<'nodes'> | null;
+    readonly resourceType: ResourceType | null;
+    constructor(resultType: T, expression: string, source: TextChunkSource, literalValue?: string, options?: TextChunkExpressionOptions);
+    static fromLiteral(stringValue: string): TextChunkExpression<'string'>;
+    static fromReference(ref: string): TextChunkExpression<'string'>;
+    static fromOutput(element: Element): TextChunkExpression<'string'> | null;
+    static fromResource(url: JRResourceURLString, type: ResourceType): TextChunkExpression<'string'>;
+    static fromTranslation(maybeExpression: string): TextChunkExpression<'nodes'> | null;
 }
 export {};

package/dist/parse/expression/abstract/DependentExpression.d.ts

@@ -1,6 +1,5 @@
 import { EngineXPathEvaluator } from '../../../integration/xpath/EngineXPathEvaluator.ts';
 import { ConstantExpression, ConstantTruthyExpression } from '../../xpath/semantic-analysis.ts';
-import { DependencyContext } from './DependencyContext.ts';
 declare const evaluatorMethodsByResultType: {
     readonly boolean: "evaluateBoolean";
     readonly nodes: "evaluateNodes";
@@ -11,19 +10,6 @@ type EvaluatorMethodsByResultType = typeof evaluatorMethodsByResultType;
 export type DependentExpressionResultType = keyof EvaluatorMethodsByResultType;
 export type DependentExpressionEvaluatorMethod<Type extends DependentExpressionResultType> = EvaluatorMethodsByResultType[Type];
 export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<EngineXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]>;
-interface SemanticDependencyOptions {
-    /**
-     * @default false
-     */
-    readonly translations?: boolean | undefined;
-}
-interface DependentExpressionOptions {
-    /**
-     * @default false
-     */
-    readonly ignoreContextReference?: boolean;
-    readonly semanticDependencies?: SemanticDependencyOptions;
-}
 export interface ConstantDependentExpression<Type extends DependentExpressionResultType> extends DependentExpression<Type> {
     readonly expression: ConstantExpression;
 }
@@ -37,7 +23,7 @@ export declare abstract class DependentExpression<Type extends DependentExpressi
     readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
     readonly constantExpression: ConstantExpression | null;
     readonly constantTruthyExpression: ConstantTruthyExpression | null;
-    constructor(context: DependencyContext, resultType: Type, expression: string, options?: DependentExpressionOptions);
+    constructor(resultType: Type, expression: string);
     isConstantExpression(): this is ConstantDependentExpression<Type>;
     isConstantTruthyExpression(): this is ConstantTruthyDependentExpression;
     toString(): string | null;

package/dist/parse/model/{SubtreeDefinition.d.ts → GroupDefinition.d.ts}

@@ -1,13 +1,14 @@
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
-import { AnyBodyElementDefinition, AnyGroupElementDefinition } from '../body/BodyDefinition.ts';
+import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null> {
+export declare class GroupDefinition extends DescendentNodeDefinition<'group', GroupElementDefinition | null> {
     readonly template: StaticElement;
-    readonly type = "subtree";
+    readonly type = "group";
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly qualifiedName: QualifiedName;
     readonly children: readonly ChildNodeDefinition[];

package/dist/parse/model/ModelDefinition.d.ts

@@ -1,5 +1,8 @@
+import { ActiveLanguage } from '../../client/FormLanguage.ts';
 import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
+import { ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import { AnyNodeDefinition } from './NodeDefinition.ts';
@@ -12,8 +15,10 @@ export declare class ModelDefinition {
     readonly nodes: NodeDefinitionMap;
     readonly instance: StaticDocument;
     readonly itextTranslations: ItextTranslationsDefinition;
+    readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
     constructor(form: XFormDefinition);
     getNodeDefinition(nodeset: string): AnyNodeDefinition;
     getRootDefinition(instance: StaticDocument): RootDefinition;
-    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition">;
+    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition" | "getTranslationChunks">;
+    getTranslationChunks(itextId: string, activeLanguage: ActiveLanguage): ReadonlyArray<TextChunkExpression<'string'>>;
 }

package/dist/parse/model/NodeDefinition.d.ts

@@ -4,10 +4,10 @@ import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
+import { GroupDefinition } from './GroupDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import { AnyRepeatDefinition } from './RepeatDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
-import { SubtreeDefinition } from './SubtreeDefinition.ts';
 /**
  * Corresponds to a model instance root node, i.e.:
  *
@@ -27,10 +27,9 @@ export type RootNodeType = 'root';
 export type RepeatType = 'repeat';
 /**
  * Corresponds to a model instance subtree which **does not** correspond to a
- * <repeat> in the form definition. This will typically correspond to a <group>,
- * but this is not strictly necessary per spec (hence the distinct name).
+ * <repeat> in the form definition.
  */
-export type SubtreeNodeType = 'subtree';
+export type GroupNodeType = 'group';
 /**
  * Corresponds to a model instance leaf node, i.e. one of:
  *
@@ -38,9 +37,9 @@ export type SubtreeNodeType = 'subtree';
  * - Any attribute corresponding to a bind's `nodeset` expression
  */
 export type LeafNodeType = 'leaf-node';
-export type NodeDefinitionType = RootNodeType | RepeatType | SubtreeNodeType | LeafNodeType;
-export type ParentNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition;
-export type ChildNodeDefinition = AnyRepeatDefinition | LeafNodeDefinition | SubtreeDefinition;
+export type NodeDefinitionType = RootNodeType | RepeatType | GroupNodeType | LeafNodeType;
+export type ParentNodeDefinition = RootDefinition | AnyRepeatDefinition | GroupDefinition;
+export type ChildNodeDefinition = AnyRepeatDefinition | GroupDefinition | LeafNodeDefinition;
 export declare abstract class NodeDefinition<Type extends NodeDefinitionType> implements NamedSubtreeDefinition {
     readonly bind: BindDefinition;
     abstract readonly type: Type;
@@ -55,4 +54,4 @@ export declare abstract class NodeDefinition<Type extends NodeDefinitionType> im
     readonly nodeset: string;
     constructor(bind: BindDefinition);
 }
-export type AnyNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition | LeafNodeDefinition;
+export type AnyNodeDefinition = RootDefinition | AnyRepeatDefinition | GroupDefinition | LeafNodeDefinition;

package/dist/parse/model/RepeatDefinition.d.ts

@@ -18,7 +18,7 @@ export interface UncontrolledRepeatDefinition extends RepeatDefinition {
  * "repeat", as defined by a form, where those concepts include:
  *
  * - A {@link RepeatElementDefinition}—corresponding to a `<repeat>` {@link https://getodk.github.io/xforms-spec/#body-elements | body element}—which is associated with the nodeset referencing the "repeat template" and
- *   all "repeat instances" (see below points describing both concepts in more detail). The presence of such a body element determines whether to produce a repeat definition (rather than e.g. a {@link SubtreeDefinition}).
+ *   all "repeat instances" (see below points describing both concepts in more detail). The presence of such a body element determines whether to produce a repeat definition (rather than e.g. a {@link GroupDefinition}).
  *
  * - A "repeat template", defined by a form either
  *   explicitly,

package/dist/parse/model/RootDefinition.d.ts

@@ -24,5 +24,5 @@ export declare class RootDefinition extends NodeDefinition<'root'> {
     readonly isTranslated = false;
     constructor(form: XFormDefinition, model: ModelDefinition, submission: SubmissionDefinition, classes: BodyClassList);
     buildSubtree(parent: ParentNodeDefinition, node: StaticElement): readonly ChildNodeDefinition[];
-    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "root" | "model" | "bodyElement" | "buildSubtree">;
+    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "model" | "root" | "bodyElement" | "buildSubtree">;
 }

package/dist/parse/model/generateItextChunks.d.ts

@@ -0,0 +1,5 @@
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
+import { DOMItextTranslationElement } from '../XFormDOM.ts';
+export interface ChunkExpressionsByItextId extends Map<string, ReadonlyArray<TextChunkExpression<'string'>>> {
+}
+export declare const generateItextChunks: (translationElements: readonly DOMItextTranslationElement[]) => Map<string, ChunkExpressionsByItextId>;

package/dist/parse/text/LabelDefinition.d.ts

@@ -1,14 +1,13 @@
 import { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import { AnyGroupElementDefinition } from '../../parse/body/BodyDefinition.ts';
-import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
-import { BaseGroupDefinition } from '../body/group/BaseGroupDefinition.ts';
+import { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
-export type LabelOwner = AnyControlDefinition | AnyGroupElementDefinition | RepeatElementDefinition;
+export type LabelOwner = AnyControlDefinition | GroupElementDefinition | RepeatElementDefinition;
 export declare class LabelDefinition extends TextElementDefinition<'label'> {
     static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null;
     static forRepeatGroup(form: XFormDefinition, repeat: RepeatElementDefinition): LabelDefinition | null;
-    static forGroup(form: XFormDefinition, group: BaseGroupDefinition<any>): LabelDefinition | null;
+    static forGroup(form: XFormDefinition, group: GroupElementDefinition): LabelDefinition | null;
     readonly role = "label";
     private constructor();
 }

package/dist/parse/xpath/semantic-analysis.d.ts

@@ -11,6 +11,7 @@ export type TranslationExpression = LocalNamedFunctionCallLiteral<'itext'>;
  * arbitrary expression may call `jr:itext`.
  */
 export declare const isTranslationExpression: (expression: string) => expression is TranslationExpression;
+export declare const getTranslationExpression: (expression: string) => string | null;
 /**
  * Predicate to determine if a FilterPathExpr (as currently produced by
  * `tree-sitter-xpath`) is one of: