@getodk/xforms-engine 0.4.0 → 0.6.0

package/dist/lib/names/QualifiedName.d.ts

@@ -0,0 +1,113 @@
+import { NamespaceURL } from './NamespaceURL.ts';
+export type NamespaceURI = NamespaceURL | null;
+export type QualifiedNamePrefix = string | null;
+export interface NamespaceQualifiedNameSource {
+    readonly namespaceURI: NamespaceURI | string;
+    readonly localName: string;
+    /**
+     * Note that this property is intentionally optional as one of the
+     * {@link QualifiedNameSource | QualifiedName source input}, and its absence
+     * is treated differently from an explicitly assigned `null` value.
+     *
+     * @see {@link SourcePrefixUnspecified}, {@link DeferredPrefix}
+     */
+    readonly prefix?: QualifiedNamePrefix;
+}
+declare const SOURCE_PREFIX_UNSPECIFIED: unique symbol;
+/**
+ * May be used as a placeholder for a {@link QualifiedName.prefix}, where the
+ * actual prefix may not be known at definition time.
+ *
+ * Example: parsing non-XML sources into an XML-like tree, e.g. for XPath
+ * evaluation; in which case, we may not need to resolve a prefix for the name
+ * until such a node is serialized as XML, if it ever is.
+ */
+type SourcePrefixUnspecified = typeof SOURCE_PREFIX_UNSPECIFIED;
+/**
+ * Represents a {@link QualifiedName.prefix} whose resolution may be deferred,
+ * e.g. until all requisite parsing is complete and/or until XML serialization
+ * requires use of a prefix to represent the corresponding
+ * {@link QualifiedName.namespaceURI}.
+ */
+type DeferredPrefix = string | null | SourcePrefixUnspecified;
+interface DeferredPrefixedQualifiedNameSource {
+    readonly namespaceURI: NamespaceURI | string;
+    readonly prefix: DeferredPrefix;
+    readonly localName: string;
+}
+export type QualifiedNameSource = NamespaceQualifiedNameSource | DeferredPrefixedQualifiedNameSource;
+interface PrefixResolutionOptions {
+    lookupPrefix(namespaceURI: NamespaceURI | string): string | null;
+}
+/**
+ * @todo This is in the `lib` directory because it's a cross-cutting concern,
+ * applicable to:
+ *
+ * - Parsing XML into a useful runtime data model (usage which motivated initial
+ *   development of this class)
+ * - Serializing XML from a runtime data model (also motivated initial dev)
+ * - `@getodk/xpath` (internal) e.g. references to
+ *   {@link https://www.w3.org/TR/REC-xml-names/#NT-QName | QName} in various
+ *   parts of XPath expression _syntax_, as well as various parts of the package
+ *   interpreting those parts of syntax
+ * - `@getodk/xpath` (cross-package), e.g. in aspects of the
+ *   {@link XPathDOMAdapter} APIs, and implementations thereof
+ * - A zillion potential optimizations, e.g. where names are useful in a lookup
+ *   table (or used in conjunction with other information to construct keys for
+ *   same)
+ *
+ * @todo As a cross-cutting concern, there are subtle but important differences
+ * between certain XPath and XML semantics around expressions of a "null"
+ * {@link prefix}. E.g. in the expression `/foo`, **technically** the `foo` Step
+ * should select child elements _in the null namespace_, whereas in most other
+ * cases a null prefix (when explicitly assigned `null`, rather than
+ * {@link DeferredPrefix | deferred for later resolution}) is expected to
+ * correspond _to the default namespace_ (whatever that is in the context of the
+ * {@link QualifiedName | qualified-named thing}).
+ *
+ * @todo As a mechanism for many optimizations, an evolution of this class would
+ * be **BY FAR** most useful if it can be treated as a _value type_, despite
+ * challenges using non-primitives as such in a JS runtime. To be clear: it
+ * would be most useful if every instance of {@link QualifiedName} having the
+ * same property values (or in some cases, the same combined
+ * {@link namespaceURI}/{@link localName} or combined
+ * {@link prefix}/{@link localName}) would also have _reference equality_ with
+ * other instances having the same property values (or pertinent subset
+ * thereof). Making a somewhat obvious point explicit: this would be
+ * particularly useful in cases where a lookup table is implemented as a native
+ * {@link Map}, where using {@link QualifiedName} as a key would break
+ * expectations (and probably quite a lot of functionality!) if 2+ equivalent
+ * keys mapped to different values.
+ *
+ * @todo Where we would want to treat instances as a value type, it would be
+ * useful to look at prior art for representation of the same data as a string.
+ * One frame of reference worth looking at is
+ * {@link https://www.w3.org/TR/xpath-30/#prod-xpath30-URIQualifiedName | XPath 3.0's URIQualifiedName}
+ * (but note that this syntax is mutually exclusive with the prefixed `QName`).
+ */
+export declare class QualifiedName implements DeferredPrefixedQualifiedNameSource {
+    private readonly defaultPrefixResolutionOptions;
+    readonly namespaceURI: NamespaceURI;
+    /**
+     * @see {@link SourcePrefixUnspecified}, {@link DeferredPrefix}
+     */
+    readonly prefix: DeferredPrefix;
+    readonly localName: string;
+    constructor(source: QualifiedNameSource);
+    /**
+     * @todo at time of writing, it's not expected we will actually supply
+     * {@link options} in calls to this method! Current calls are from definitions
+     * whose prefixes are known at parse time (i.e. they are prefixed in the
+     * source XML from which they're parsed).
+     *
+     * The intent of accepting the options here now is to leave a fairly large
+     * breadcrumb, for any use case where we might want to serialize XML from
+     * artificially constructed DOM-like trees (e.g. `StaticNode` implementations
+     * defined by parsing non-XML external secondary instances such as CSV and
+     * GeoJSON). AFAIK this doesn't correspond to any known feature in the "like
+     * Collect" scope, but it could have implications for inspecting form details
+     * in e.g. "debug/form design/dev mode" scenarios.
+     */
+    getPrefixedName(options?: PrefixResolutionOptions): string;
+}
+export {};

package/dist/lib/number-parsers.d.ts

@@ -0,0 +1,2 @@
+export declare const parseToInteger: (value: string | null) => number | null;
+export declare const parseToFloat: (value: string | null) => number | null;

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

@@ -1,17 +1,18 @@
 import { Accessor, Setter, Signal } from 'solid-js';
+import { FormNodeID } from '../../client/identity.ts';
 import { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
-import { NodeID } from '../../instance/identity.ts';
 export interface ChildrenState<Child extends AnyChildNode> {
     readonly children: Signal<readonly Child[]>;
     readonly getChildren: Accessor<readonly Child[]>;
     readonly setChildren: Setter<readonly Child[]>;
-    readonly childIds: Accessor<readonly NodeID[]>;
+    readonly childIds: Accessor<readonly FormNodeID[]>;
 }
 /**
  * Creates a synchronized pair of:
  *
  * - Internal children state suitable for all parent node types
- * - The same children state computed as an array of each child's {@link NodeID}
+ * - The same children state computed as an array of each child's
+ *   {@link FormNodeID}
  *
  * This state is used, in tandem with {@link materializeCurrentStateChildren},
  * to ensure children in **client-facing** state are not written into nested
@@ -26,11 +27,12 @@ export interface ChildrenState<Child extends AnyChildNode> {
  * The produced {@link ChildrenState.childIds} memo is intended to be used to
  * specify each parent node's `children` in an instance of {@link EngineState}.
  * In so doing, the node's corresponding (internal, synchronized)
- * {@link ClientState} will likewise store only the children's {@link NodeID}s.
+ * {@link ClientState} will likewise store only the children's
+ * {@link FormNodeID}s.
  *
  * As a client reacts to changes in a given parent node's `children` state, that
  * node's {@link CurrentState} should produce the child nodes corresponding to
- * those {@link NodeID}s with the aforementioned
+ * those {@link FormNodeID}s with the aforementioned
  * {@link materializeCurrentStateChildren}.
  */
 export declare const createChildrenState: <Parent extends AnyParentNode, Child extends AnyChildNode>(parent: Parent) => ChildrenState<Child>;

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

@@ -1,17 +1,30 @@
 import { Accessor } from 'solid-js';
 import { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
-import { SubscribableDependency } from '../../instance/internal-api/SubscribableDependency.ts';
+import { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
 import { DependentExpression, DependentExpressionResultType } from '../../parse/expression/abstract/DependentExpression.ts';
 interface ComputedExpressionResults {
     readonly boolean: boolean;
-    readonly nodes: Node[];
+    readonly nodes: EngineXPathNode[];
     readonly number: number;
     readonly string: string;
 }
 type EvaluatedExpression<Type extends DependentExpressionResultType> = ComputedExpressionResults[Type];
 type ComputedExpression<Type extends DependentExpressionResultType> = Accessor<EvaluatedExpression<Type>>;
-interface CreateComputedExpressionOptions {
-    readonly arbitraryDependencies?: readonly SubscribableDependency[];
+interface CreateComputedExpressionOptions<Type extends DependentExpressionResultType> {
+    /**
+     * If a default value is provided, {@link createComputedExpression} will
+     * produce this value for computations in a non-attached evaluation context,
+     * i.e. when evaluating an expression against a node which has not yet been
+     * appended to its parents children state (or which has since been removed
+     * from that state). A non-attached state is detected when
+     * {@link EvaluationContext.isAttached} returns false.
+     *
+     * If no default value is provided, an implicit default value is produced as
+     * appropriate for the expression's intrinsic result type.
+     *
+     * @see {@link defaultEvaluationsByType} for these implicit defaults.
+     */
+    readonly defaultValue?: EvaluatedExpression<Type>;
 }
-export declare const createComputedExpression: <Type extends DependentExpressionResultType>(context: EvaluationContext, dependentExpression: DependentExpression<Type>, options?: CreateComputedExpressionOptions) => ComputedExpression<Type>;
+export declare const createComputedExpression: <Type extends DependentExpressionResultType>(context: EvaluationContext, dependentExpression: DependentExpression<Type>, options?: CreateComputedExpressionOptions<Type>) => ComputedExpression<Type>;
 export {};

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

@@ -0,0 +1,40 @@
+import { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
+import { SimpleAtomicState } from './types.ts';
+type InitialValueSource = 'FORM_DEFAULT' | 'PRIMARY_INSTANCE';
+export interface InstanceValueStateOptions {
+    /**
+     * Specifies the source of a {@link createInstanceValueState} signal's initial
+     * value state, where:
+     *
+     * - 'FORM_DEFAULT': Derives the initial state from the form's definition of
+     *   the node itself. This is the default option, appropriate when
+     *   initializing a form without additional primary instance data. In other
+     *   words, this value should not be used for edits.
+     *
+     * - 'PRIMARY_INSTANCE': Derives the initial state from the current text
+     *   content of the {@link ValueNode.contextNode}. This option should be
+     *   specified when initializing a form with existing primary instance data,
+     *   such as when editing a previous submission.
+     *
+     * @default 'FORM_DEFAULT'
+     *
+     * Specifies whether a {@link createInstanceValueState} signal's initial state
+     * should be derived from the current text content of the
+     * {@link ValueNode.contextNode | primary instance DOM state}.
+     */
+    readonly initialValueSource?: InitialValueSource;
+}
+export type InstanceValueState = SimpleAtomicState<string>;
+/**
+ * Provides a consistent interface for value nodes of any type which:
+ *
+ * - derives initial state from either an existing instance (e.g. for edits) or
+ *   the node's definition (e.g. initializing a new submission)
+ * - decodes current primary instance state into the value node's runtime type
+ * - encodes updated runtime values to store updated instance state
+ * - initializes reactive computation of `calculate` bind expressions for those
+ *   nodes defined with one
+ * - prevents downstream writes to nodes in a readonly state
+ */
+export declare const createInstanceValueState: (context: InstanceValueContext, options?: InstanceValueStateOptions) => InstanceValueState;
+export {};

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

@@ -0,0 +1,21 @@
+import { Accessor } from 'solid-js';
+import { SelectItem } from '../../client/SelectNode.ts';
+import { RankItem } from '../../client/RankNode.ts';
+import { SelectControl } from '../../instance/SelectControl.ts';
+import { RankControl } from '../../instance/RankControl.ts';
+export type ItemCollectionControl = RankControl | SelectControl;
+type Item = RankItem | SelectItem;
+/**
+ * Creates a reactive computation of a {@link ItemCollectionControl}'s
+ * {@link Item}s, in support of the field's `valueOptions`.
+ *
+ * - The control defined with static `<item>`s will compute to an corresponding
+ *   static list of items.
+ * - The control defined with a computed `<itemset>` will compute to a reactive list
+ *   of items.
+ * - Items of both will produce {@link ItemType.label | labels} reactive to
+ *   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 {};

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

@@ -1,4 +1,4 @@
 import { Accessor } from 'solid-js';
 import { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
-import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
-export declare const createNoteReadonlyThunk: (context: EvaluationContext, readonlyDefinition: BindComputationExpression<"readonly">) => Accessor<true>;
+import { NoteNodeDefinition } from '../../parse/model/NoteNodeDefinition.ts';
+export declare const createNoteReadonlyThunk: (context: EvaluationContext, definition: NoteNodeDefinition) => Accessor<true>;

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

@@ -0,0 +1,19 @@
+import { Accessor } from 'solid-js';
+import { ActiveLanguage, FormLanguage, FormLanguages } from '../../client/FormLanguage.ts';
+import { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
+import { ReactiveScope } from './scope.ts';
+import { SimpleAtomicStateSetter } from './types.ts';
+interface TranslationState {
+    readonly languages: FormLanguages;
+    readonly getActiveLanguage: Accessor<ActiveLanguage>;
+    readonly setActiveLanguage: SimpleAtomicStateSetter<FormLanguage>;
+}
+/**
+ * @todo It's been very silly all along that {@link XFormsXPathEvaluator} is
+ * responsible for parsing translation languages, and maintaining the active
+ * language state. It is especially silly now that we've moved _part of the
+ * parsing_ up to the constructor call site. Let's finish off that awkwardness
+ * in a subsequent refactor.
+ */
+export declare const createTranslationState: (scope: ReactiveScope, evaluator: EngineXPathEvaluator) => TranslationState;
+export {};

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

@@ -12,8 +12,7 @@ export interface ValueStateOptions {
      *   other words, this value should not be used for edits.
      *
      * - 'PRIMARY_INSTANCE': Derives the initial state from the current text
-     *   content of the {@link ValueNode.contextNode} (currently an XML DOM
-     *   backing store/source of thruth for primary instance state). This option
+     *   content of the {@link ValueNode.contextNode}. This option
      *   should be specified when initializing a form with existing primary
      *   instance data, such as when editing a previous submission.
      *
@@ -29,16 +28,13 @@ type ValueState<RuntimeValue> = SimpleAtomicState<RuntimeValue>;
 /**
  * Provides a consistent interface for value nodes of any type which:
  *
- * - derives initial state from either the existing primary instance state (e.g.
- *   for edits) or the node's definition (e.g. initializing a new submission)
- * - decodes primary instance state into the value node's runtime type
- * - encodes and persists updated values to the primary instance
+ * - derives initial state from either an existing instance (e.g. for edits) or
+ *   the node's definition (e.g. initializing a new submission)
+ * - decodes current primary instance state into the value node's runtime type
+ * - encodes updated runtime values to store updated instance state
  * - initializes reactive computation of `calculate` bind expressions for those
  *   nodes defined with one
- * - ensures any downstream reactive dependencies are updated only after writes
- *   (whether performed by a client, or by a reactive `calculate` computation)
- *   are persisted, ensuring a consistent view of state when downstream
- *   computations perform XPath evaluations against that primary instance state
+ * - prevents downstream writes to nodes in a readonly state
  */
 export declare const createValueState: <RuntimeValue>(context: ValueContext<RuntimeValue>, options?: ValueStateOptions) => ValueState<RuntimeValue>;
 export {};

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

@@ -1,9 +1,9 @@
+import { FormNodeID } from '../../client/identity.ts';
 import { AnyChildNode } from '../../instance/hierarchy.ts';
-import { NodeID } from '../../instance/identity.ts';
 import { ChildrenState } from './createChildrenState.ts';
 import { ReactiveScope } from './scope.ts';
 export interface EncodedParentState {
-    readonly children: readonly NodeID[];
+    readonly children: readonly FormNodeID[];
 }
 export type MaterializedChildren<BaseState extends EncodedParentState, Child extends AnyChildNode | null> = Omit<BaseState, 'children'> & {
     readonly children: readonly Child[];
@@ -11,8 +11,8 @@ export type MaterializedChildren<BaseState extends EncodedParentState, Child ext
 /**
  * Creates a wrapper proxy around a parent node's {@link CurrentState} to map
  * `children` state, which is written to the node's (internal, synchronized)
- * {@link ClientState} as an array of {@link NodeID}s, back to the node objects
- * corresponding to those IDs.
+ * {@link ClientState} as an array of {@link FormNodeID}s, back to the node
+ * objects corresponding to those IDs.
  *
  * @see {@link createChildrenState} for further detail.
  */

package/dist/lib/xml-serialization.d.ts

@@ -0,0 +1,50 @@
+import { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from './names/QualifiedName.ts';
+declare const ESCAPED_XML_TEXT_BRAND: unique symbol;
+export type EscapedXMLText = string & {
+    readonly [ESCAPED_XML_TEXT_BRAND]: true;
+};
+/**
+ * This is based on the `escapeHTML` implementation in
+ * {@link https://github.com/ryansolid/dom-expressions} (Solid's JSX transform).
+ *
+ * @see {@link https://github.com/ryansolid/dom-expressions/pull/27} for
+ * motivation to derive this implementation approach.
+ *
+ * The intent is that this can be updated easily if the base implementation
+ * changes. As such, some aspects of this implementation differ from some of our
+ * typical code style preferences.
+ *
+ * Notable changes from the base implementation:
+ *
+ * - Formatting: automated only.
+ * - Naming: the {@link text} parameter is named `html` in the base
+ *   implementation. That would be confusing if preserved.
+ * - Types:
+ *     - Parameter types are added (of course)
+ *     - Return type is branded as {@link EscapedXMLText}, to allow downstream
+ *       checks that escaping has been performed. Return statements are cast
+ *       accordingly.
+ *     - {@link text} attempts to minimize risk of double-escaping by excluding
+ *       that same branded type.
+ * - The '>' character is also escaped, necessary for producing valid XML.
+ *
+ * As with the base implementation, we leave some characters unescaped:
+ *
+ * - " (double quote): except when {@link attr} is `true`.
+ *
+ * - ' (single quote): on the assumption that attributes are always serialized
+ *   in double quotes. If we ever move this to `@getodk/common`, we'd want to
+ *   reconsider this assumption.
+ */
+export declare const escapeXMLText: <Text extends string>(text: Exclude<Text, EscapedXMLText>, attr?: boolean) => EscapedXMLText;
+interface SerializableElementAttribute {
+    serializeAttributeXML(): string;
+}
+interface ElementXMLSerializationOptions {
+    readonly namespaceDeclarations?: NamespaceDeclarationMap;
+    readonly attributes?: readonly SerializableElementAttribute[];
+}
+export declare const serializeParentElementXML: (qualifiedName: QualifiedName, serializedChildren: readonly string[], options?: ElementXMLSerializationOptions) => string;
+export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, options?: ElementXMLSerializationOptions) => string;
+export {};

package/dist/parse/XFormDOM.d.ts

@@ -1,24 +1,35 @@
-import { XFormsXPathEvaluator } from '@getodk/xpath';
-interface XFormDOMNormalizationOptions {
+import { KnownAttributeLocalNamedElement } from '../../../common/types/dom.ts';
+interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {
+}
+export interface DOMItextTranslationElement extends KnownAttributeLocalNamedElement<'translation', 'lang'> {
+}
+export interface DOMSecondaryInstanceElement extends KnownAttributeLocalNamedElement<'instance', 'id'> {
+}
+interface XFormDOMOptions {
     readonly isNormalized: boolean;
 }
+/**
+ * @todo **Everything** in this class should be cacheable. Maybe not worth it
+ * for small forms, but may make a pretty substantial difference for very large
+ * forms (in bytes) in sessions creating multiple instances of the same form.
+ */
 export declare class XFormDOM {
     protected readonly sourceXML: string;
     static from(sourceXML: string): XFormDOM;
     protected readonly normalizedXML: string;
-    readonly rootEvaluator: XFormsXPathEvaluator;
-    readonly primaryInstanceEvaluator: XFormsXPathEvaluator;
     readonly xformDocument: XMLDocument;
     readonly html: Element;
     readonly head: Element;
     readonly title: Element;
     readonly model: Element;
+    readonly binds: readonly DOMBindElement[];
     readonly primaryInstance: Element;
     readonly primaryInstanceRoot: Element;
+    readonly itextTranslationElements: readonly DOMItextTranslationElement[];
+    readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
     readonly body: Element;
-    protected constructor(sourceXML: string, options: XFormDOMNormalizationOptions);
-    createInstance(): XFormDOM;
-    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "model" | "primaryInstanceRoot" | "xformDocument" | "rootEvaluator" | "primaryInstanceEvaluator" | "primaryInstance" | "createInstance"> & {
+    protected constructor(sourceXML: string, options: XFormDOMOptions);
+    toJSON(): Omit<this, "head" | "html" | "title" | "primaryInstance" | "model" | "primaryInstanceRoot" | "xformDocument" | "toJSON"> & {
         xformDocument: string;
         html: string;
         head: string;

package/dist/parse/XFormDefinition.d.ts

@@ -2,7 +2,6 @@ import { BodyDefinition } from '../parse/body/BodyDefinition.ts';
 import { ModelDefinition } from './model/ModelDefinition.ts';
 import { XFormDOM } from './XFormDOM.ts';
 export declare class XFormDefinition {
-    readonly sourceXML: string;
     readonly xformDOM: XFormDOM;
     readonly xformDocument: XMLDocument;
     readonly id: string;
@@ -10,5 +9,5 @@ export declare class XFormDefinition {
     readonly rootReference: string;
     readonly body: BodyDefinition;
     readonly model: ModelDefinition;
-    constructor(sourceXML: string);
+    constructor(xformDOM: XFormDOM);
 }

package/dist/parse/attachments/FormAttachmentResource.d.ts

@@ -0,0 +1,27 @@
+import { JRResourceURL } from '../../../../common/src/jr-resources/JRResourceURL.ts';
+export type FormAttachmentDataType = 'media' | 'secondary-instance';
+/**
+ * @todo This type anticipates work to support media form attachments, which
+ * will tend to be associated with binary data. The
+ * expectation is that:
+ *
+ * - {@link Blob} would be appropriate for representing data from attachment
+ *   resources which are conventionally loaded to completion (where network
+ *   conditions are favorable), such as images
+ *
+ * - {@link MediaSource} or {@link ReadableStream} may be more appropriate for
+ *   representing data from resources which are conventionally streamed in a
+ *   browser context (often regardless of network conditions), such as video and
+ *   audio
+ */
+export type FormAttachmentMediaData = Blob | MediaSource | ReadableStream<unknown>;
+export type FormAttachmentSecondaryInstanceData = string;
+type FormAttachmentData<DataType extends FormAttachmentDataType> = DataType extends 'media' ? FormAttachmentMediaData : FormAttachmentSecondaryInstanceData;
+export declare abstract class FormAttachmentResource<DataType extends FormAttachmentDataType> {
+    readonly dataType: DataType;
+    readonly resourceURL: JRResourceURL;
+    readonly contentType: string;
+    readonly data: FormAttachmentData<DataType>;
+    protected constructor(dataType: DataType, resourceURL: JRResourceURL, contentType: string, data: FormAttachmentData<DataType>);
+}
+export {};

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

@@ -1,10 +1,10 @@
 import { ParsedTokenList, TokenListParser } from '../../lib/TokenListParser.ts';
 import { XFormDefinition } from '../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
-import { InputDefinition } from './control/InputDefinition.ts';
+import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import { AnySelectDefinition } from './control/select/SelectDefinition.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';
@@ -17,7 +17,7 @@ export interface BodyElementParentContext {
     readonly reference: string | null;
     readonly element: Element;
 }
-export type ControlElementDefinition = AnySelectDefinition | InputDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
+export type ControlElementDefinition = AnySelectControlDefinition | InputControlDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
 type SupportedBodyElementDefinition = RepeatElementDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | ControlElementDefinition;
 export type AnyBodyElementDefinition = SupportedBodyElementDefinition | UnsupportedBodyElementDefinition;
 export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
@@ -70,6 +70,6 @@ export declare class BodyDefinition extends DependencyContext implements BodyEle
     constructor(form: XFormDefinition);
     getBodyElement(reference: string): AnyBodyElementDefinition | null;
     getChildElementDefinitions(form: XFormDefinition, parent: BodyElementParentContext, parentElement: Element, children?: readonly Element[]): readonly AnyBodyElementDefinition[];
-    toJSON(): Omit<this, "form" | "isTranslated" | "toJSON" | "dependencyExpressions" | "registerDependentExpression" | "getBodyElement" | "getChildElementDefinitions">;
+    toJSON(): Omit<this, "form" | "toJSON" | "isTranslated" | "getBodyElement" | "getChildElementDefinitions">;
 }
 export {};

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

@@ -14,5 +14,5 @@ export declare class RepeatElementDefinition extends BodyElementDefinition<'repe
     readonly noAddRemoveExpression: string | null;
     readonly children: BodyElementDefinitionArray;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
-    toJSON(): Omit<this, "parent" | "form" | "isTranslated" | "toJSON" | "dependencyExpressions" | "registerDependentExpression">;
+    toJSON(): Omit<this, "parent" | "form" | "toJSON" | "isTranslated">;
 }

package/dist/parse/body/appearance/inputAppearanceParser.d.ts

@@ -1,3 +1,3 @@
 import { TokenListParser, ParsedTokenList } from '../../../lib/TokenListParser.ts';
-export declare const inputAppearanceParser: TokenListParser<"multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked", "multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked">;
+export declare const inputAppearanceParser: TokenListParser<"multiline" | "numbers" | "url" | "thousands-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked", "multiline" | "numbers" | "url" | "thousands-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked">;
 export type InputAppearanceDefinition = ParsedTokenList<typeof inputAppearanceParser>;

package/dist/parse/body/appearance/rangeAppearanceParser.d.ts

@@ -0,0 +1,3 @@
+import { ParsedTokenList, TokenListParser } from '../../../lib/TokenListParser.ts';
+export declare const rangeAppearanceParser: TokenListParser<"no-ticks" | "picker" | "rating" | "vertical", "no-ticks" | "picker" | "rating" | "vertical">;
+export type RangeAppearanceDefinition = ParsedTokenList<typeof rangeAppearanceParser>;

package/dist/parse/body/control/{InputDefinition.d.ts → InputControlDefinition.d.ts}

@@ -2,9 +2,12 @@ import { XFormDefinition } from '../../XFormDefinition.ts';
 import { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
-export declare class InputDefinition extends ControlDefinition<'input'> {
+export declare class InputControlDefinition extends ControlDefinition<'input'> {
     static isCompatible(localName: string): boolean;
     readonly type = "input";
     readonly appearances: InputAppearanceDefinition;
+    readonly rows: number | null;
+    readonly accuracyThreshold: number | null;
+    readonly unacceptableAccuracyThreshold: number | null;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
 }

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

@@ -0,0 +1,14 @@
+import { ItemElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../text/ItemLabelDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
+export declare class ItemDefinition extends BodyElementDefinition<'item'> {
+    readonly parent: AnySelectControlDefinition | RankControlDefinition;
+    readonly category = "support";
+    readonly type = "item";
+    readonly label: ItemLabelDefinition | null;
+    readonly value: string;
+    constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemElement);
+}

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

@@ -0,0 +1,18 @@
+import { ItemsetElement } from '../../../lib/dom/query.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';
+export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
+    readonly parent: AnySelectControlDefinition | RankControlDefinition;
+    readonly category = "support";
+    readonly type = "itemset";
+    readonly reference: string;
+    readonly label: ItemsetLabelDefinition | null;
+    readonly nodes: ItemsetNodesetExpression;
+    readonly value: ItemsetValueExpression;
+    constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemsetElement);
+}

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

@@ -1,11 +1,40 @@
 import { XFormDefinition } from '../../XFormDefinition.ts';
-import { UnknownAppearanceDefinition } from '../appearance/unknownAppearanceParser.ts';
+import { RangeAppearanceDefinition } from '../appearance/rangeAppearanceParser.ts';
 import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
+type NumericString = `${number}`;
+/**
+ * Per
+ * {@link https://getodk.github.io/xforms-spec/#body-elements | ODK XForms spec},
+ * the following attributes are required:
+ *
+ * - `start`
+ * - `end`
+ * - `step`
+ *
+ * While we also know that a `<range>` control is expected to have a bind type
+ * of either `decimal` or `int`, at this parsing stage we do not yet know which
+ * type is associated with the control. So we parse the attributes as strings,
+ * checking only that they appear to be numeric values. We also preserve the
+ * attributes' names here, for consistency with the spec.
+ *
+ * Downstream, we parse these to their appropriate numeric runtime types, and
+ * alias them to their more conventional names (i.e. "start" -> "min", "end" ->
+ * "max").
+ */
+export declare class RangeControlBoundsDefinition {
+    readonly start: NumericString;
+    readonly end: NumericString;
+    readonly step: NumericString;
+    static from(element: Element): RangeControlBoundsDefinition;
+    constructor(start: NumericString, end: NumericString, step: NumericString);
+}
 export declare class RangeControlDefinition extends ControlDefinition<'range'> {
     static isCompatible(localName: string): boolean;
     readonly type = "range";
-    readonly appearances: UnknownAppearanceDefinition;
+    readonly appearances: RangeAppearanceDefinition;
+    readonly bounds: RangeControlBoundsDefinition;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
     toJSON(): object;
 }
+export {};