@getodk/xforms-engine 0.13.0 → 0.14.0

package/src/instance/markdown/MarkdownNode.ts

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

package/src/instance/text/TextChunk.ts

@@ -1,13 +1,8 @@
 import type { ActiveLanguage } from '../../client/FormLanguage.ts';
 import type { TextChunk as ClientTextChunk, TextChunkSource } from '../../client/TextRange.ts';
 import type { TranslationContext } from '../internal-api/TranslationContext.ts';
-import { FormattedTextStub } from './FormattedTextStub.ts';
 
 export class TextChunk implements ClientTextChunk {
-	get formatted() {
-		return FormattedTextStub;
-	}
-
 	get language(): ActiveLanguage {
 		return this.context.getActiveLanguage();
 	}

package/src/instance/text/TextRange.ts

@@ -1,11 +1,13 @@
 import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+
+import type { MarkdownNode } from '../../client/MarkdownNode.ts';
 import type {
 	TextRange as ClientTextRange,
 	TextChunk,
 	TextOrigin,
 	TextRole,
 } from '../../client/TextRange.ts';
-import { FormattedTextStub } from './FormattedTextStub.ts';
+import { format } from './markdownFormat.ts';
 
 export interface MediaSources {
 	image?: JRResourceURL;
@@ -20,8 +22,8 @@ export class TextRange<Role extends TextRole, Origin extends TextOrigin>
 		yield* this.chunks;
 	}
 
-	get formatted() {
-		return FormattedTextStub;
+	get formatted(): MarkdownNode[] {
+		return format(this.chunks);
 	}
 
 	get asString(): string {

package/src/instance/text/markdownFormat.ts

@@ -0,0 +1,214 @@
+import type { Heading, Literal, RootContent } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { type MarkdownNode, type StyleProperty } from '../../client';
+import type { TextChunk } from '../../client/TextRange.ts';
+import {
+	Anchor,
+	ChildMarkdownNode,
+	Div,
+	Emphasis,
+	Heading1,
+	Heading2,
+	Heading3,
+	Heading4,
+	Heading5,
+	Heading6,
+	Html,
+	ListItem,
+	OrderedList,
+	Paragraph,
+	Span,
+	Strong,
+	Underline,
+	UnorderedList,
+} from '../markdown/MarkdownNode.ts';
+
+const STYLE_PROPERTY_REGEX = /style\s*=\s*(?:'|")(.+)(?:'|")/i;
+const HTML_TAG_MAP = {
+	span: Span,
+	div: Div,
+	p: Paragraph,
+	u: Underline,
+	i: Emphasis,
+	em: Emphasis,
+	b: Strong,
+	strong: Strong,
+};
+const SUPPORTED_HTML_TAGS = Object.entries(HTML_TAG_MAP).map(([tag, type]) => {
+	return {
+		openRegex: RegExp(`^\\s*<\\s*${tag}[\\s+>]`, 'i'),
+		closeRegex: RegExp(`<\\s*/${tag}\\s*>`, 'i'),
+		type,
+	};
+});
+
+let outputStrings: Map<string, string>;
+
+function validateStyleProperty(name: string | undefined, value: string | undefined): boolean {
+	if (!name || !value) {
+		return false;
+	}
+	if (!['color', 'font-family', 'text-align', 'font-size'].includes(name)) {
+		return false;
+	}
+	if (name === 'text-align' && !['left', 'right', 'center'].includes(value)) {
+		return false;
+	}
+	return true;
+}
+
+function parseStyle(tag: string): StyleProperty | undefined {
+	const styleProperty = STYLE_PROPERTY_REGEX.exec(tag);
+	if (!styleProperty || styleProperty.length < 2) {
+		return;
+	}
+	const styleValue = styleProperty[1] ?? '';
+	const properties = styleValue.split(';');
+	const entries: string[][] = [];
+	properties.forEach((property) => {
+		const [name, value] = property.split(':').map((val) => val.trim());
+		if (validateStyleProperty(name, value)) {
+			entries.push([name!, value!]);
+		}
+	});
+	if (!entries.length) {
+		return;
+	}
+	return Object.fromEntries(entries) as StyleProperty;
+}
+
+function mdastHeading(tree: Heading, children: MarkdownNode[]): MarkdownNode {
+	if (tree.depth === 1) {
+		return new Heading1(children);
+	}
+	if (tree.depth === 2) {
+		return new Heading2(children);
+	}
+	if (tree.depth === 3) {
+		return new Heading3(children);
+	}
+	if (tree.depth === 4) {
+		return new Heading4(children);
+	}
+	if (tree.depth === 5) {
+		return new Heading5(children);
+	}
+	return new Heading6(children);
+}
+
+function mdastNodeToOdkMarkdown(tree: RootContent): MarkdownNode | undefined {
+	if (tree.type === 'html') {
+		return new Html(tree.value);
+	}
+	if (tree.type === 'text' || tree.type === 'inlineCode') {
+		const outputString = outputStrings.get(tree.value);
+		if (outputString) {
+			const children = toOdkMarkdown(outputString);
+			return new Span(children, undefined);
+		}
+		return new ChildMarkdownNode(tree.value);
+	}
+	if ('children' in tree) {
+		const children = mdastToOdkMarkdown(tree.children);
+		if (tree.type === 'paragraph') {
+			return new Paragraph(children, undefined);
+		}
+		if (tree.type === 'strong') {
+			return new Strong(children);
+		}
+		if (tree.type === 'emphasis') {
+			return new Emphasis(children);
+		}
+		if (tree.type === 'link') {
+			return new Anchor(children, tree.url);
+		}
+		if (tree.type === 'list') {
+			if (tree.ordered) {
+				return new OrderedList(children);
+			} else {
+				return new UnorderedList(children);
+			}
+		}
+		if (tree.type === 'listItem') {
+			return new ListItem(children);
+		}
+		if (tree.type === 'heading') {
+			return mdastHeading(tree, children);
+		}
+	}
+	return;
+}
+
+function getUnclosedHtmlTag(tree: RootContent) {
+	if (tree.type !== 'html') {
+		return;
+	}
+	const tag = SUPPORTED_HTML_TAGS.find((supported) => supported.openRegex.test(tree.value));
+	if (!tag || tag.closeRegex.test(tree.value)) {
+		return;
+	}
+	return tag;
+}
+
+function mdastToOdkMarkdown(elements: RootContent[]): MarkdownNode[] {
+	const result: MarkdownNode[] = [];
+	for (let i = 0; i < elements.length; i++) {
+		const tree = elements[i]!;
+		const tag = getUnclosedHtmlTag(tree);
+		if (!tag) {
+			const odkMarkdown = mdastNodeToOdkMarkdown(tree);
+			if (odkMarkdown) {
+				result.push(odkMarkdown);
+			}
+			continue;
+		}
+
+		// SPECIAL CASE in mdast processing
+		// span children are parsed into siblings in the mdast for some reason
+		// so we need to advance `i` as we consume siblings
+		const children: RootContent[] = [];
+		let next = elements[++i];
+		while (next && !(next.type === 'html' && tag.closeRegex.test(next.value))) {
+			children.push(next);
+			next = elements[++i];
+		}
+		const odkChildren = mdastToOdkMarkdown(children);
+		const style = parseStyle((tree as Literal).value);
+		const properties = style && { style };
+		result.push(new tag.type(odkChildren, properties));
+	}
+	return result;
+}
+
+function escapeEditableChunks(chunks: readonly TextChunk[]) {
+	return chunks
+		.map((chunk, i) => {
+			const str = chunk.asString;
+			if (str && chunk.source === 'output') {
+				// we need to process this separately otherwise user entered markup will
+				// interract with form markup in unexpected ways
+				const id = `--ODK-OUTPUT-STRING-${i}--`;
+				outputStrings.set(id, str);
+				return '`' + id + '`';
+			}
+			return str ?? '';
+		})
+		.join('');
+}
+
+function toOdkMarkdown(str: string): MarkdownNode[] {
+	const tree = fromMarkdown(str);
+	const odk = mdastToOdkMarkdown(tree.children);
+	if (odk.length === 1 && odk[0]?.role === 'parent' && odk[0]?.elementName === 'p') {
+		// mdast tends to add too many paragraphs which if left in place, puts a block level
+		// element where it's not needed
+		return odk[0].children;
+	}
+	return odk;
+}
+
+export function format(chunks: readonly TextChunk[]): MarkdownNode[] {
+	outputStrings = new Map<string, string>();
+	const str = escapeEditableChunks(chunks);
+	return toOdkMarkdown(str);
+}

package/src/integration/xpath/adapter/names.ts

@@ -140,7 +140,6 @@ export const resolveEngineXPathNodeNamespaceURI = (
 		case 'repeat-range:uncontrolled':
 		case 'root':
 		case 'select':
-		case 'subtree':
 		case 'trigger':
 		case 'upload':
 			return node.definition.namespaceDeclarations.get(prefix)?.declaredURI?.href ?? null;

package/src/lib/reactivity/createItemCollection.ts

@@ -2,13 +2,12 @@ import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { ActiveLanguage } from '../../client/FormLanguage.ts';
-import type { SelectItem } from '../../client/SelectNode.ts';
-import type { RankItem } from '../../client/RankNode.ts';
+import type { BaseItem } from '../../client/BaseItem.ts';
 import type { TextRange as ClientTextRange } from '../../client/TextRange.ts';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { TranslationContext } from '../../instance/internal-api/TranslationContext.ts';
-import type { SelectControl } from '../../instance/SelectControl.ts';
 import type { RankControl } from '../../instance/RankControl.ts';
+import type { SelectControl } from '../../instance/SelectControl.ts';
 import { TextChunk } from '../../instance/text/TextChunk.ts';
 import { TextRange } from '../../instance/text/TextRange.ts';
 import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
@@ -19,8 +18,7 @@ import { createComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
 
-export type ItemCollectionControl = RankControl | SelectControl;
-type Item = RankItem | SelectItem;
+type ItemCollectionControl = RankControl | SelectControl;
 type DerivedItemLabel = ClientTextRange<'item-label', 'form-derived'>;
 
 const derivedItemLabel = (context: TranslationContext, value: string): DerivedItemLabel => {
@@ -45,7 +43,7 @@ const createItemLabel = (
 const createTranslatedStaticItems = (
 	control: ItemCollectionControl,
 	items: readonly ItemDefinition[]
-): Accessor<readonly Item[]> => {
+): Accessor<readonly BaseItem[]> => {
 	return control.scope.runTask(() => {
 		const labeledItems = items.map((item) => {
 			const { value } = item;
@@ -54,6 +52,7 @@ const createTranslatedStaticItems = (
 			return () => ({
 				value,
 				label: label(),
+				properties: [],
 			});
 		});
 
@@ -101,6 +100,7 @@ const createItemsetItemLabel = (
 interface ItemsetItem {
 	label(): ClientTextRange<'item-label'>;
 	value(): string;
+	properties: Array<[string, () => string]>;
 }
 
 const createItemsetItems = (
@@ -122,9 +122,20 @@ const createItemsetItems = (
 					});
 					const label = createItemsetItemLabel(context, itemset, value);
 
+					const nodeElements = itemNode
+						.getXPathChildNodes()
+						.filter((node) => node.nodeType === 'static-element');
+					const properties = itemset.getPropertiesExpressions(nodeElements).map((expression) => {
+						return [expression.toString(), createComputedExpression(context, expression)] as [
+							string,
+							() => string,
+						];
+					});
+
 					return {
 						label,
 						value,
+						properties,
 					};
 				});
 			});
@@ -135,7 +146,7 @@ const createItemsetItems = (
 const createItemset = (
 	control: ItemCollectionControl,
 	itemset: ItemsetDefinition
-): Accessor<readonly Item[]> => {
+): Accessor<readonly BaseItem[]> => {
 	return control.scope.runTask(() => {
 		const itemsetItems = createItemsetItems(control, itemset);
 
@@ -144,6 +155,9 @@ const createItemset = (
 				return {
 					label: item.label(),
 					value: item.value(),
+					properties: item.properties.map(
+						([propLabel, propValue]) => [propLabel, propValue()] as [string, string]
+					),
 				};
 			});
 		});
@@ -152,7 +166,7 @@ const createItemset = (
 
 /**
  * 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.
@@ -162,7 +176,9 @@ const createItemset = (
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export const createItemCollection = (control: ItemCollectionControl): Accessor<readonly Item[]> => {
+export const createItemCollection = (
+	control: ItemCollectionControl
+): Accessor<readonly BaseItem[]> => {
 	const { items, itemset } = control.definition.bodyElement;
 
 	if (itemset != null) {

package/src/parse/body/BodyDefinition.ts

@@ -10,9 +10,7 @@ import type { AnySelectControlDefinition } from './control/SelectControlDefiniti
 import { SelectControlDefinition } 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';
 
@@ -31,22 +29,18 @@ export type ControlElementDefinition =
 	| TriggerControlDefinition
 	| UploadControlDefinition;
 
+// prettier-ignore
 type SupportedBodyElementDefinition =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| RepeatElementDefinition
-	| LogicalGroupDefinition
-	| PresentationGroupDefinition
-	| StructuralGroupDefinition
-	| ControlElementDefinition;
+	| ControlElementDefinition
+	| GroupElementDefinition
+	| RepeatElementDefinition;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type BodyElementDefinitionConstructor = new (...args: any[]) => SupportedBodyElementDefinition;
 
 const BodyElementDefinitionConstructors = [
 	RepeatElementDefinition,
-	LogicalGroupDefinition,
-	PresentationGroupDefinition,
-	StructuralGroupDefinition,
+	GroupElementDefinition,
 	InputControlDefinition,
 	SelectControlDefinition,
 	RangeControlDefinition,
@@ -63,23 +57,6 @@ export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
 
 export type AnyBodyElementType = AnyBodyElementDefinition['type'];
 
-export type AnyGroupElementDefinition = Extract<
-	AnyBodyElementDefinition,
-	{ readonly type: `${string}-group` }
->;
-
-const isGroupElementDefinition = (
-	element: AnyBodyElementDefinition
-): element is AnyGroupElementDefinition => {
-	return element.type.endsWith('-group');
-};
-
-export const groupElementDefinition = (
-	element: AnyBodyElementDefinition
-): AnyGroupElementDefinition | null => {
-	return isGroupElementDefinition(element) ? element : null;
-};
-
 export type AnyControlElementDefinition = Extract<
 	AnyBodyElementDefinition,
 	{ readonly category: 'control' }
@@ -119,11 +96,7 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 				this.mapElementsByReference(element.children);
 			}
 
-			if (
-				element instanceof LogicalGroupDefinition ||
-				element instanceof PresentationGroupDefinition ||
-				element instanceof StructuralGroupDefinition
-			) {
+			if (element instanceof GroupElementDefinition) {
 				if (reference != null) {
 					this.set(reference, element);
 				}

package/src/parse/body/GroupElementDefinition.ts

@@ -0,0 +1,47 @@
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { parseNodesetReference } from '../xpath/reference-parsing.ts';
+import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
+import {
+	type BodyElementDefinitionArray,
+	type 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 class GroupElementDefinition extends BodyElementDefinition<'group'> {
+	override readonly category = 'structure';
+	override readonly type = 'group';
+
+	readonly children: BodyElementDefinitionArray;
+
+	override readonly reference: string | null;
+	readonly appearances: StructureElementAppearanceDefinition;
+	override readonly label: LabelDefinition | null;
+
+	static override isCompatible(localName: string): boolean {
+		return localName === 'group';
+	}
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		const childElements = Array.from(element.children).filter((child) => {
+			const childName = child.localName;
+
+			return childName !== 'label';
+		});
+
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
+		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.label = LabelDefinition.forGroup(form, this);
+	}
+}

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

@@ -1,5 +1,8 @@
+import type { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import type { ItemsetElement } from '../../../lib/dom/query.ts';
 import { getValueElement } from '../../../lib/dom/query.ts';
+import { DependentExpression } from '../../expression/abstract/DependentExpression.ts';
+import { ItemPropertyExpression } from '../../expression/ItemPropertyExpression.ts';
 import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
@@ -52,4 +55,8 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 		this.value = new ItemsetValueExpression(this, valueExpression);
 		this.label = ItemsetLabelDefinition.from(form, this);
 	}
+
+	getPropertiesExpressions(propertiesNodes: StaticElement[]): Array<DependentExpression<'string'>> {
+		return ItemPropertyExpression.from(propertiesNodes);
+	}
 }

package/src/parse/expression/ItemPropertyExpression.ts

@@ -0,0 +1,12 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+
+export class ItemPropertyExpression extends DependentExpression<'string'> {
+	static from(propertiesNodes: StaticElement[]) {
+		return propertiesNodes.map((node: StaticElement) => new this(node.qualifiedName.localName));
+	}
+
+	constructor(propertyName: string) {
+		super('string', propertyName);
+	}
+}

package/src/parse/model/{SubtreeDefinition.ts → GroupDefinition.ts}

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