@siteimprove/alfa-dom 0.112.0 → 0.114.0

package/dist/node/index.js

@@ -0,0 +1,74 @@
+import { Cache } from "@siteimprove/alfa-cache";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { BaseNode as BaseNode } from "./node.js";
+import { Attribute } from "./attribute.js";
+import { Comment } from "./comment.js";
+import { Document } from "./document.js";
+import { Shadow } from "./shadow.js";
+import { Element, Text } from "./slotable/index.js";
+import { Fragment } from "./fragment.js";
+import { Type } from "./type.js";
+import * as predicate from "./predicate/index.js";
+import * as traversal from "./traversal/index.js";
+const { or } = Refinement;
+export * from "./attribute.js";
+export * from "./comment.js";
+export * from "./document.js";
+export * from "./shadow.js";
+export * from "./slotable/index.js";
+// Load the element specific augments.
+import "./element/augment.js";
+export * from "./fragment.js";
+export * from "./type.js";
+/**
+ * @public
+ */
+export var Node;
+(function (Node) {
+    Node.isNode = or(Attribute.isAttribute, or(Comment.isComment, or(Document.isDocument, or(Element.isElement, or(Fragment.isFragment, or(Shadow.isShadow, or(Type.isType, Text.isText)))))));
+    Node.Traversal = BaseNode.Traversal;
+    Node.flatTree = BaseNode.flatTree;
+    Node.fullTree = BaseNode.fullTree;
+    Node.composedNested = BaseNode.composedNested;
+    const cacheWithDevice = Cache.empty();
+    const cacheWithoutDevice = Cache.empty();
+    function from(json, device) {
+        return device === undefined
+            ? cacheWithoutDevice.get(json, () => fromNode(json, device).run())
+            : cacheWithDevice
+                .get(json, Cache.empty)
+                .get(device, () => fromNode(json, device).run());
+    }
+    Node.from = from;
+    /**
+     * @internal
+     */
+    function fromNode(json, device) {
+        switch (json.type) {
+            case "element":
+                return Element.fromElement(json, fromNode, device);
+            case "attribute":
+                return Attribute.fromAttribute(json);
+            case "text":
+                return Text.fromText(json, device);
+            case "comment":
+                return Comment.fromComment(json);
+            case "document":
+                return Document.fromDocument(json, fromNode, device);
+            case "type":
+                return Type.fromType(json);
+            case "fragment":
+                return Fragment.fromFragment(json, fromNode, device);
+            default:
+                throw new Error(`Unexpected node of type: ${json.type}`);
+        }
+    }
+    Node.fromNode = fromNode;
+    Node.getNodesBetween = traversal.getNodesBetween;
+    Node.hasBox = predicate.hasBox, Node.isRoot = predicate.isRoot;
+    Node.hasChild = predicate.hasChild;
+    Node.hasDescendant = predicate.hasDescendant;
+    Node.hasInclusiveDescendant = predicate.hasInclusiveDescendant;
+    Node.hasTextContent = predicate.hasTextContent;
+})(Node || (Node = {}));
+//# sourceMappingURL=index.js.map

package/dist/{node.d.ts → node/node.d.ts}

@@ -5,84 +5,82 @@ import { Option } from "@siteimprove/alfa-option";
 import type { Predicate } from "@siteimprove/alfa-predicate";
 import type { Refinement } from "@siteimprove/alfa-refinement";
 import { Sequence } from "@siteimprove/alfa-sequence";
-import type { Trampoline } from "@siteimprove/alfa-trampoline";
 import type * as earl from "@siteimprove/alfa-earl";
 import * as json from "@siteimprove/alfa-json";
 import type * as sarif from "@siteimprove/alfa-sarif";
 import * as tree from "@siteimprove/alfa-tree";
-import { Attribute, Comment, Document, Element, Fragment, Shadow, Text, Type } from "./index.js";
-import * as predicate from "./node/predicate.js";
-import * as traversal from "./node/traversal.js";
+import type { Element, Node } from "./index.js";
 /**
  * @public
  */
-export declare abstract class Node<T extends string = string> extends tree.Node<"DOM traversal", Node.TraversalFlags, T> implements earl.Serializable<Node.EARL>, json.Serializable<tree.Node.JSON<T>>, sarif.Serializable<sarif.Location> {
+export declare abstract class BaseNode<T extends string = string> extends tree.Node<"DOM traversal", BaseNode.TraversalFlags, T> implements earl.Serializable<BaseNode.EARL>, json.Serializable<tree.Node.JSON<T>>, sarif.Serializable<sarif.Location> {
     protected constructor(children: Array<Node>, type: T, externalId?: string, internalId?: string, extraData?: any);
     /**
      * {@link https://dom.spec.whatwg.org/#concept-descendant-text-content}
      */
-    textContent(options?: Node.Traversal): string;
+    textContent(options?: BaseNode.Traversal): string;
     /**
      * Construct a sequence of descendants of this node sorted by tab index. Only
      * nodes with a non-negative tab index are included in the sequence.
      *
      * {@link https://html.spec.whatwg.org/multipage/#tabindex-value}
      */
-    tabOrder(): Sequence<Element>;
+    tabOrder(this: Node): Sequence<Element>;
     private _path;
     /**
      * @internal
      */
-    protected _internalPath(options?: Node.Traversal): string;
+    protected _internalPath(options?: BaseNode.Traversal): string;
     /**
      * Get an XPath that uniquely identifies the node across descendants of its
      * root.
      */
-    path(options?: Node.Traversal): string;
-    equals(value: Node): boolean;
+    path(options?: BaseNode.Traversal): string;
+    equals(value: BaseNode): boolean;
     equals(value: unknown): value is this;
-    toJSON(options?: Serializable.Options): Node.JSON<T>;
-    toEARL(): Node.EARL;
+    toJSON(options?: Serializable.Options): BaseNode.JSON<T>;
+    toEARL(): BaseNode.EARL;
     toSARIF(): sarif.Location;
 }
 /**
  * @public
  */
-export interface Node {
-    parent(options?: Node.Traversal): Option<Node>;
-    isParentOf(node: Node, options?: Node.Traversal): boolean;
-    root(options?: Node.Traversal): Node;
-    isRootOf(node: Node, options?: Node.Traversal): boolean;
-    children(options?: Node.Traversal): Sequence<Node>;
-    isChildOf(node: Node, options?: Node.Traversal): boolean;
-    descendants(options?: Node.Traversal): Sequence<Node>;
-    isDescendantOf(node: Node, options?: Node.Traversal): boolean;
-    inclusiveDescendants(options?: Node.Traversal): Sequence<Node>;
-    isInclusiveDescendantsOf(node: Node, options?: Node.Traversal): boolean;
-    ancestors(options?: Node.Traversal): Sequence<Node>;
-    isAncestorOf(node: Node, options?: Node.Traversal): boolean;
-    inclusiveAncestors(options?: Node.Traversal): Sequence<Node>;
-    isInclusiveAncestorOf(node: Node, options?: Node.Traversal): boolean;
-    siblings(options?: Node.Traversal): Sequence<Node>;
-    isSiblingOf(node: Node, options?: Node.Traversal): boolean;
-    inclusiveSiblings(options?: Node.Traversal): Sequence<Node>;
-    isInclusiveSiblingOf(node: Node, options?: Node.Traversal): boolean;
-    preceding(options?: Node.Traversal): Sequence<Node>;
-    following(options?: Node.Traversal): Sequence<Node>;
-    first(options?: Node.Traversal): Option<Node>;
-    last(options?: Node.Traversal): Option<Node>;
-    previous(options?: Node.Traversal): Option<Node>;
-    next(options?: Node.Traversal): Option<Node>;
-    index(options?: Node.Traversal, predicate?: Predicate<Node>): number;
-    closest<T extends Node>(refinement: Refinement<Node, T>, options?: Node.Traversal): Option<T>;
-    closest(predicate: Predicate<Node>, options?: Node.Traversal): Option<Node>;
+export interface BaseNode {
+    parent(options?: BaseNode.Traversal): Option<Node>;
+    isParentOf(node: Node, options?: BaseNode.Traversal): boolean;
+    root(options?: BaseNode.Traversal): Node;
+    isRootOf(node: Node, options?: BaseNode.Traversal): boolean;
+    children(options?: BaseNode.Traversal): Sequence<Node>;
+    isChildOf(node: Node, options?: BaseNode.Traversal): boolean;
+    descendants(options?: BaseNode.Traversal): Sequence<Node>;
+    isDescendantOf(node: Node, options?: BaseNode.Traversal): boolean;
+    inclusiveDescendants(options?: BaseNode.Traversal): Sequence<Node>;
+    isInclusiveDescendantsOf(node: Node, options?: BaseNode.Traversal): boolean;
+    ancestors(options?: BaseNode.Traversal): Sequence<Node>;
+    isAncestorOf(node: Node, options?: BaseNode.Traversal): boolean;
+    inclusiveAncestors(options?: BaseNode.Traversal): Sequence<Node>;
+    isInclusiveAncestorOf(node: Node, options?: BaseNode.Traversal): boolean;
+    siblings(options?: BaseNode.Traversal): Sequence<Node>;
+    isSiblingOf(node: Node, options?: BaseNode.Traversal): boolean;
+    inclusiveSiblings(options?: BaseNode.Traversal): Sequence<Node>;
+    isInclusiveSiblingOf(node: Node, options?: BaseNode.Traversal): boolean;
+    preceding(options?: BaseNode.Traversal): Sequence<Node>;
+    following(options?: BaseNode.Traversal): Sequence<Node>;
+    first(options?: BaseNode.Traversal): Option<Node>;
+    last(options?: BaseNode.Traversal): Option<Node>;
+    previous(options?: BaseNode.Traversal): Option<Node>;
+    next(options?: BaseNode.Traversal): Option<Node>;
+    index(options?: BaseNode.Traversal, predicate?: Predicate<Node>): number;
+    closest<T extends Node>(refinement: Refinement<Node, T>, options?: BaseNode.Traversal): Option<T>;
+    closest(predicate: Predicate<Node>, options?: BaseNode.Traversal): Option<Node>;
 }
 /**
  * @public
  */
-export declare namespace Node {
+export declare namespace BaseNode {
     interface JSON<T extends string = string> extends tree.Node.JSON<T> {
         path?: string;
+        children?: Array<Node.JSON>;
     }
     interface SerializationOptions extends json.Serializable.Options {
         device?: Device;
@@ -102,7 +100,6 @@ export declare namespace Node {
             "@id": string;
         };
     }
-    function isNode(value: unknown): value is Node;
     const Traversal: {
         of: (...flags: import("@siteimprove/alfa-array").Array<0 | 1 | 2 | 4 | "composed" | "flattened" | "nested">) => {
             has(flag: 0 | 1 | 2 | 4 | "composed" | "flattened" | "nested"): boolean;
@@ -162,7 +159,7 @@ export declare namespace Node {
         nested: 1 | 2 | 4;
     };
     type Traversal = ReturnType<(typeof Traversal)["of"]>;
-    type TraversalFlags = (typeof Node.Traversal.allFlags)[number];
+    type TraversalFlags = (typeof BaseNode.Traversal.allFlags)[number];
     /**
      * Traversal options to traverse the flat tree.
      *
@@ -245,122 +242,5 @@ export declare namespace Node {
         flattened: boolean;
         nested: boolean;
     };
-    function from(json: Element.JSON, device?: Device): Element;
-    function from(json: Attribute.JSON, device?: Device): Attribute;
-    function from(json: Text.JSON, device?: Device): Text;
-    function from(json: Comment.JSON, device?: Device): Comment;
-    function from(json: Document.JSON, device?: Device): Document;
-    function from(json: Type.JSON, device?: Device): Document;
-    function from(json: Fragment.JSON, device?: Device): Fragment;
-    function from(json: JSON, device?: Device): Node;
-    /**
-     * @internal
-     */
-    function fromNode(json: JSON, device?: Device): Trampoline<Node>;
-    interface ElementReplacementOptions {
-        predicate: Predicate<Element>;
-        newElements: Iterable<Element>;
-    }
-    /**
-     * Creates a new `Element` instance with the same value as the original and
-     * deeply referentially non-equal. Optionally replaces child elements based
-     * on a predicate.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Element, options?: ElementReplacementOptions, device?: Device): Element;
-    /**
-     * Creates a new `Attribute` instance with the same value as the original and
-     * referentially non-equal.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Attribute, options?: ElementReplacementOptions, device?: Device): Attribute;
-    /**
-     * Creates a new `Text` instance with the same value as the original and
-     * referentially non-equal.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Text, options?: ElementReplacementOptions, device?: Device): Text;
-    /**
-     * Creates a new `Comment` instance with the same value as the original and
-     * referentially non-equal.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Comment, options?: ElementReplacementOptions, device?: Device): Comment;
-    /**
-     * Creates a new `Document` instance with the same value as the original and
-     * deeply referentially non-equal. Optionally replaces child elements based
-     * on a predicate.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Document, options?: ElementReplacementOptions, device?: Device): Document;
-    /**
-     * Creates a new `Type` instance with the same value as the original and
-     * referentially non-equal.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Type, options?: ElementReplacementOptions, device?: Device): Document;
-    /**
-     * Creates a new `Fragment` instance with the same value as the original and
-     * deeply referentially non-equal. Optionally replaces child elements based
-     * on a predicate.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Fragment, options?: ElementReplacementOptions, device?: Device): Fragment;
-    /**
-     * Creates a new `Shadow` instance with the same value as the original and
-     * deeply referentially non-equal. Optionally replaces child elements based
-     * on a predicate.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     * `undefined`.
-     */
-    function clone(node: Shadow, options?: ElementReplacementOptions, device?: Device): Shadow;
-    /**
-     * Creates a new `Node` instance with the same value as the original and
-     * deeply referentially non-equal. Optionally replaces child elements based
-     * on a predicate.
-     *
-     * @remarks
-     * The clone will have the same `externalId` as the original.
-     * The clone will *not* get `extraData` from the original, instead it will be
-     *   `undefined`.
-     */
-    function clone(node: Node, options?: ElementReplacementOptions, device?: Device): Node;
-    /**
-     * @internal
-     */
-    function cloneNode(node: Node, options?: ElementReplacementOptions, device?: Device): Trampoline<Node>;
-    const getNodesBetween: typeof traversal.getNodesBetween;
-    const hasBox: typeof predicate.hasBox, hasChild: typeof predicate.hasChild, hasDescendant: typeof predicate.hasDescendant, hasInclusiveDescendant: typeof predicate.hasInclusiveDescendant, hasTextContent: typeof predicate.hasTextContent, isRoot: typeof predicate.isRoot;
 }
 //# sourceMappingURL=node.d.ts.map

package/dist/{node.js → node/node.js}

@@ -1,29 +1,24 @@
-import { Cache } from "@siteimprove/alfa-cache";
 import { Comparable, Comparison, } from "@siteimprove/alfa-comparable";
 import { Flags } from "@siteimprove/alfa-flags";
 import { Serializable } from "@siteimprove/alfa-json";
 import { Lazy } from "@siteimprove/alfa-lazy";
 import { Option } from "@siteimprove/alfa-option";
-import { Selective } from "@siteimprove/alfa-selective";
 import { Sequence } from "@siteimprove/alfa-sequence";
 import { String } from "@siteimprove/alfa-string";
 import * as json from "@siteimprove/alfa-json";
 import * as tree from "@siteimprove/alfa-tree";
-import { Attribute, Comment, Document, Element, Fragment, Shadow, Slot, Slotable, Text, Type, } from "./index.js";
-import * as predicate from "./node/predicate.js";
-import * as traversal from "./node/traversal.js";
 /**
  * @public
  */
-export class Node extends tree.Node {
+export class BaseNode extends tree.Node {
     constructor(children, type, externalId, internalId, extraData) {
         super(children, type, externalId, internalId, extraData);
     }
     /**
      * {@link https://dom.spec.whatwg.org/#concept-descendant-text-content}
      */
-    textContent(options = Node.Traversal.empty) {
-        return String.flatten(this.descendants(options).filter(Text.isText).join(""));
+    textContent(options = BaseNode.Traversal.empty) {
+        return String.flatten(this.descendants(options).filter(isText).join(""));
     }
     /**
      * Construct a sequence of descendants of this node sorted by tab index. Only
@@ -46,7 +41,7 @@ export class Node extends tree.Node {
          * tabIndexes.
          */
         function candidates(node) {
-            if (Element.isElement(node)) {
+            if (isElement(node)) {
                 const element = node;
                 const tabIndex = element.tabIndex();
                 // If the element is a shadow host that doesn't block keyboard navigation
@@ -67,9 +62,9 @@ export class Node extends tree.Node {
                     return Sequence.of([element, tabIndex]);
                 }
                 // If the element is a slot, we replace it by its assigned nodes.
-                if (Slot.isSlot(element)) {
+                if (isSlot(element)) {
                     return Sequence.from(element.assignedNodes())
-                        .filter(Element.isElement)
+                        .filter(isElement)
                         .map((element) => [element, tabIndex]);
                 }
                 // If the element is keyboard focusable, record it and recurse.
@@ -138,20 +133,33 @@ export class Node extends tree.Node {
         }
         return candidates(this).sortWith(comparer).flatMap(expand);
     }
-    parent(options = Node.Traversal.empty) {
+    /**
+     * @privateRemarks
+     * The type assertions to `Node` in here are technically incorrect.
+     * BaseNode could be extended to another class which is then not added to the
+     * Node union, in which case the assertions would be wrong. This scenario is
+     * however quite unlikely given that BaseNode is not exported out of this
+     * package. So it is only a matter of us not doing so, which sound OK enough.
+     * It is not possible at this level to do any sort of runtime type checking
+     * without creating circular dependencies, and the parent method here has
+     * to extends the one in `alfa-tree/Node`.
+     */
+    parent(options = BaseNode.Traversal.empty) {
         const parent = this._parent;
         // If we traverse the flat tree, we want to jump over shadow roots.
-        if (options.isSet(Node.Traversal.flattened)) {
+        if (options.isSet(BaseNode.Traversal.flattened)) {
             return parent.flatMap((parent) => {
-                if (Shadow.isShadow(parent)) {
+                if (isShadow(parent)) {
                     return parent.host;
                 }
                 // Additionally, if this is a slottable light child of a shadow host, we want
                 // to search for where it is slotted, and return that parent instead.
-                if (Element.isElement(parent) &&
+                if (isElement(parent) &&
                     parent.shadow.isSome() &&
-                    Slotable.isSlotable(this)) {
-                    return this.assignedSlot().flatMap((slot) => slot.parent(options));
+                    isSlotable(this)) {
+                    return this
+                        .assignedSlot()
+                        .flatMap((slot) => slot.parent(options));
                 }
                 return Option.of(parent);
             });
@@ -182,7 +190,7 @@ export class Node extends tree.Node {
     // For the sake of simplicity, and until we encounter errors due to this,
     // we accept the risk of caching the value assuming that it will only be
     // computed on fully frozen trees.
-    path(options = Node.Traversal.empty) {
+    path(options = BaseNode.Traversal.empty) {
         if (this._path[options.value] == undefined) {
             this._path[options.value] = this._internalPath(options);
         }
@@ -193,11 +201,15 @@ export class Node extends tree.Node {
     }
     toJSON(options) {
         const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        // `super.toJSON` types the children as tree.Node.JSON, but we know they
+        // are generated by applying `#toJSON` on each child, and children are
+        // here forced to be Node.
+        const base = super.toJSON(options);
         return {
-            ...super.toJSON(options),
+            ...base,
             ...(json.Serializable.Verbosity.Minimal < verbosity &&
                 verbosity < json.Serializable.Verbosity.Medium
-                ? { path: this.path(Node.composedNested) }
+                ? { path: this.path(BaseNode.composedNested) }
                 : {}),
         };
     }
@@ -228,89 +240,42 @@ export class Node extends tree.Node {
 /**
  * @public
  */
-(function (Node) {
-    function isNode(value) {
-        return value instanceof Node;
-    }
-    Node.isNode = isNode;
-    Node.Traversal = Flags.named("DOM traversal", "composed", "flattened", "nested");
+(function (BaseNode) {
+    BaseNode.Traversal = Flags.named("DOM traversal", "composed", "flattened", "nested");
     /**
      * Traversal options to traverse the flat tree.
      *
      * {@link https://drafts.csswg.org/css-scoping-1/#flattening}
      */
-    Node.flatTree = Node.Traversal.of("flattened");
+    BaseNode.flatTree = BaseNode.Traversal.of("flattened");
     /**
      * Traversal options to traverse all relevant nodes (flat tree and inside
      * nested browsing container), a very frequent use case.
      */
-    Node.fullTree = Node.Traversal.of("flattened", "nested");
+    BaseNode.fullTree = BaseNode.Traversal.of("flattened", "nested");
     /**
      * Traversal options to traverse in shadow-including tree order and inside
      * nested browsing context container, a common use case.
      */
-    Node.composedNested = Node.Traversal.of("composed", "nested");
-    const cacheWithDevice = Cache.empty();
-    const cacheWithoutDevice = Cache.empty();
-    function from(json, device) {
-        return device === undefined
-            ? cacheWithoutDevice.get(json, () => fromNode(json, device).run())
-            : cacheWithDevice
-                .get(json, Cache.empty)
-                .get(device, () => fromNode(json, device).run());
-    }
-    Node.from = from;
-    /**
-     * @internal
-     */
-    function fromNode(json, device) {
-        switch (json.type) {
-            case "element":
-                return Element.fromElement(json, device);
-            case "attribute":
-                return Attribute.fromAttribute(json);
-            case "text":
-                return Text.fromText(json, device);
-            case "comment":
-                return Comment.fromComment(json);
-            case "document":
-                return Document.fromDocument(json, device);
-            case "type":
-                return Type.fromType(json);
-            case "fragment":
-                return Fragment.fromFragment(json, device);
-            default:
-                throw new Error(`Unexpected node of type: ${json.type}`);
-        }
-    }
-    Node.fromNode = fromNode;
-    function clone(node, options, device) {
-        return cloneNode(node, options, device).run();
-    }
-    Node.clone = clone;
-    /**
-     * @internal
-     */
-    function cloneNode(node, options = {
-        predicate: () => false,
-        newElements: [],
-    }, device) {
-        return Selective.of(node)
-            .if(Element.isElement, Element.cloneElement(options, device))
-            .if(Attribute.isAttribute, Attribute.cloneAttribute)
-            .if(Text.isText, Text.cloneText(device))
-            .if(Comment.isComment, Comment.cloneComment)
-            .if(Document.isDocument, Document.cloneDocument(options, device))
-            .if(Type.isType, Type.cloneType)
-            .if(Fragment.isFragment, Fragment.cloneFragment(options, device))
-            .if(Shadow.isShadow, Shadow.cloneShadow(options, device))
-            .else(() => {
-            throw new Error(`Unexpected node of type: ${node.type}`);
-        })
-            .get();
-    }
-    Node.cloneNode = cloneNode;
-    Node.getNodesBetween = traversal.getNodesBetween;
-    Node.hasBox = predicate.hasBox, Node.hasChild = predicate.hasChild, Node.hasDescendant = predicate.hasDescendant, Node.hasInclusiveDescendant = predicate.hasInclusiveDescendant, Node.hasTextContent = predicate.hasTextContent, Node.isRoot = predicate.isRoot;
-})(Node || (Node = {}));
+    BaseNode.composedNested = BaseNode.Traversal.of("composed", "nested");
+})(BaseNode || (BaseNode = {}));
+/*
+ * Sub-nodes type guards, we need to duplicate them to avoid circular references.
+ * Here, we only use the differentiating `type` property.
+ */
+function isElement(node) {
+    return node.type === "element";
+}
+function isSlot(element) {
+    return element.name === "slot";
+}
+function isShadow(node) {
+    return node.type === "shadow";
+}
+function isSlotable(node) {
+    return isElement(node) || isText(node);
+}
+function isText(node) {
+    return node.type === "text";
+}
 //# sourceMappingURL=node.js.map

package/dist/node/predicate/has-box.d.ts

@@ -1,8 +1,7 @@
 import type { Device } from "@siteimprove/alfa-device";
 import type { Predicate } from "@siteimprove/alfa-predicate";
 import type { Rectangle } from "@siteimprove/alfa-rectangle";
-import type { Element } from "../element.js";
-import type { Text } from "../text.js";
+import type { Element, Text } from "../index.js";
 /**
  * @public
  */

package/dist/node/predicate/has-child.d.ts

@@ -1,5 +1,5 @@
 import type { Predicate } from "@siteimprove/alfa-predicate";
-import { Node } from "../../node.js";
+import type { Node } from "../index.js";
 /**
  * @public
  */

package/dist/node/predicate/has-child.js

@@ -1,8 +1,8 @@
-import { Node } from "../../node.js";
+import { BaseNode } from "../node.js";
 /**
  * @public
  */
-export function hasChild(predicate, options = Node.Traversal.empty) {
+export function hasChild(predicate, options = BaseNode.Traversal.empty) {
     return (node) => node.children(options).some(predicate);
 }
 //# sourceMappingURL=has-child.js.map

package/dist/node/predicate/has-descendant.d.ts

@@ -1,5 +1,5 @@
 import type { Predicate } from "@siteimprove/alfa-predicate";
-import { Node } from "../../node.js";
+import type { Node } from "../index.js";
 /**
  * @public
  */

package/dist/node/predicate/has-descendant.js

@@ -1,8 +1,8 @@
-import { Node } from "../../node.js";
+import { BaseNode } from "../node.js";
 /**
  * @public
  */
-export function hasDescendant(predicate, options = Node.Traversal.empty) {
+export function hasDescendant(predicate, options = BaseNode.Traversal.empty) {
     return (node) => node.descendants(options).some(predicate);
 }
 //# sourceMappingURL=has-descendant.js.map

package/dist/node/predicate/has-inclusive-descendant.d.ts

@@ -1,5 +1,5 @@
 import type { Predicate } from "@siteimprove/alfa-predicate";
-import { Node } from "../../node.js";
+import type { Node } from "../index.js";
 /**
  * @public
  */

package/dist/node/predicate/has-inclusive-descendant.js

@@ -1,8 +1,8 @@
-import { Node } from "../../node.js";
+import { BaseNode } from "../node.js";
 /**
  * @public
  */
-export function hasInclusiveDescendant(predicate, options = Node.Traversal.empty) {
+export function hasInclusiveDescendant(predicate, options = BaseNode.Traversal.empty) {
     return (node) => node.inclusiveDescendants(options).some(predicate);
 }
 //# sourceMappingURL=has-inclusive-descendant.js.map

package/dist/node/predicate/has-text-content.d.ts

@@ -1,5 +1,5 @@
 import { Predicate } from "@siteimprove/alfa-predicate";
-import { Node } from "../../node.js";
+import type { Node } from "../index.js";
 /**
  * @public
  */