Use `Implicit wrapper` instead of `Implicit Child`

[kildom]

This new name may be easier to understand, e.g.:

---

When you place a node that is not allowed directly in current context, it will be wrapped using implicit wrapper tag.
For example, if you put <font> directly inside <document>, the DocTML will internally wrap <font> element with <p> element before placing it in the <document> element. This happens because <document> element has implicit wrapper <p>. In other words, the following code:

<document>
  <font size="8pt">foo</font>
</document>

will be interpret as:

<document>
  <p>
    <font size="8pt">foo</font>
  </p>
</document>

The implicit wrapper may be applied multiple times until valid hierarchy is reached.
For example, if you put text directly inside <document>, it will be wrapped with <p> first and then <font>. In other words, the following code:

<document>
  foo
</document>

will be interpret as:

<document>
  <p>
    <font>foo</font>
  </p>
</document>

[kildom]

HTML has a similar mechanism where certain elements are implicitly inserted by the browser when parsing HTML that’s missing required structure.

In the HTML spec and documentation, this behavior is commonly referred to as:

---

✅ "Implied elements" or "implied tags"

This is the most common term used in both the HTML specification and developer-facing documentation (like MDN or WHATWG).

Example usage:

When a <tr> is placed directly inside a <table>, the browser implies a <tbody> element as its container, even if it's not explicitly present in the markup.

---

🔄 Also commonly called:

• Implicit insertion
• Implicit DOM construction
• Tag omission / implied tag insertion
• Parser-generated elements
• Automatic element inference

---

📘 Official sources use phrasing like:

• HTML Parsing algorithm (WHATWG spec):

  “The user agent will automatically insert elements that are required by the content model (such as <tbody> inside <table>) if they are omitted.”

• MDN (Mozilla Developer Network):

  “The <tbody> element is implied when a <tr> is placed inside a <table> without it.”

---

🏷️ So in your XML spec, analogous naming might include:

• Implied wrapper element
• Implicitly inferred structure
• Parser-inserted node
• Auto-generated intermediate element

These mirror the HTML terminology and will feel intuitive to developers familiar with HTML.

[kildom]

Short version in syntax introduction or tutorial

Most elements can be written in their short form by omitting some of their child elements. When an omitted element is required, the parser automatically inserts it as an implicit wrapper element.

For example, you can write:

<document>Hello, World!</document>

which the parser interprets as:

<document>
    <p>
        <font>Hello, World!</font>
    </p>
</document>

See Implicit wrapper elements for details.

[kildom]

Long version - dedicated section

Implicit wrapper elements

Some elements define an implicit wrapper element. This means you can leave out certain elements when writing a document, and the parser will add them for you automatically.

An implicit wrapper is only added when it is needed. If an element is already allowed inside its parent, it is left unchanged. If it is not allowed, it is automatically wrapped with the parent's implicit wrapper element.

If multiple consecutive children need the same implicit wrapper, they are wrapped together using a single implicit wrapper element. The parser does not create a separate wrapper for each child.

For example, the document element allows section, table, and p as direct children, so these elements are not wrapped. However, elements such as font, b, and i are not allowed directly inside document. When one of these elements is encountered, the parser automatically inserts a p element around it, because p is the implicit wrapper element of document.

Likewise, the p element uses font as its implicit wrapper element.

Therefore, the following document:

<document>Hello, World!</document>

is interpreted as:

<document>
    <p>
        <font>Hello, World!</font>
    </p>
</document>

The following document:

<document>
    <font>Hello, World!</font>
</document>

is interpreted as:

<document>
    <p>
        <font>Hello, World!</font>
    </p>
</document>

If several consecutive elements need to be wrapped, they share the same implicit wrapper:

<document>
    <b>Bold</b>
    <i>Italic</i>
    <font>Plain</font>
</document>

is interpreted as:

<document>
    <p>
        <b>Bold</b> <!-- WRONG: b and i are not allowed directly in p, so they will be wrapped with font -->
        <i>Italic</i>
        <font>Plain</font>
    </p>
</document>

On the other hand, because p is already allowed inside document, it is not wrapped:

<document>
    <p>Hello, World!</p>
</document>

is interpreted as:

<document>
    <p>
        <font>Hello, World!</font>
    </p>
</document>

Although some elements are omitted in the source document, they are still created by the parser and become part of the document tree. For example, the font element is always a child of p, never a direct child of document, even if the p element is not visible in the source code.

This is especially important when using attribute passing. Attributes passed to an implicit wrapper element work exactly the same as if the wrapper had been written explicitly.

For example:

<document>
    <p font.size="20pt">
        Hello, World!
    </p>
</document>

is equivalent to:

<document>
    <p>
        <font size="20pt">Hello, World!</font>
    </p>
</document>

Even though the font element is omitted in the source document, it is still created by the parser, so the font.size="20pt" attribute is applied to the implicitly created font element.

[kildom]

AI Agent instructions version

Implicit wrapper elements

An implicit wrapper element is an element that is automatically inserted by the parser when a node is not valid as a direct child of its parent.

Rule

For each element E, if a child node C is not allowed in E, the parser wraps C using the implicit wrapper element defined by E, unless C is already valid in E.

If multiple consecutive nodes require wrapping with the same implicit wrapper, they MUST be grouped into a single wrapper instance.

Nesting

Implicit wrappers apply recursively. If a wrapper element itself requires wrapping for its parent, the same rules apply transitively.

Document model consequence

After parsing, implicit wrappers are indistinguishable from explicitly written elements. They MUST be included in the final AST.

Example:

<document>
    <font>Hello</font>
</document>

is normalized to:

<document>
    <p>
        <font>Hello</font>
    </p>
</document>

Attribute forwarding

Attributes applied to a node that triggers implicit wrapping MUST be forwarded to the first implicitly created wrapper element of the corresponding level.

Example:

<document>
    <p font.size="20pt">
        Hello
    </p>
</document>

=> equivalent AST:

<document>
    <p>
        <font size="20pt">Hello</font>
    </p>
</document>

Notes

• Implicit wrappers are deterministic and context-free per parent element definition.
• They do not alter semantic ordering of nodes.
• They are preserved in the final document tree.