@getodk/xforms-engine 0.6.0 → 0.8.0

package/src/parse/body/control/UploadControlDefinition.ts

@@ -1,3 +1,5 @@
+import type { UploadMediaOptions, UploadNodeOptions } from '../../../client/UploadNode.ts';
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import {
 	unknownAppearanceParser,
@@ -6,6 +8,44 @@ import {
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
+const MEDIATYPE_PATTERN = /^([^/]+)\/([^/]+)$/;
+
+// prettier-ignore
+type MediaTypeMatches =
+	| readonly [$0: string, $1: string, $2: string];
+
+const parseUploadMediaOptions = (element: Element): UploadMediaOptions => {
+	const mediaType = element.getAttribute('mediatype')?.trim();
+
+	if (mediaType == null || mediaType === '') {
+		return {
+			accept: '*',
+			type: null,
+			subtype: null,
+		};
+	}
+
+	const matches = MEDIATYPE_PATTERN.exec(mediaType) as MediaTypeMatches | null;
+
+	if (matches == null) {
+		throw new ErrorProductionDesignPendingError(`Unsupported mediatype: ${mediaType}`);
+	}
+
+	const [accept, type, subtype] = matches;
+
+	return {
+		accept,
+		type,
+		subtype,
+	};
+};
+
+const parseUploadNodeOptions = (element: Element): UploadNodeOptions => {
+	const media = parseUploadMediaOptions(element);
+
+	return { media };
+};
+
 export class UploadControlDefinition extends ControlDefinition<'upload'> {
 	static override isCompatible(localName: string): boolean {
 		return localName === 'upload';
@@ -13,11 +53,13 @@ export class UploadControlDefinition extends ControlDefinition<'upload'> {
 
 	readonly type = 'upload';
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly options: UploadNodeOptions;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		this.options = parseUploadNodeOptions(element);
 	}
 
 	override toJSON(): object {

package/src/parse/model/BindDefinition.ts

@@ -80,7 +80,7 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 	) {
 		super();
 
-		this.type = BindTypeDefinition.from(bindElement);
+		this.type = BindTypeDefinition.from(form, nodeset, bindElement);
 
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 

package/src/parse/model/BindTypeDefinition.ts

@@ -1,19 +1,14 @@
 import { XSD_NAMESPACE_URI, XSD_PREFIX } from '@getodk/common/constants/xmlns.ts';
+import type { AnyBodyElementType } from '../body/BodyDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
 import { parseQualifiedNameExpression } from '../xpath/semantic-analysis.ts';
 import type { BindElement } from './BindElement.ts';
 
-/**
- * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
- */
-export const DEFAULT_BIND_TYPE = 'string';
-
-export type DefaultBindType = typeof DEFAULT_BIND_TYPE;
-
 /**
  * As specified by {@link https://getodk.github.io/xforms-spec/#data-types}
  */
 const BIND_TYPES = [
-	DEFAULT_BIND_TYPE,
+	'string',
 	'int',
 	'boolean',
 	'decimal',
@@ -32,6 +27,47 @@ type BindTypes = typeof BIND_TYPES;
 
 export type BindType = BindTypes[number];
 
+type BindTypeDefaultOverridesByBodyType = Partial<Readonly<Record<AnyBodyElementType, BindType>>>;
+
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
+ */
+const SPEC_BIND_TYPE_DEFAULT = 'string' satisfies BindType;
+
+/**
+ * If an `<upload>` is not explicitly associated with any `<bind type>`, we can do one of two things:
+ *
+ * - correct: default to {@link SPEC_BIND_TYPE_DEFAULT | the spec default regardless of control type}
+ * - more useful and robust: default to "binary", which is the only type the spec allows for an `<upload>` control
+ *
+ * Asked which would be preferable, @lognaturel responded:
+ *
+ * > I think we should assume in the spirit of doing the most useful thing!
+ */
+const UPLOAD_BIND_TYPE_DEFAULT = 'binary' satisfies BindType;
+
+const BODY_BIND_TYPE_DEFAULT_OVERRIDES = {
+	upload: UPLOAD_BIND_TYPE_DEFAULT,
+} as const satisfies BindTypeDefaultOverridesByBodyType;
+
+type BodyBindTypeDefaultOverrides = typeof BODY_BIND_TYPE_DEFAULT_OVERRIDES;
+
+type BodyBindTypeDefaultOverride = keyof BodyBindTypeDefaultOverrides;
+
+const isBodyBindTypeDefaultOverride = (
+	bodyElementType: AnyBodyElementType | null
+): bodyElementType is BodyBindTypeDefaultOverride => {
+	return bodyElementType != null && bodyElementType in BODY_BIND_TYPE_DEFAULT_OVERRIDES;
+};
+
+const resolveDefaultBindType = (bodyElementType: AnyBodyElementType | null): BindType => {
+	if (isBodyBindTypeDefaultOverride(bodyElementType)) {
+		return BODY_BIND_TYPE_DEFAULT_OVERRIDES[bodyElementType];
+	}
+
+	return SPEC_BIND_TYPE_DEFAULT;
+};
+
 const isBindType = (value: string): value is BindType => {
 	return BIND_TYPES.includes(value as BindType);
 };
@@ -42,14 +78,10 @@ const resolveSupportedBindType = (sourceType: string): BindType | null => {
 
 type BindTypeAliasMapping = Readonly<Record<string, BindType>>;
 
-/**
- * @todo should we make these aliases explicit (rather than relying on {@link resolveUnsupportedBindType})?
- *
- * - select1
- * - rank
- * - odk:rank
- */
 const BIND_TYPE_ALIASES: BindTypeAliasMapping = {
+	select1: SPEC_BIND_TYPE_DEFAULT,
+	rank: SPEC_BIND_TYPE_DEFAULT,
+	'odk:rank': SPEC_BIND_TYPE_DEFAULT,
 	integer: 'int',
 };
 
@@ -65,7 +97,7 @@ const resolveAliasedBindType = (sourceType: string): BindType | null => {
  * @todo Should we warn on this fallback?
  */
 const resolveUnsupportedBindType = (_unsupportedType: string): BindType => {
-	return DEFAULT_BIND_TYPE;
+	return SPEC_BIND_TYPE_DEFAULT;
 };
 
 interface BindDataTypeNamespaceResolver {
@@ -144,7 +176,15 @@ const resolveNamespacedBindType = (
 	return null;
 };
 
-const resolveBindType = (bindElement: BindElement, sourceType: string): BindType => {
+const resolveBindType = (
+	bodyElementType: AnyBodyElementType | null,
+	bindElement: BindElement,
+	sourceType: string | null
+): BindType => {
+	if (sourceType == null) {
+		return resolveDefaultBindType(bodyElementType);
+	}
+
 	return (
 		resolveSupportedBindType(sourceType) ??
 		resolveAliasedBindType(sourceType) ??
@@ -154,20 +194,22 @@ const resolveBindType = (bindElement: BindElement, sourceType: string): BindType
 };
 
 export class BindTypeDefinition<T extends BindType = BindType> {
-	static from<T extends BindType>(bindElement: BindElement): BindTypeDefinition<T> {
+	static from<T extends BindType>(
+		form: XFormDefinition,
+		nodeset: string,
+		bindElement: BindElement
+	): BindTypeDefinition<T> {
+		const bodyElementType = form.body.getBodyElementType(nodeset);
 		const sourceType = bindElement.getAttribute('type');
-
-		if (sourceType == null) {
-			return new this(sourceType, DEFAULT_BIND_TYPE);
-		}
-
-		const resolved = resolveBindType(bindElement, sourceType);
+		const resolved = resolveBindType(
+			bodyElementType,
+			bindElement,
+			sourceType
+		) satisfies BindType as T;
 
 		return new this(sourceType, resolved);
 	}
 
-	private constructor(source: null, resolved: DefaultBindType);
-	private constructor(source: string, resolved: BindType);
 	private constructor(
 		readonly source: string | null,
 		readonly resolved: T

package/src/parse/model/ItextTranslationsDefinition.ts

@@ -0,0 +1,79 @@
+import type {
+	XFORMS_KNOWN_ATTRIBUTE,
+	XFORMS_LOCAL_NAME,
+	XFormsItextTranslationMap,
+} from '@getodk/xpath';
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import type { XFormDOM } from '../XFormDOM.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocumentFromDOMSubtree.ts';
+
+export interface ItextTranslationDefinition extends StaticDocument {
+	readonly rootDocument: ItextTranslationDefinition;
+	readonly root: ItextTranslationRootDefinition;
+}
+
+export interface ItextTranslationRootDefinition extends StaticElement {
+	readonly [XFORMS_LOCAL_NAME]: 'translation';
+	readonly [XFORMS_KNOWN_ATTRIBUTE]: 'lang';
+
+	readonly root: ItextTranslationRootDefinition;
+	readonly rootDocument: ItextTranslationDefinition;
+}
+
+type ItextTranslationsDefinitionEntry = readonly [
+	key: string,
+	value: ItextTranslationRootDefinition,
+];
+
+type AssertItextTranslationsDefinitionEntry = (
+	entry: readonly [key: string | null, value: StaticElement]
+) => asserts entry is ItextTranslationsDefinitionEntry;
+
+const assertItextTranslationsDefinitionEntry: AssertItextTranslationsDefinitionEntry = ([
+	key,
+	root,
+]) => {
+	if (key == null || root.qualifiedName.localName !== 'translation') {
+		throw new Error();
+	}
+};
+
+/**
+ * @todo At time of writing, this shouldn't have any observable
+ * consequence—apart from preventing the potential mistake of using an
+ * {@link ItextTranslationDefinition} where an
+ * **instance**-as-{@link StaticDocument} would be expected (i.e. anything
+ * expecting an instance's {@link StaticDocument.nodeset} to be '/', or an its
+ * descendant elements' {@link StaticElement.nodeset} to start with '/'). The
+ * main intent, however, is to leave a breadcrumb back to ideas discussed in
+ * {@link https://github.com/getodk/web-forms/issues/22#issuecomment-2669228571 | Allow output in translation text (#22)}.
+ */
+const itextTranslationNodesetPrefix = (lang: string) => {
+	return `wf:translation('${lang}')`;
+};
+
+export class ItextTranslationsDefinition
+	extends Map<string, ItextTranslationRootDefinition>
+	implements XFormsItextTranslationMap<ItextTranslationRootDefinition>
+{
+	static from(xformDOM: XFormDOM): ItextTranslationsDefinition {
+		const entries = xformDOM.itextTranslationElements.map((element) => {
+			const lang = element.getAttribute('lang');
+			const { root } = parseStaticDocumentFromDOMSubtree(element, {
+				nodesetPrefix: itextTranslationNodesetPrefix(lang),
+			});
+			const entry = [lang, root] as const;
+
+			assertItextTranslationsDefinitionEntry(entry);
+
+			return entry;
+		});
+
+		return new this(entries);
+	}
+
+	private constructor(entries: readonly ItextTranslationsDefinitionEntry[]) {
+		super(entries);
+	}
+}

package/src/parse/model/LeafNodeDefinition.ts

@@ -1,4 +1,5 @@
 import type { ValueType } from '../../client/ValueType.ts';
+import type { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import {
 	NamespaceDeclarationMap,
 	type NamedSubtreeDefinition,
@@ -19,14 +20,12 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
 	readonly children = null;
-	readonly instances = null;
-	readonly defaultValue: string;
 
 	constructor(
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
-		readonly node: Element
+		readonly template: StaticLeafElement
 	) {
 		if (bodyElement != null && bodyElement.category !== 'control') {
 			throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
@@ -35,9 +34,8 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 		super(parent, bind, bodyElement);
 
 		this.valueType = bind.type.resolved satisfies ValueType as V;
-		this.qualifiedName = new QualifiedName(node);
+		this.qualifiedName = template.qualifiedName;
 		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-		this.defaultValue = node.textContent ?? '';
 	}
 
 	toJSON() {

package/src/parse/model/ModelBindMap.ts

@@ -1,7 +1,6 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import type { BindElement, BindNodeset } from './BindElement.ts';
-import { DEFAULT_BIND_TYPE } from './BindTypeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
 class ArtificialBindElement implements BindElement {
@@ -16,10 +15,6 @@ class ArtificialBindElement implements BindElement {
 			return this.ancestorNodeset;
 		}
 
-		if (name === 'type') {
-			return DEFAULT_BIND_TYPE;
-		}
-
 		return null;
 	}
 

package/src/parse/model/ModelDefinition.ts

@@ -1,21 +1,54 @@
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocumentFromDOMSubtree.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
-import { ItextTranslationsDefinition } from './ItextTranslation/ItextTranslationsDefinition.ts';
+import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
+import type { AnyNodeDefinition } from './NodeDefinition.ts';
+import type { NodeDefinitionMap } from './nodeDefinitionMap.ts';
+import { nodeDefinitionMap } from './nodeDefinitionMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
+import { SubmissionDefinition } from './SubmissionDefinition.ts';
 
 export class ModelDefinition {
 	readonly binds: ModelBindMap;
 	readonly root: RootDefinition;
+	readonly nodes: NodeDefinitionMap;
+	readonly instance: StaticDocument;
 	readonly itextTranslations: ItextTranslationsDefinition;
 
 	constructor(readonly form: XFormDefinition) {
-		const submission = new FormSubmissionDefinition(form.xformDOM);
+		const submission = new SubmissionDefinition(form.xformDOM);
+
 		this.binds = ModelBindMap.fromModel(this);
+		this.instance = parseStaticDocumentFromDOMSubtree(form.xformDOM.primaryInstanceRoot, {
+			nodesetPrefix: '/',
+		});
 		this.root = new RootDefinition(form, this, submission, form.body.classes);
+		this.nodes = nodeDefinitionMap(this.root);
 		this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
 	}
 
+	getNodeDefinition(nodeset: string): AnyNodeDefinition {
+		const definition = this.nodes.get(nodeset);
+
+		if (definition == null) {
+			throw new ErrorProductionDesignPendingError(`No definition for nodeset: ${nodeset}`);
+		}
+
+		return definition;
+	}
+
+	getRootDefinition(instance: StaticDocument): RootDefinition {
+		const definition = this.getNodeDefinition(instance.root.nodeset);
+
+		if (definition !== this.root) {
+			throw new ErrorProductionDesignPendingError();
+		}
+
+		return definition;
+	}
+
 	toJSON() {
 		const { form, ...rest } = this;
 

package/src/parse/model/NodeDefinition.ts

@@ -1,3 +1,4 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import type {
 	NamedSubtreeDefinition,
 	NamespaceDeclarationMap,
@@ -7,14 +8,12 @@ import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type { LeafNodeDefinition } from './LeafNodeDefinition.ts';
-import type { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
-import type { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
-import type { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
+import type { AnyRepeatDefinition } from './RepeatDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 import type { SubtreeDefinition } from './SubtreeDefinition.ts';
 
 /**
- * Corresponds to the model/entry DOM root node, i.e.:
+ * Corresponds to a model instance root node, i.e.:
  *
  * - the element matching `/*` in primary instance expressions, a.k.a.
  * - `/h:html/h:head/xf:model/xf:instance[1]/*`
@@ -22,34 +21,25 @@ import type { SubtreeDefinition } from './SubtreeDefinition.ts';
 export type RootNodeType = 'root';
 
 /**
- * Corresponds to a range/sequence of model/entry DOM subtrees which in turn
- * corresponds to a <repeat> in the form body definition.
- */
-export type RepeatRangeType = 'repeat-range';
-
-/**
- * Corresponds to a template definition for a repeat range, which either has
- * an explicit `jr:template=""` attribute in the form definition or is inferred
- * as a template from the form's first element matched by a <repeat nodeset>.
- */
-export type RepeatTemplateType = 'repeat-template';
-
-/**
- * Corresponds to a single instance of a model/entry DOM subtree which
- * in turn corresponds to a <repeat> in the form body definition, and a
- * 'repeat-range' definition.
+ * Corresponds to the combined concepts defining a "repeat".
+ *
+ * @see {@link RepeatDefinition} for details on these concepts and how they are used to produce a "repeat definition", as such.
+ *
+ * , including or
+ * referencing all of the following:
+ *
  */
-export type RepeatInstanceType = 'repeat-instance';
+export type RepeatType = 'repeat';
 
 /**
- * Corresponds to a model/entry DOM subtree which **does not** correspond to a
+ * 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).
  */
 export type SubtreeNodeType = 'subtree';
 
 /**
- * Corresponds to a model/entry DOM leaf node, i.e. one of:
+ * Corresponds to a model instance leaf node, i.e. one of:
  *
  * - An element with no child elements
  * - Any attribute corresponding to a bind's `nodeset` expression
@@ -60,9 +50,7 @@ export type LeafNodeType = 'leaf-node';
 export type NodeDefinitionType =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootNodeType
-	| RepeatRangeType
-	| RepeatTemplateType
-	| RepeatInstanceType
+	| RepeatType
 	| SubtreeNodeType
 	| LeafNodeType;
 
@@ -70,24 +58,15 @@ export type NodeDefinitionType =
 export type ParentNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
-	| RepeatTemplateDefinition
-	| RepeatInstanceDefinition
+	| AnyRepeatDefinition
 	| SubtreeDefinition;
 
 // prettier-ignore
 export type ChildNodeDefinition =
-	| AnyRepeatRangeDefinition
+	| AnyRepeatDefinition
 	| LeafNodeDefinition
 	| SubtreeDefinition;
 
-// prettier-ignore
-export type ChildNodeInstanceDefinition =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| RepeatTemplateDefinition
-	| RepeatInstanceDefinition
-	| SubtreeDefinition
-	| LeafNodeDefinition;
-
 export abstract class NodeDefinition<Type extends NodeDefinitionType>
 	implements NamedSubtreeDefinition
 {
@@ -98,12 +77,8 @@ export abstract class NodeDefinition<Type extends NodeDefinitionType>
 	abstract readonly isTranslated: boolean;
 	abstract readonly root: RootDefinition;
 	abstract readonly parent: ParentNodeDefinition | null;
+	abstract readonly template: StaticElement;
 	abstract readonly children: readonly ChildNodeDefinition[] | null;
-	abstract readonly instances: readonly RepeatInstanceDefinition[] | null;
-	abstract readonly defaultValue: string | null;
-
-	/** @todo leaf-node may be Attr */
-	abstract readonly node: Element | null;
 
 	readonly nodeset: string;
 
@@ -112,11 +87,10 @@ export abstract class NodeDefinition<Type extends NodeDefinitionType>
 	}
 }
 
+// prettier-ignore
 export type AnyNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
-	| AnyRepeatRangeDefinition
-	| RepeatTemplateDefinition
-	| RepeatInstanceDefinition
+	| AnyRepeatDefinition
 	| SubtreeDefinition
 	| LeafNodeDefinition;

package/src/parse/model/NoteNodeDefinition.ts

@@ -1,5 +1,6 @@
 import type { NoteNode } from '../../client/NoteNode.ts';
 import type { ValueType } from '../../client/ValueType.ts';
+import type { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
@@ -43,7 +44,7 @@ export class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNod
 		parent: ParentNodeDefinition,
 		bind: BindDefinition<V>,
 		bodyElement: AnyBodyElementDefinition | null,
-		node: Element
+		node: StaticLeafElement
 	): NoteNodeDefinition<V> | null {
 		if (!isNoteBindDefinition(bind) || bodyElement?.type !== 'input') {
 			return null;
@@ -64,8 +65,8 @@ export class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNod
 		override readonly bind: NoteBindDefinition<V>,
 		override readonly bodyElement: InputControlDefinition,
 		readonly noteTextDefinition: NoteTextDefinition,
-		node: Element
+		template: StaticLeafElement
 	) {
-		super(parent, bind, bodyElement, node);
+		super(parent, bind, bodyElement, template);
 	}
 }

package/src/parse/model/RangeNodeDefinition.ts

@@ -1,5 +1,6 @@
 import type { ValueType } from '../../client/ValueType.ts';
 import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import type { RuntimeValue, SharedValueCodec } from '../../lib/codecs/getSharedValueCodec.ts';
 import { getSharedValueCodec } from '../../lib/codecs/getSharedValueCodec.ts';
 import type {
@@ -91,7 +92,7 @@ export class RangeNodeDefinition<V extends RangeValueType = RangeValueType>
 		parent: ParentNodeDefinition,
 		bind: BindDefinition<V>,
 		bodyElement: RangeControlDefinition,
-		node: Element
+		node: StaticLeafElement
 	): RangeNodeDefinition<Extract<V, RangeValueType>> {
 		assertRangeBindDefinition(bind);
 
@@ -104,7 +105,7 @@ export class RangeNodeDefinition<V extends RangeValueType = RangeValueType>
 		parent: ParentNodeDefinition,
 		override readonly bind: BindDefinition<V>,
 		override readonly bodyElement: RangeControlDefinition,
-		node: Element
+		node: StaticLeafElement
 	) {
 		super(parent, bind, bodyElement, node);