@siteimprove/alfa-dom 0.89.2

package/dist/node/element.d.ts

@@ -0,0 +1,122 @@
+import type { Device } from "@siteimprove/alfa-device";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Rectangle } from "@siteimprove/alfa-rectangle";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import type { Namespace } from "../namespace.js";
+import { Node } from "../node.js";
+import { Block } from "../style/block.js";
+import { Attribute } from "./attribute.js";
+import { Document } from "./document.js";
+import { Shadow } from "./shadow.js";
+import { Slot } from "./slot.js";
+import { Slotable } from "./slotable.js";
+import * as helpers from "./element/input-type.js";
+import * as predicate from "./element/predicate.js";
+/**
+ * @public
+ */
+export declare class Element<N extends string = string> extends Node<"element"> implements Slot, Slotable {
+    static of<N extends string = string>(namespace: Option<Namespace>, prefix: Option<string>, name: N, attributes?: Iterable<Attribute>, children?: Iterable<Node>, style?: Option<Block>, box?: Option<Rectangle>, device?: Option<Device>, externalId?: string, serializationId?: string, extraData?: any): Element<N>;
+    private readonly _namespace;
+    private readonly _prefix;
+    private readonly _name;
+    private readonly _attributes;
+    private readonly _style;
+    private _shadow;
+    private _content;
+    private readonly _id;
+    private readonly _classes;
+    private readonly _boxes;
+    private constructor();
+    get namespace(): Option<Namespace>;
+    get prefix(): Option<string>;
+    get name(): N;
+    get qualifiedName(): string;
+    get attributes(): Sequence<Attribute>;
+    get style(): Option<Block>;
+    get shadow(): Option<Shadow>;
+    get content(): Option<Document>;
+    /**
+     * {@link https://dom.spec.whatwg.org/#concept-id}
+     */
+    get id(): Option<string>;
+    /**
+     * {@link https://dom.spec.whatwg.org/#concept-class}
+     */
+    get classes(): Sequence<string>;
+    getBoundingBox(device: Device): Option<Rectangle>;
+    children(options?: Node.Traversal): Sequence<Node>;
+    attribute<A extends string = string>(name: A): Option<Attribute<A>>;
+    attribute<A extends string = string>(predicate: Predicate<Attribute<A>>): Option<Attribute<A>>;
+    /**
+     * {@link https://html.spec.whatwg.org/#void-elements}
+     */
+    isVoid(): boolean;
+    /**
+     * {@link https://html.spec.whatwg.org/#dom-tabindex}
+     */
+    tabIndex(): Option<number>;
+    /**
+     * {@link https://dom.spec.whatwg.org/#dom-slotable-assignedslot}
+     */
+    assignedSlot(): Option<Slot>;
+    /**
+     * {@link https://html.spec.whatwg.org/#dom-slot-assignednodes}
+     */
+    assignedNodes(): Iterable<Slotable>;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Element.MinimalJSON;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.High;
+    }): Element.JSON & {
+        assignedSlot: Element.MinimalJSON | null;
+    };
+    toJSON(options?: Node.SerializationOptions): Element.JSON<N>;
+    toString(): string;
+    /**
+     * @internal
+     */
+    _attachShadow(shadow: Shadow): boolean;
+    /**
+     * @internal
+     */
+    _attachContent(document: Document): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Element {
+    interface MinimalJSON extends Node.JSON<"element"> {
+    }
+    interface JSON<N extends string = string> extends Node.JSON<"element"> {
+        namespace: string | null;
+        prefix: string | null;
+        name: N;
+        attributes: Array<Attribute.JSON>;
+        style: Block.JSON | string | null;
+        shadow: Shadow.JSON | null;
+        content: Document.JSON | null;
+        box: Rectangle.JSON | null;
+    }
+    function isElement(value: unknown): value is Element;
+    /**
+     * @internal
+     */
+    function fromElement<N extends string = string>(json: JSON<N>, device?: Device): Trampoline<Element<N>>;
+    /**
+     * @internal
+     */
+    function cloneElement(options: Node.ElementReplacementOptions, device?: Device): (element: Element) => Trampoline<Element>;
+    const hasAttribute: typeof predicate.hasAttribute, hasBox: typeof predicate.hasBox, hasDisplaySize: typeof predicate.hasDisplaySize, hasId: typeof predicate.hasId, hasInputType: typeof predicate.hasInputType, hasName: typeof predicate.hasName, hasNamespace: typeof predicate.hasNamespace, hasTabIndex: typeof predicate.hasTabIndex, hasUniqueId: Predicate<Element<string>>, isBrowsingContextContainer: typeof predicate.isBrowsingContextContainer, isContent: typeof predicate.isContent, isActuallyDisabled: typeof predicate.isActuallyDisabled, isDocumentElement: typeof predicate.isDocumentElement, isDraggable: typeof predicate.isDraggable, isEditingHost: typeof predicate.isEditingHost, isFallback: typeof predicate.isFallback, isScopedTo: typeof predicate.isScopedTo, isSuggestedFocusable: typeof predicate.isSuggestedFocusable, isReplaced: typeof predicate.isReplaced;
+    const inputType: typeof helpers.inputType;
+}
+//# sourceMappingURL=element.d.ts.map

package/dist/node/element.js

@@ -0,0 +1,330 @@
+import { Cache } from "@siteimprove/alfa-cache";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { None, Option, Some } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Rectangle } from "@siteimprove/alfa-rectangle";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Block } from "../style/block.js";
+import { Declaration } from "../style/declaration.js";
+import { Attribute } from "./attribute.js";
+import { Document } from "./document.js";
+import { Shadow } from "./shadow.js";
+import { Slot } from "./slot.js";
+import { Slotable } from "./slotable.js";
+import * as helpers from "./element/input-type.js";
+import * as predicate from "./element/predicate.js";
+const { isEmpty } = Iterable;
+const { not } = Predicate;
+/**
+ * @public
+ */
+export class Element extends Node {
+    static of(namespace, prefix, name, attributes = [], children = [], style = None, box = None, device = None, externalId, serializationId, extraData) {
+        return new Element(namespace, prefix, name, Array.from(attributes), Array.from(children), style, box, device, externalId, serializationId, extraData);
+    }
+    _namespace;
+    _prefix;
+    _name;
+    _attributes;
+    _style;
+    _shadow = None;
+    _content = None;
+    _id;
+    _classes;
+    _boxes;
+    constructor(namespace, prefix, name, attributes, children, style, box, device, externalId, serializationId, extraData) {
+        super(children, "element", externalId, serializationId, extraData);
+        this._namespace = namespace;
+        this._prefix = prefix;
+        this._name = name;
+        this._attributes = new Map(attributes
+            .filter((attribute) => attribute._attachOwner(this))
+            .map((attribute) => [attribute.qualifiedName, attribute]));
+        style.forEach((block) => Iterable.forEach(block, (declaration) => declaration._attachOwner(this)));
+        this._style = style;
+        this._id = this.attribute("id").map((attr) => attr.value);
+        this._classes = this.attribute("class")
+            .map((attr) => attr.value.trim().split(/\s+/))
+            .getOr([]);
+        this._boxes = Cache.from(device.isSome() && box.isSome() ? [[device.get(), box.get()]] : []);
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    get name() {
+        return this._name;
+    }
+    get qualifiedName() {
+        return this._prefix.reduce((name, prefix) => `${prefix}:${name}`, this._name);
+    }
+    get attributes() {
+        return Sequence.from(this._attributes.values());
+    }
+    get style() {
+        return this._style;
+    }
+    get shadow() {
+        return this._shadow;
+    }
+    get content() {
+        return this._content;
+    }
+    /**
+     * {@link https://dom.spec.whatwg.org/#concept-id}
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * {@link https://dom.spec.whatwg.org/#concept-class}
+     */
+    get classes() {
+        return Sequence.from(this._classes);
+    }
+    getBoundingBox(device) {
+        return this._boxes.get(device);
+    }
+    children(options = Node.Traversal.empty) {
+        const treeChildren = this._children;
+        const children = [];
+        if (options.isSet(Node.Traversal.flattened)) {
+            if (this._shadow.isSome()) {
+                return this._shadow.get().children(options);
+            }
+            if (Slot.isSlot(this)) {
+                return Sequence.from(this.assignedNodes());
+            }
+            for (const child of treeChildren) {
+                if (Slot.isSlot(child)) {
+                    children.push(...child.children(options));
+                }
+                else {
+                    children.push(child);
+                }
+            }
+        }
+        else {
+            if (options.isSet(Node.Traversal.composed) && this._shadow.isSome()) {
+                children.push(this._shadow.get());
+            }
+            children.push(...treeChildren);
+        }
+        if (options.isSet(Node.Traversal.nested) && this._content.isSome()) {
+            children.push(this._content.get());
+        }
+        return Sequence.from(children);
+    }
+    attribute(nameOrPredicate) {
+        if (typeof nameOrPredicate === "string") {
+            return Option.from(this._attributes.get(nameOrPredicate));
+        }
+        else {
+            return Iterable.find(this._attributes.values(), nameOrPredicate);
+        }
+    }
+    /**
+     * {@link https://html.spec.whatwg.org/#void-elements}
+     */
+    isVoid() {
+        switch (this._name) {
+            case "area":
+            case "base":
+            case "basefont":
+            case "bgsound":
+            case "br":
+            case "col":
+            case "embed":
+            case "frame":
+            case "hr":
+            case "img":
+            case "input":
+            case "link":
+            case "meta":
+            case "param":
+            case "source":
+            case "track":
+            case "wbr":
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * {@link https://html.spec.whatwg.org/#dom-tabindex}
+     */
+    tabIndex() {
+        for (const tabIndex of this.attribute("tabindex")) {
+            const number = parseInt(tabIndex.value, 10);
+            //Checking if tabindex isn't NaN, undefined, null, Infinity
+            if (number === number && number === (number | 0)) {
+                return Some.of(number);
+            }
+        }
+        if (Element.isSuggestedFocusable(this)) {
+            return Some.of(0);
+        }
+        return None;
+    }
+    /**
+     * {@link https://dom.spec.whatwg.org/#dom-slotable-assignedslot}
+     */
+    assignedSlot() {
+        return Slotable.findSlot(this);
+    }
+    /**
+     * {@link https://html.spec.whatwg.org/#dom-slot-assignednodes}
+     */
+    assignedNodes() {
+        return Slot.findSlotables(this);
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options) {
+        let path = this.parent(options)
+            .map((parent) => parent.path(options))
+            .getOr("/");
+        path += path === "/" ? "" : "/";
+        path += this._name;
+        const index = this.preceding(options)
+            .filter(Element.isElement)
+            .count((element) => element._name === this._name);
+        path += `[${index + 1}]`;
+        return path;
+    }
+    toJSON(options) {
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        const result = super.toJSON(options);
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        if (verbosity >= json.Serializable.Verbosity.High) {
+            result.assignedSlot = this.assignedSlot()
+                .map((slot) => slot.toJSON({ verbosity: json.Serializable.Verbosity.Minimal }))
+                .getOr(null);
+        }
+        return {
+            ...result,
+            namespace: this._namespace.getOr(null),
+            prefix: this._prefix.getOr(null),
+            name: this._name,
+            attributes: [...this._attributes.values()].map((attribute) => attribute.toJSON(options)),
+            style: this._style.map((style) => style.toJSON()).getOr(null),
+            shadow: this._shadow.map((shadow) => shadow.toJSON(options)).getOr(null),
+            content: this._content
+                .map((content) => content.toJSON(options))
+                .getOr(null),
+            box: options?.device === undefined
+                ? null
+                : this._boxes
+                    .get(options.device)
+                    .map((box) => box.toJSON())
+                    .getOr(null),
+        };
+    }
+    toString() {
+        const name = this.qualifiedName;
+        const attributes = [...this._attributes.values()]
+            .map((attribute) => ` ${attribute.toString()}`)
+            .join("");
+        if (this.isVoid()) {
+            return `<${name}${attributes}>`;
+        }
+        const children = [...this._shadow, ...this._children, ...this._content]
+            .map((child) => {
+            const value = child.toString();
+            // If the child is only spaces, we do not want to trim them to nothingness.
+            if (value.match(/\s+/) !== null) {
+                return value;
+            }
+            return value.trim();
+        })
+            .filter(not(isEmpty))
+            .map(String.indent)
+            .join("\n");
+        return `<${name}${attributes}>${children === "" ? "" : `\n${children}\n`}</${name}>`;
+    }
+    /**
+     * @internal
+     */
+    _attachShadow(shadow) {
+        if (this._frozen || this._shadow.isSome() || !shadow._attachHost(this)) {
+            return false;
+        }
+        this._shadow = Option.of(shadow);
+        return true;
+    }
+    /**
+     * @internal
+     */
+    _attachContent(document) {
+        if (this._frozen ||
+            this._content.isSome() ||
+            !document._attachFrame(this)) {
+            return false;
+        }
+        this._content = Option.of(document);
+        return true;
+    }
+}
+/**
+ * @public
+ */
+(function (Element) {
+    function isElement(value) {
+        return value instanceof Element;
+    }
+    Element.isElement = isElement;
+    /**
+     * @internal
+     */
+    function fromElement(json, device) {
+        return Trampoline.traverse(json.children ?? [], (child) => Node.fromNode(child, device)).map((children) => {
+            const element = Element.of(Option.from(json.namespace), Option.from(json.prefix), json.name, json.attributes.map((attribute) => Attribute.fromAttribute(attribute).run()), children, json.style?.length === 0
+                ? None
+                : Option.from(json.style).map(Block.from), Option.from(json.box).map(Rectangle.from), Option.from(device), json.externalId, json.serializationId);
+            if (json.shadow !== null) {
+                element._attachShadow(Shadow.fromShadow(json.shadow, device).run());
+            }
+            if (json.content !== null) {
+                element._attachContent(Document.fromDocument(json.content, device).run());
+            }
+            return element;
+        });
+    }
+    Element.fromElement = fromElement;
+    /**
+     * @internal
+     */
+    function cloneElement(options, device) {
+        return (element) => Trampoline.traverse(element.children(), (child) => {
+            if (Element.isElement(child) && options.predicate(child)) {
+                return Trampoline.done(Array.from(options.newElements));
+            }
+            return Node.cloneNode(child, options, device).map((node) => [node]);
+        }).map((children) => {
+            const deviceOption = Option.from(device);
+            const clonedElement = Element.of(element.namespace, element.prefix, element.name, element.attributes.map((attribute) => Attribute.clone(attribute, options, device)), Iterable.flatten(children), element.style.map((block) => {
+                return Block.of(Iterable.map(block.declarations, (declaration) => Declaration.of(declaration.name, declaration.value, declaration.important)));
+            }), deviceOption.flatMap((d) => element.getBoundingBox(d)), deviceOption, element.externalId, element.serializationId, element.extraData);
+            if (element.shadow.isSome()) {
+                clonedElement._attachShadow(Shadow.clone(element.shadow.get(), options, device));
+            }
+            if (element.content.isSome()) {
+                clonedElement._attachContent(Document.clone(element.content.get(), options, device));
+            }
+            return clonedElement;
+        });
+    }
+    Element.cloneElement = cloneElement;
+    Element.hasAttribute = predicate.hasAttribute, Element.hasBox = predicate.hasBox, Element.hasDisplaySize = predicate.hasDisplaySize, Element.hasId = predicate.hasId, Element.hasInputType = predicate.hasInputType, Element.hasName = predicate.hasName, Element.hasNamespace = predicate.hasNamespace, Element.hasTabIndex = predicate.hasTabIndex, Element.hasUniqueId = predicate.hasUniqueId, Element.isBrowsingContextContainer = predicate.isBrowsingContextContainer, Element.isContent = predicate.isContent, Element.isActuallyDisabled = predicate.isActuallyDisabled, Element.isDocumentElement = predicate.isDocumentElement, Element.isDraggable = predicate.isDraggable, Element.isEditingHost = predicate.isEditingHost, Element.isFallback = predicate.isFallback, Element.isScopedTo = predicate.isScopedTo, Element.isSuggestedFocusable = predicate.isSuggestedFocusable, Element.isReplaced = predicate.isReplaced;
+    Element.inputType = helpers.inputType;
+})(Element || (Element = {}));
+//# sourceMappingURL=element.js.map

package/dist/node/fragment.d.ts

@@ -0,0 +1,38 @@
+import type { Device } from "@siteimprove/alfa-device";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Node } from "../node.js";
+/**
+ * @public
+ */
+export declare class Fragment extends Node<"fragment"> {
+    static of(children: Iterable<Node>, externalId?: string, serializationId?: string, extraData?: any): Fragment;
+    static empty(): Fragment;
+    private constructor();
+    /**
+     * @internal
+     **/
+    protected _internalPath(): string;
+    toString(): string;
+    /**
+     * @internal
+     */
+    _attachParent(): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Fragment {
+    interface JSON extends Node.JSON<"fragment"> {
+    }
+    function isFragment(value: unknown): value is Fragment;
+    /**
+     * @internal
+     */
+    function fromFragment(json: JSON, device?: Device): Trampoline<Fragment>;
+    /**
+     * @internal
+     */
+    function cloneFragment(options: Node.ElementReplacementOptions, device?: Device): (fragment: Fragment) => Trampoline<Fragment>;
+}
+//# sourceMappingURL=fragment.d.ts.map

package/dist/node/fragment.js

@@ -0,0 +1,68 @@
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Node } from "../node.js";
+import { Element } from "./element.js";
+/**
+ * @public
+ */
+export class Fragment extends Node {
+    static of(children, externalId, serializationId, extraData) {
+        return new Fragment(Array.from(children), externalId, serializationId, extraData);
+    }
+    static empty() {
+        return new Fragment([]);
+    }
+    constructor(children, externalId, serializationId, extraData) {
+        super(children, "fragment", externalId, serializationId, extraData);
+    }
+    /**
+     * @internal
+     **/
+    _internalPath() {
+        return "/";
+    }
+    toString() {
+        const children = this._children
+            .map((child) => String.indent(child.toString()))
+            .join("\n");
+        return `#document-fragment${children === "" ? "" : `\n${children}`}`;
+    }
+    /**
+     * @internal
+     */
+    _attachParent() {
+        return false;
+    }
+}
+/**
+ * @public
+ */
+(function (Fragment) {
+    function isFragment(value) {
+        return value instanceof Fragment;
+    }
+    Fragment.isFragment = isFragment;
+    /**
+     * @internal
+     */
+    function fromFragment(json, device) {
+        return Trampoline.traverse(json.children ?? [], (child) => Node.fromNode(child, device)).map((children) => Fragment.of(children));
+    }
+    Fragment.fromFragment = fromFragment;
+    /**
+     * @internal
+     */
+    function cloneFragment(options, device) {
+        return (fragment) => Trampoline.traverse(fragment.children(), (child) => {
+            if (Element.isElement(child) && options.predicate(child)) {
+                return Trampoline.done(Array.from(options.newElements));
+            }
+            return Node.cloneNode(child, options, device).map((node) => [node]);
+        }).map((children) => {
+            return Fragment.of(Iterable.flatten(children), fragment.externalId);
+        });
+    }
+    Fragment.cloneFragment = cloneFragment;
+})(Fragment || (Fragment = {}));
+//# sourceMappingURL=fragment.js.map

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

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../node.js";
+/**
+ * @public
+ */
+export declare function hasChild(predicate: Predicate<Node>, options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=has-child.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../node.js";
+/**
+ * @public
+ */
+export declare function hasDescendant(predicate: Predicate<Node>, options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=has-descendant.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../node.js";
+/**
+ * @public
+ */
+export declare function hasInclusiveDescendant(predicate: Predicate<Node>, options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=has-inclusive-descendant.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../node.js";
+/**
+ * @public
+ */
+export declare function hasTextContent(predicate?: Predicate<string>, options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=has-text-content.d.ts.map

package/dist/node/predicate/has-text-content.js

@@ -0,0 +1,12 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../node.js";
+const { isEmpty } = Iterable;
+const { not } = Predicate;
+/**
+ * @public
+ */
+export function hasTextContent(predicate = not(isEmpty), options = Node.Traversal.empty) {
+    return (node) => predicate(node.textContent(options));
+}
+//# sourceMappingURL=has-text-content.js.map

package/dist/node/predicate/is-root.d.ts

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import type { Node } from "../../node.js";
+/**
+ * @public
+ */
+export declare function isRoot(options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=is-root.d.ts.map

package/dist/node/predicate/is-root.js

@@ -0,0 +1,7 @@
+/**
+ * @public
+ */
+export function isRoot(options) {
+    return (node) => node.parent(options).isNone();
+}
+//# sourceMappingURL=is-root.js.map

package/dist/node/predicate.d.ts

@@ -0,0 +1,6 @@
+export * from "./predicate/has-child.js";
+export * from "./predicate/has-descendant.js";
+export * from "./predicate/has-inclusive-descendant.js";
+export * from "./predicate/has-text-content.js";
+export * from "./predicate/is-root.js";
+//# sourceMappingURL=predicate.d.ts.map

package/dist/node/predicate.js

@@ -0,0 +1,6 @@
+export * from "./predicate/has-child.js";
+export * from "./predicate/has-descendant.js";
+export * from "./predicate/has-inclusive-descendant.js";
+export * from "./predicate/has-text-content.js";
+export * from "./predicate/is-root.js";
+//# sourceMappingURL=predicate.js.map

package/dist/node/query/element-descendants.d.ts

@@ -0,0 +1,8 @@
+import type { Sequence } from "@siteimprove/alfa-sequence";
+import { Node } from "../../node.js";
+import { Element } from "../element.js";
+/**
+ * @public
+ */
+export declare function getElementDescendants(node: Node, options?: Node.Traversal): Sequence<Element>;
+//# sourceMappingURL=element-descendants.d.ts.map