@markuplint/ml-core 5.1.1 → 5.2.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.2.0](https://github.com/markuplint/markuplint/compare/v5.1.1...v5.2.0) (2026-10-13)
+
+### Bug Fixes
+
+- **ml-core:** resolve the namespace of a component and the children given to it ([00ecbba](https://github.com/markuplint/markuplint/commit/00ecbbae6095dd8eb7d10148633d6610bed7f1e2))
+- **ml-core:** return the DOM values from MLAttr.namespaceURI ([05467ad](https://github.com/markuplint/markuplint/commit/05467ad28d61ae0a272c8335db9a0b2f614e5592))
+- use caret ranges for third-party dependencies of published packages ([5fb5d2e](https://github.com/markuplint/markuplint/commit/5fb5d2ee81eaeea45fe7256a40dd41c95ff0d672))
+
 ## [5.1.1](https://github.com/markuplint/markuplint/compare/v5.1.0...v5.1.1) (2026-10-09)
 
 **Note:** Version bump only for package @markuplint/ml-core

package/lib/ml-dom/node/attr.d.ts

@@ -98,7 +98,9 @@ export declare class MLAttr<T extends RuleConfigValue, O extends PlainData = und
      */
     get name(): string;
     /**
-     * Returns the namespace URI of this attribute, resolved from the attribute name.
+     * Returns the namespace URI of this attribute: that of its prefix when the name has a known
+     * one (e.g. `xlink:href`), otherwise `null`. An attribute without a prefix has no namespace
+     * whichever element it is on, and so does a spread attribute.
      *
      * @implements DOM API: `Attr`
      * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-namespaceuri

package/lib/ml-dom/node/attr.js

@@ -90,7 +90,7 @@ export class MLAttr extends MLNode {
         super(astToken, ownElement.ownerMLDocument);
         this.ownerElement = ownElement;
         if (this._astToken.type === 'spread') {
-            this.#namespaceURI = ownElement.namespaceURI;
+            this.#namespaceURI = null;
             this.valueType = 'code';
             this.#localName = '#spread';
             this.#potentialName = '#spread';
@@ -158,7 +158,12 @@ export class MLAttr extends MLNode {
         }
         const ns = resolveNamespace(this.#potentialName, ownElement.namespaceURI);
         this.#localName = ns.localName;
-        this.#namespaceURI = ns.namespaceURI;
+        // An attribute does not inherit the namespace of its element, so only a known prefix
+        // gives it one. `ns.namespace` equals the prefix exactly when the prefix is a known
+        // one; for an unknown prefix it falls back to the element's namespace.
+        const hasPrefix = ns.localName !== this.#potentialName;
+        const prefix = this.#potentialName.split(':')[0];
+        this.#namespaceURI = hasPrefix && ns.namespace === prefix ? ns.namespaceURI : null;
     }
     /**
      * Returns the local name portion of the attribute (without namespace prefix).
@@ -179,7 +184,9 @@ export class MLAttr extends MLNode {
         return this.#potentialName;
     }
     /**
-     * Returns the namespace URI of this attribute, resolved from the attribute name.
+     * Returns the namespace URI of this attribute: that of its prefix when the name has a known
+     * one (e.g. `xlink:href`), otherwise `null`. An attribute without a prefix has no namespace
+     * whichever element it is on, and so does a spread attribute.
      *
      * @implements DOM API: `Attr`
      * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-namespaceuri

package/lib/ml-dom/node/element.d.ts

@@ -36,16 +36,26 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
     readonly elementType: ElementType;
     /**
      * Whether this element belongs to a non-HTML namespace (e.g., SVG or MathML).
+     *
+     * Unlike {@link namespaceURI}, it does not follow the pretender: it says how the tag
+     * written here is parsed (whether the case of its name is kept, whether `/>` closes
+     * it), and the tag of a component is not parsed as the element it renders. An element
+     * given to a component as a child is, as it ends up inside what the component renders.
      */
-    readonly isForeignElement: boolean;
+    get isForeignElement(): boolean;
     /**
      * Whether this element was implicitly created (e.g., an omitted `<body>` tag in HTML).
      */
     readonly isOmitted: boolean;
     /**
      * The namespace URI of this element (e.g., `http://www.w3.org/1999/xhtml` for HTML elements).
+     *
+     * Like {@link localName}, it follows the pretender, so that a namespaced selector
+     * (`svg|svg`) and a spec lookup see the element the component renders. An element
+     * given to a component as a child takes the namespace of where the component renders
+     * it, resolved when the document pretends.
      */
-    readonly namespaceURI: NamespaceURI;
+    get namespaceURI(): NamespaceURI;
     readonly ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
     readonly ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
     readonly ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;

package/lib/ml-dom/node/element.js

@@ -1,6 +1,8 @@
 /* global StylePropertyMap, StylePropertyMapReadOnly */
 var _a;
 import { getSpecByTagName, resolveNamespace } from '@markuplint/ml-spec';
+import { pretenderNamespaceToURI } from '@markuplint/ml-config';
+import { getChildNamespace } from '@markuplint/parser-utils';
 import { matchSelector } from '@markuplint/selector';
 import { getAccname } from '../helper/accname.js';
 import { after, before, nextElementSibling, previousElementSibling, remove, replaceWith, } from '../manipulations/child-node-methods.js';
@@ -38,8 +40,15 @@ export class MLElement extends MLParentNode {
     #getChildElementsAndTextNodeWithoutWhitespacesCache = null;
     /**
      * Whether this element belongs to a non-HTML namespace (e.g., SVG or MathML).
+     *
+     * Unlike {@link namespaceURI}, it does not follow the pretender: it says how the tag
+     * written here is parsed (whether the case of its name is kept, whether `/>` closes
+     * it), and the tag of a component is not parsed as the element it renders. An element
+     * given to a component as a child is, as it ends up inside what the component renders.
      */
-    isForeignElement;
+    get isForeignElement() {
+        return this.#namespaceURI !== HTML_NAMESPACE;
+    }
     /**
      * Whether this element was implicitly created (e.g., an omitted `<body>` tag in HTML).
      */
@@ -47,8 +56,19 @@ export class MLElement extends MLParentNode {
     #localName;
     /**
      * The namespace URI of this element (e.g., `http://www.w3.org/1999/xhtml` for HTML elements).
+     *
+     * Like {@link localName}, it follows the pretender, so that a namespaced selector
+     * (`svg|svg`) and a spec lookup see the element the component renders. An element
+     * given to a component as a child takes the namespace of where the component renders
+     * it, resolved when the document pretends.
      */
-    namespaceURI;
+    get namespaceURI() {
+        if (this.pretenderContext?.type === 'pretender') {
+            return this.pretenderContext.as.namespaceURI;
+        }
+        return this.#namespaceURI;
+    }
+    #namespaceURI;
     /**
      * ## Why this cache exists
      *
@@ -122,10 +142,9 @@ export class MLElement extends MLParentNode {
             : null;
         this.closeTag = pairAstNode ? new MLElementCloseTag(pairAstNode, document, this) : null;
         const ns = resolveNamespace(astNode.nodeName, astNode.namespace);
-        this.namespaceURI = astNode.namespace;
+        this.#namespaceURI = astNode.namespace;
         this.elementType = astNode.elementType;
         this.#localName = ns.localName;
-        this.isForeignElement = this.namespaceURI !== HTML_NAMESPACE;
         this.isOmitted = astNode.isGhost;
         this.tagOpenChar = astNode.tagOpenChar;
         this.tagCloseChar = astNode.tagCloseChar;
@@ -2861,6 +2880,101 @@ export class MLElement extends MLParentNode {
         }
         return matched;
     }
+    /**
+     * The element this element is rendered in: when the parent is a component, the
+     * element the component wraps its children with (the slot wrapper, or the element
+     * it renders), otherwise the parent. `null` at the top level. `undefined` when the
+     * parent is a component with more than one slot that give the children different
+     * namespaces.
+     *
+     * A custom element is not a component here: it puts the children in its light DOM,
+     * where they keep the namespace they are parsed in.
+     *
+     * The parent has pretended already: `MLDocument` calls `pretending()` in
+     * document order.
+     */
+    #getRenderedParent() {
+        const parent = this.parentElement;
+        if (parent?.pretenderContext?.type !== 'pretender' || parent.elementType === 'web-component') {
+            return parent;
+        }
+        const { as, slotContent } = parent.pretenderContext;
+        if (!slotContent) {
+            return as;
+        }
+        return slotContent.wrapper ?? parent.#sharedWrapper ?? undefined;
+    }
+    /**
+     * For a component with more than one slot, whose wrapper of each child is unknown, a
+     * wrapper that gives the children the same namespace as all the others do, so that
+     * the children can still be resolved. `null` when they differ (`<svg>` and the `<div>`
+     * inside its `foreignObject`).
+     */
+    #sharedWrapper = null;
+    #findSharedWrapper(slots, as) {
+        const wrappers = slots.map((slot, i) => this.#createVirtualElement(slot, `${this.uuid}_pretender_slot_${i}`, this.uuid, as));
+        const [first] = wrappers;
+        if (!first) {
+            return null;
+        }
+        const namespace = first.#getChildNamespace(null);
+        return wrappers.every(wrapper => wrapper.#getChildNamespace(null) === namespace) ? first : null;
+    }
+    /**
+     * The namespace of an element named `name` rendered as a child of this element, from
+     * its own resolved namespace rather than the one of what it pretends to be.
+     * `null` takes the namespace this element gives any element.
+     */
+    #getChildNamespace(name) {
+        return getChildNamespace(name, this.#namespaceURI, this._astToken.nodeName);
+    }
+    /**
+     * Re-resolves the namespace for the element this element is rendered in.
+     *
+     * The parser gives the children written inside a component the namespace of where
+     * the component is written, as it does not know what the component renders: in
+     * `<Icon><path /></Icon>`, where `Icon` renders `<svg>`, `path` is an HTML element
+     * to it. Its namespace is kept while the parent is where the parser put it, so that
+     * where no component is involved, the namespace stays what the parser gave, and when
+     * where the component renders it is unknown.
+     *
+     * `getChildNamespace` leaves foreign content only at `foreignObject`, so an element
+     * re-resolved here does not follow the other integration points (`<mi>`, `<desc>`),
+     * nor the HTML elements that break out of foreign content in an HTML document (`<div>`
+     * inside `<svg>`).
+     *
+     * A component is given no name, so that its own name is not taken for an element:
+     * `getChildNamespace` compares names in lowercase, so `<Math>` would enter MathML.
+     * The parsers of this repository do the same, but the AST may come from a parser
+     * that does not.
+     */
+    #resolveNamespace(renderedParent) {
+        const parent = this.parentElement;
+        if (!parent || !renderedParent) {
+            return;
+        }
+        if (renderedParent === parent && parent.#namespaceURI === parent._astToken.namespace) {
+            return;
+        }
+        this.#namespaceURI = renderedParent.#getChildNamespace(this.elementType === 'authored' ? null : this._astToken.nodeName);
+    }
+    /**
+     * The namespace of an element named `name` rendered where this element is, for the
+     * element this element pretends to be.
+     *
+     * Where this element is has the namespace of this element, so the element gets the
+     * namespace an element written there gets. For a component, it is taken from the
+     * parent instead, as a parser that does not keep the name of a component out of
+     * the namespace may have taken it for an element (`<Svg>`, `<Math>`: the names are
+     * compared in lowercase).
+     */
+    #getNamespaceInPlace(name, renderedParent) {
+        let here = this.#namespaceURI;
+        if (this.elementType === 'authored' && renderedParent !== undefined) {
+            here = renderedParent ? renderedParent.#getChildNamespace(null) : HTML_NAMESPACE;
+        }
+        return getChildNamespace(name, here, null);
+    }
     /**
      * Initializes the pretender context for this element based on the given pretender
      * configurations. If a matching pretender is found or the element has an `as` attribute,
@@ -2869,6 +2983,8 @@ export class MLElement extends MLParentNode {
      * @param pretenders - Optional array of pretender configurations to match against
      */
     pretending(pretenders) {
+        const renderedParent = this.#getRenderedParent();
+        this.#resolveNamespace(renderedParent);
         // Pretender must not apply to a recognised standard HTML element (e.g. <marquee>,
         // <h1>, <button>). Allowing such elements to masquerade as another would silently
         // mask spec-driven rules — deprecation, ARIA role restrictions, browser support —
@@ -2896,7 +3012,6 @@ export class MLElement extends MLParentNode {
             return;
         }
         let nodeName;
-        let namespace = 'http://www.w3.org/1999/xhtml';
         const attributes = [];
         let aria;
         if (typeof pretenderElement === 'string') {
@@ -2904,7 +3019,6 @@ export class MLElement extends MLParentNode {
         }
         else {
             nodeName = pretenderElement.element;
-            namespace = pretenderElement.namespace === 'svg' ? 'http://www.w3.org/2000/svg' : namespace;
             if (pretenderElement.inheritAttrs) {
                 attributes.push(...this._astToken.attributes);
             }
@@ -2914,6 +3028,9 @@ export class MLElement extends MLParentNode {
             aria = pretenderElement.aria;
         }
         const slots = typeof pretenderElement === 'string' ? undefined : pretenderElement.slots;
+        const namespace = typeof pretenderElement !== 'string' && pretenderElement.namespace
+            ? pretenderNamespaceToURI(pretenderElement.namespace)
+            : this.#getNamespaceInPlace(nodeName, renderedParent);
         const as = new _a({
             ...this._astToken,
             uuid: this.uuid + '_pretender',
@@ -2935,7 +3052,7 @@ export class MLElement extends MLParentNode {
             type: 'origin',
             origin: this,
         };
-        const slotContent = typeof pretenderElement === 'string' ? undefined : this.#createSlotContent(pretenderElement, as, namespace);
+        const slotContent = typeof pretenderElement === 'string' ? undefined : this.#createSlotContent(pretenderElement, as);
         this.pretenderContext = {
             type: 'pretender',
             as,
@@ -3032,7 +3149,7 @@ export class MLElement extends MLParentNode {
      * constructor would otherwise re-register the origin's real close tag under
      * the virtual element.
      */
-    #createVirtualElement(spec, uuid, parentNodeUuid, fallbackNamespace) {
+    #createVirtualElement(spec, uuid, parentNodeUuid, renderedIn) {
         const attributes = [];
         if (spec.inheritAttrs) {
             attributes.push(...this._astToken.attributes);
@@ -3045,7 +3162,9 @@ export class MLElement extends MLParentNode {
             uuid,
             raw: `<${spec.element}>`,
             nodeName: spec.element,
-            namespace: getVirtualNamespace(spec, fallbackNamespace),
+            namespace: spec.namespace
+                ? pretenderNamespaceToURI(spec.namespace)
+                : renderedIn.#getChildNamespace(spec.element),
             elementType: spec.element.includes('-') ? 'web-component' : 'html',
             attributes,
             childNodes: [],
@@ -3064,7 +3183,7 @@ export class MLElement extends MLParentNode {
      * the children, so that the children given at the usage site stay the whole
      * content of the outermost element (the bare-string pretender behavior).
      */
-    #createSlotContent(node, as, namespace) {
+    #createSlotContent(node, as) {
         const { slots } = node;
         let wrapper = as;
         let contents = node.contents;
@@ -3073,20 +3192,23 @@ export class MLElement extends MLParentNode {
             if (slots.length > 1 || !slot) {
                 // The wrapper of each child is unknown, so the children are not validated,
                 // but a slot may still render unknown content (which may be a name).
+                this.#sharedWrapper = this.#findSharedWrapper(slots, as);
                 return {
                     wrapper: null,
                     mutable: slots.some(s => s.contents?.some(entry => 'dynamic' in entry) ?? false),
                     fill: (given) => given,
                 };
             }
-            wrapper = this.#createVirtualElement(slot, `${this.uuid}_pretender_slot`, this.uuid, namespace);
+            // The elements between the root and the wrapper are not known, so the wrapper is
+            // taken to be a child of the root unless the definition states its namespace.
+            wrapper = this.#createVirtualElement(slot, `${this.uuid}_pretender_slot`, this.uuid, as);
             contents = slot.contents ?? [{ slot: true }];
         }
         if (!contents) {
             return undefined;
         }
         const entries = contents.map((entry, i) => 'element' in entry
-            ? this.#createVirtualElement(entry, `${this.uuid}_pretender_content_${i}`, wrapper === as ? this.uuid : wrapper.uuid, namespace)
+            ? this.#createVirtualElement(entry, `${this.uuid}_pretender_content_${i}`, wrapper === as ? this.uuid : wrapper.uuid, wrapper)
             : entry);
         return {
             wrapper,
@@ -3372,17 +3494,3 @@ export class MLElement extends MLParentNode {
     }
 }
 _a = MLElement;
-/**
- * The namespace of a virtual element made from a pretender definition.
- * `svg` and `math` are foreign elements wherever they are written, and a
- * definition can only state `namespace: 'svg'`, so the name decides.
- */
-function getVirtualNamespace(spec, fallback) {
-    if (spec.namespace === 'svg' || spec.element === 'svg') {
-        return 'http://www.w3.org/2000/svg';
-    }
-    if (spec.element === 'math') {
-        return 'http://www.w3.org/1998/Math/MathML';
-    }
-    return fallback;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "5.1.1",
+	"version": "5.2.0",
 	"description": "The core module of markuplint",
 	"repository": {
 		"type": "git",
@@ -34,20 +34,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "5.1.1",
-		"@markuplint/html-parser": "5.1.1",
-		"@markuplint/html-spec": "5.1.1",
+		"@markuplint/config-presets": "5.2.0",
+		"@markuplint/html-parser": "5.2.0",
+		"@markuplint/html-spec": "5.2.0",
 		"@markuplint/i18n": "5.1.1",
 		"@markuplint/ml-ast": "5.1.1",
-		"@markuplint/ml-config": "5.1.1",
-		"@markuplint/ml-spec": "5.1.1",
-		"@markuplint/parser-utils": "5.1.1",
-		"@markuplint/selector": "5.1.1",
-		"@markuplint/shared": "5.1.1",
-		"@types/debug": "4.1.13",
-		"debug": "4.4.3",
-		"is-plain-object": "5.0.0",
-		"type-fest": "5.6.0"
-	},
-	"gitHead": "a940c8526e971d590d97395ce924910221208820"
+		"@markuplint/ml-config": "5.2.0",
+		"@markuplint/ml-spec": "5.2.0",
+		"@markuplint/parser-utils": "5.2.0",
+		"@markuplint/selector": "5.2.0",
+		"@markuplint/shared": "5.2.0",
+		"@types/debug": "^4.1.13",
+		"debug": "^4.4.3",
+		"is-plain-object": "^5.1.0",
+		"type-fest": "^5.10.0"
+	},
+	"gitHead": "d8b2feab77c9c862513615bea6b80d2817431878"
 }