@getodk/xforms-engine 0.13.0 → 0.15.0

package/src/instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts

@@ -1,5 +1,5 @@
-import type { TemplatedNodeAttributeSerializationError } from '../../../error/TemplatedNodeAttributeSerializationError.ts';
 import type { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import type { Attribute } from '../../Attribute.ts';
 import type { GeneralChildNode } from '../../hierarchy.ts';
 import type {
 	ClientReactiveSerializableParentNode,
@@ -9,8 +9,7 @@ import type {
 
 export interface ClientReactiveSerializableTemplatedNodeCurrentState
 	extends ClientReactiveSerializableParentNodeCurrentState<GeneralChildNode> {
-	/** @see {@link TemplatedNodeAttributeSerializationError} */
-	get attributes(): unknown;
+	get attributes(): readonly Attribute[];
 }
 
 export interface ClientReactiveSerializableTemplatedNodeDefinition

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/repeat/BaseRepeatRange.ts

@@ -17,6 +17,10 @@ import type {
 import { XFORMS_XPATH_NODE_RANGE_KIND } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { createNodeRangeInstanceState } from '../../lib/client-reactivity/instance-state/createNodeRangeInstanceState.ts';
+import {
+	createAttributeState,
+	type AttributeState,
+} from '../../lib/reactivity/createAttributeState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -32,6 +36,7 @@ import type {
 	DescendantNodeSharedStateSpec,
 } from '../abstract/DescendantNode.ts';
 import { DescendantNode } from '../abstract/DescendantNode.ts';
+import type { Attribute } from '../Attribute.ts';
 import type { GeneralParentNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { ClientReactiveSerializableParentNode } from '../internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -41,6 +46,7 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 	readonly hint: null;
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly children: Accessor<readonly FormNodeID[]>;
+	readonly attributes: Accessor<readonly Attribute[]>;
 	readonly valueOptions: null;
 	readonly value: null;
 }
@@ -60,6 +66,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
 		ClientReactiveSerializableParentNode<RepeatInstance>
 {
 	protected readonly childrenState: ChildrenState<RepeatInstance>;
+	protected readonly attributeState: AttributeState;
 
 	/**
 	 * A repeat range doesn't have a corresponding primary instance element of its
@@ -156,8 +163,10 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
 		const repeatRange = this as AnyDescendantNode as RepeatRange;
 
 		const childrenState = createChildrenState<RepeatRange, RepeatInstance>(repeatRange);
+		const attributeState = createAttributeState(this.scope);
 
 		this.childrenState = childrenState;
+		this.attributeState = attributeState;
 
 		const state = createSharedNodeState(
 			this.scope,
@@ -170,6 +179,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
 				label: createNodeLabel(this, definition),
 				hint: null,
 				children: childrenState.childIds,
+				attributes: attributeState.getAttributes,
 				valueOptions: null,
 				value: null,
 			},
@@ -260,4 +270,8 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
 	getChildren(): readonly RepeatInstance[] {
 		return this.childrenState.getChildren();
 	}
+
+	getAttributes(): readonly Attribute[] {
+		return this.attributeState.getAttributes();
+	}
 }

package/src/instance/repeat/RepeatInstance.ts

@@ -10,10 +10,13 @@ import type {
 import type { InstanceState } from '../../client/serialization/InstanceState.ts';
 import type { TextRange } from '../../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
-import type { TemplatedNodeAttributeSerializationError } from '../../error/TemplatedNodeAttributeSerializationError.ts';
 import type { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { createTemplatedNodeInstanceState } from '../../lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts';
+import {
+	createAttributeState,
+	type AttributeState,
+} from '../../lib/reactivity/createAttributeState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -26,6 +29,7 @@ import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
 import type { DescendantNodeSharedStateSpec } from '../abstract/DescendantNode.ts';
 import { DescendantNode } from '../abstract/DescendantNode.ts';
+import type { Attribute } from '../Attribute.ts';
 import { buildChildren } from '../children/buildChildren.ts';
 import type { GeneralChildNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
@@ -35,9 +39,7 @@ interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: null;
 
-	/** @see {@link TemplatedNodeAttributeSerializationError} */
-	readonly attributes: null;
-
+	readonly attributes: Accessor<readonly Attribute[]>;
 	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
@@ -61,6 +63,7 @@ export class RepeatInstance
 		ClientReactiveSerializableTemplatedNode
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
+	private readonly attributeState: AttributeState;
 	private readonly currentIndex: Accessor<number>;
 
 	override readonly [XPathNodeKindKey] = 'element';
@@ -132,8 +135,10 @@ export class RepeatInstance
 		this.appearances = definition.bodyElement.appearances;
 
 		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
+		const attributeState = createAttributeState(this.scope);
 
 		this.childrenState = childrenState;
+		this.attributeState = attributeState;
 		this.currentIndex = currentIndex;
 
 		const state = createSharedNodeState(
@@ -147,7 +152,7 @@ export class RepeatInstance
 				// TODO: only-child <group><label>
 				label: createNodeLabel(this, definition),
 				hint: null,
-				attributes: null,
+				attributes: attributeState.getAttributes,
 				children: childrenState.childIds,
 				valueOptions: null,
 				value: null,
@@ -192,4 +197,8 @@ export class RepeatInstance
 	getChildren(): readonly GeneralChildNode[] {
 		return this.childrenState.getChildren();
 	}
+
+	getAttributes(): readonly Attribute[] {
+		return this.attributeState.getAttributes();
+	}
 }

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/XFormsXPathNode.ts

@@ -97,7 +97,8 @@ export type XFormsXPathDescendantNodeKind =
 	| XFormsXPathNodeRangeKind
 	| XPathElementKind
 	| XPathTextKind
-	| XPathCommentKind;
+	| XPathCommentKind
+	| XPathAttributeKind;
 
 export interface XFormsXPathDescendantNode extends XFormsXPathNode {
 	readonly [XPathNodeKindKey]: XFormsXPathDescendantNodeKind;
@@ -109,6 +110,7 @@ export type XFormsXPathPrimaryInstanceNodeKind =
 	| XPathDocumentKind
 	| XFormsXPathNodeRangeKind
 	| XPathElementKind
+	| XPathAttributeKind
 	| XPathTextKind;
 
 export interface XFormsXPathPrimaryInstanceNode extends XFormsXPathNode {

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/client-reactivity/instance-state/createAttributeNodeInstanceState.ts

@@ -0,0 +1,16 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableAttributeNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableAttributeNode.ts';
+import { escapeXMLText, serializeAttributeXML } from '../../xml-serialization.ts';
+
+export const createAttributeNodeInstanceState = (
+	node: ClientReactiveSerializableAttributeNode
+): InstanceState => {
+	const { qualifiedName } = node.definition;
+
+	return {
+		get instanceXML() {
+			const xmlValue = escapeXMLText(node.currentState.instanceValue, true);
+			return serializeAttributeXML(qualifiedName, xmlValue);
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createParentNodeInstanceState.ts

@@ -12,11 +12,11 @@ export const createParentNodeInstanceState = (
 				return '';
 			}
 
-			const serializedChildren = node.currentState.children.map((child) => {
-				return child.instanceState.instanceXML;
-			});
-
-			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+			return serializeParentElementXML(
+				node.definition.qualifiedName,
+				node.currentState.children,
+				node.currentState.attributes
+			);
 		},
 	};
 };

package/src/lib/client-reactivity/instance-state/createRootInstanceState.ts

@@ -5,15 +5,12 @@ import { serializeParentElementXML } from '../../xml-serialization.ts';
 export const createRootInstanceState = (node: Root): InstanceState => {
 	return {
 		get instanceXML() {
-			const { namespaceDeclarations, attributes } = node.definition;
-			const serializedChildren = node.currentState.children.map((child) => {
-				return child.instanceState.instanceXML;
-			});
-
-			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren, {
-				namespaceDeclarations,
-				attributes: Array.from(attributes.values()),
-			});
+			return serializeParentElementXML(
+				node.definition.qualifiedName,
+				node.currentState.children,
+				node.currentState.attributes,
+				node.definition.namespaceDeclarations
+			);
 		},
 	};
 };

package/src/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts

@@ -1,11 +1,7 @@
 import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
-import { TemplatedNodeAttributeSerializationError } from '../../../error/TemplatedNodeAttributeSerializationError.ts';
 import type { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
 import { serializeParentElementXML } from '../../xml-serialization.ts';
 
-/**
- * @see {@link TemplatedNodeAttributeSerializationError}
- */
 export const createTemplatedNodeInstanceState = (
 	node: ClientReactiveSerializableTemplatedNode
 ): InstanceState => {
@@ -15,17 +11,11 @@ export const createTemplatedNodeInstanceState = (
 				return '';
 			}
 
-			const serializedChildren = node.currentState.children.map((child) => {
-				return child.instanceState.instanceXML;
-			});
-
-			const { attributes } = node.currentState;
-
-			if (attributes != null) {
-				throw new TemplatedNodeAttributeSerializationError();
-			}
-
-			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+			return serializeParentElementXML(
+				node.definition.qualifiedName,
+				node.currentState.children,
+				node.currentState.attributes
+			);
 		},
 	};
 };

package/src/lib/names/NamespaceDeclarationMap.ts

@@ -11,7 +11,7 @@ type NamedNodeDefinitionMap = ReadonlyMap<QualifiedName, NamedNodeDefinition>;
 export interface NamedSubtreeDefinition extends NamedNodeDefinition {
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly parent: NamedSubtreeDefinition | null;
-	readonly attributes?: NamedNodeDefinitionMap;
+	readonly attributes: NamedNodeDefinitionMap | null;
 }
 
 /**