@siteimprove/alfa-dom 0.89.2

package/dist/node/element/predicate/has-id.js

@@ -0,0 +1,17 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Predicate } from "@siteimprove/alfa-predicate";
+const { equals } = Predicate;
+export function hasId(idOrPredicate = () => true, ...ids) {
+    let predicate;
+    if (typeof idOrPredicate === "function") {
+        predicate = idOrPredicate;
+    }
+    else if (typeof idOrPredicate === "string") {
+        predicate = equals(idOrPredicate, ...ids);
+    }
+    else {
+        predicate = (value) => Iterable.includes(ids, value);
+    }
+    return (element) => element.id.some(predicate);
+}
+//# sourceMappingURL=has-id.js.map

package/dist/node/element/predicate/has-input-type.d.ts

@@ -0,0 +1,12 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Element } from "../../element.js";
+import { type InputType } from "../input-type.js";
+/**
+ * @public
+ */
+export declare function hasInputType(predicate: Predicate<InputType>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasInputType(inputType: InputType, ...rest: Array<InputType>): Predicate<Element>;
+//# sourceMappingURL=has-input-type.d.ts.map

package/dist/node/element/predicate/has-input-type.js

@@ -0,0 +1,17 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { inputType } from "../input-type.js";
+import { hasName } from "./has-name.js";
+const { equals, test } = Predicate;
+const { and } = Refinement;
+export function hasInputType(inputTypeOrPredicate, ...inputTypes) {
+    let predicate;
+    if (typeof inputTypeOrPredicate === "function") {
+        predicate = inputTypeOrPredicate;
+    }
+    else {
+        predicate = equals(inputTypeOrPredicate, ...inputTypes);
+    }
+    return and(hasName("input"), (element) => test(predicate, inputType(element)));
+}
+//# sourceMappingURL=has-input-type.js.map

package/dist/node/element/predicate/has-name.d.ts

@@ -0,0 +1,11 @@
+import type { Refinement } from "@siteimprove/alfa-refinement";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasName<N extends string = string>(predicate: Refinement<string, N>): Refinement<Element, Element<N>>;
+/**
+ * @public
+ */
+export declare function hasName<N extends string = string>(name: N, ...rest: Array<N>): Refinement<Element, Element<N>>;
+//# sourceMappingURL=has-name.d.ts.map

package/dist/node/element/predicate/has-name.js

@@ -0,0 +1,13 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+const { equals } = Predicate;
+export function hasName(nameOrPredicate, ...names) {
+    let predicate;
+    if (typeof nameOrPredicate === "function") {
+        predicate = nameOrPredicate;
+    }
+    else {
+        predicate = equals(nameOrPredicate, ...names);
+    }
+    return (element) => predicate(element.name);
+}
+//# sourceMappingURL=has-name.js.map

package/dist/node/element/predicate/has-namespace.d.ts

@@ -0,0 +1,12 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Namespace } from "../../../namespace.js";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasNamespace(predicate: Predicate<Namespace>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasNamespace(namespace: Namespace, ...rest: Array<Namespace>): Predicate<Element>;
+//# sourceMappingURL=has-namespace.d.ts.map

package/dist/node/element/predicate/has-namespace.js

@@ -0,0 +1,13 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+const { equals } = Predicate;
+export function hasNamespace(namespaceOrPredicate, ...namespaces) {
+    let predicate;
+    if (typeof namespaceOrPredicate === "function") {
+        predicate = namespaceOrPredicate;
+    }
+    else {
+        predicate = equals(namespaceOrPredicate, ...namespaces);
+    }
+    return (element) => element.namespace.some(predicate);
+}
+//# sourceMappingURL=has-namespace.js.map

package/dist/node/element/predicate/has-tab-index.d.ts

@@ -0,0 +1,12 @@
+import { Array } from "@siteimprove/alfa-array";
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasTabIndex(predicate?: Predicate<number>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasTabIndex(value: number, ...rest: Array<number>): Predicate<Element>;
+//# sourceMappingURL=has-tab-index.d.ts.map

package/dist/node/element/predicate/has-tab-index.js

@@ -0,0 +1,11 @@
+import { Array } from "@siteimprove/alfa-array";
+/**
+ * @public
+ */
+export function hasTabIndex(predicateOrNumber = () => true, ...rest) {
+    const predicate = typeof predicateOrNumber === "number"
+        ? (n) => Array.append(rest, predicateOrNumber).includes(n)
+        : predicateOrNumber;
+    return (element) => element.tabIndex().some(predicate);
+}
+//# sourceMappingURL=has-tab-index.js.map

package/dist/node/element/predicate/has-unique-id.d.ts

@@ -0,0 +1,7 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare const hasUniqueId: Predicate<Element>;
+//# sourceMappingURL=has-unique-id.d.ts.map

package/dist/node/element/predicate/has-unique-id.js

@@ -0,0 +1,31 @@
+import { Cache } from "@siteimprove/alfa-cache";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Element } from "../../element.js";
+import { hasId } from "./has-id.js";
+const { and } = Predicate;
+const uniques = Cache.empty();
+/**
+ * @public
+ */
+export const hasUniqueId = and(hasId(), (element) => uniques
+    .get(element.root(), () => {
+    const counts = new Map();
+    for (const node of element.root().descendants()) {
+        if (Element.isElement(node) && node.id.isSome()) {
+            const id = node.id.get();
+            const count = counts.get(id);
+            if (count === undefined) {
+                counts.set(id, 1);
+            }
+            else {
+                counts.set(id, 1 + count);
+            }
+        }
+    }
+    return new Set(Iterable.map(Iterable.filter(counts, ([, count]) => count === 1), ([id]) => id));
+})
+    // The initial hasId in the conjunction guarantee that there is one.
+    // Still defaulting to an impossible one.
+    .has(element.id.getOr("impossible id due to spaces")));
+//# sourceMappingURL=has-unique-id.js.map

package/dist/node/element/predicate/is-actually-disabled.d.ts

@@ -0,0 +1,8 @@
+import { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/multipage#concept-element-disabled}
+ *
+ * @public
+ */
+export declare function isActuallyDisabled(element: Element): boolean;
+//# sourceMappingURL=is-actually-disabled.d.ts.map

package/dist/node/element/predicate/is-actually-disabled.js

@@ -0,0 +1,47 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Element } from "../../element.js";
+const { equals } = Predicate;
+/**
+ * {@link https://html.spec.whatwg.org/multipage#concept-element-disabled}
+ *
+ * @public
+ */
+export function isActuallyDisabled(element) {
+    switch (element.name) {
+        // https://html.spec.whatwg.org/multipage#concept-fe-disabled
+        case "button":
+        case "input":
+        case "select":
+        case "textarea":
+        // https://html.spec.whatwg.org/#attr-optgroup-disabled
+        case "optgroup":
+            return element.attribute("disabled").isSome();
+        // https://html.spec.whatwg.org/multipage#concept-fieldset-disabled
+        case "fieldset":
+            if (element.attribute("disabled").isSome()) {
+                return true;
+            }
+            return element
+                .ancestors()
+                .filter(Element.isElement)
+                .find(Element.hasName("fieldset"))
+                .reject(isActuallyDisabled)
+                .flatMap((fieldset) => fieldset
+                .descendants()
+                .filter(Element.isElement)
+                .find(Element.hasName("legend")))
+                .some((legend) => legend.descendants().some(equals(element)));
+        // https://html.spec.whatwg.org/multipage#concept-option-disabled
+        case "option":
+            if (element.attribute("disabled").isSome()) {
+                return true;
+            }
+            return element
+                .inclusiveAncestors()
+                .filter(Element.isElement)
+                .find(Element.hasName("optgroup"))
+                .some(isActuallyDisabled);
+    }
+    return false;
+}
+//# sourceMappingURL=is-actually-disabled.js.map

package/dist/node/element/predicate/is-browsing-context-container.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/#browsing-context-container}
+ *
+ * @public
+ */
+export declare function isBrowsingContextContainer(element: Element): boolean;
+//# sourceMappingURL=is-browsing-context-container.d.ts.map

package/dist/node/element/predicate/is-browsing-context-container.js

@@ -0,0 +1,20 @@
+/**
+ * {@link https://html.spec.whatwg.org/#browsing-context-container}
+ *
+ * @public
+ */
+export function isBrowsingContextContainer(element) {
+    switch (element.name) {
+        // <iframe> elements are _always_ browsing context containers as they will
+        // _always_ have a content document, although it might be empty.
+        case "iframe":
+            return true;
+        // <object> elements are only browsing context containers if they have a
+        // content document.
+        case "object":
+            return element.content.isSome();
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=is-browsing-context-container.js.map

package/dist/node/element/predicate/is-content.d.ts

@@ -0,0 +1,10 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Node } from "../../../node.js";
+/**
+ * A node is actual content (not just a container) if it has no children,
+ * or if it is a replaced element (assumed to be replaced by actual content).
+ *
+ * @public
+ */
+export declare function isContent(options?: Node.Traversal): Predicate<Node>;
+//# sourceMappingURL=is-content.d.ts.map

package/dist/node/element/predicate/is-content.js

@@ -0,0 +1,17 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { Element } from "../../element.js";
+import { Node } from "../../../node.js";
+import { isReplaced } from "./is-replaced.js";
+const { or } = Predicate;
+const { and } = Refinement;
+/**
+ * A node is actual content (not just a container) if it has no children,
+ * or if it is a replaced element (assumed to be replaced by actual content).
+ *
+ * @public
+ */
+export function isContent(options = Node.Traversal.empty) {
+    return or((node) => node.children(options).isEmpty(), and(Element.isElement, isReplaced));
+}
+//# sourceMappingURL=is-content.js.map

package/dist/node/element/predicate/is-document-element.d.ts

@@ -0,0 +1,6 @@
+import { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function isDocumentElement(value: unknown): value is Element<"html">;
+//# sourceMappingURL=is-document-element.d.ts.map

package/dist/node/element/predicate/is-document-element.js

@@ -0,0 +1,13 @@
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { Element } from "../../element.js";
+import { Namespace } from "../../../namespace.js";
+import { hasName } from "./has-name.js";
+import { hasNamespace } from "./has-namespace.js";
+const { and, test } = Refinement;
+/**
+ * @public
+ */
+export function isDocumentElement(value) {
+    return test(and(Element.isElement, and(hasName("html"), hasNamespace(Namespace.HTML))), value);
+}
+//# sourceMappingURL=is-document-element.js.map

package/dist/node/element/predicate/is-draggable.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/#dom-draggable}
+ *
+ * @public
+ */
+export declare function isDraggable(element: Element): boolean;
+//# sourceMappingURL=is-draggable.d.ts.map

package/dist/node/element/predicate/is-draggable.js

@@ -0,0 +1,28 @@
+/**
+ * {@link https://html.spec.whatwg.org/#dom-draggable}
+ *
+ * @public
+ */
+export function isDraggable(element) {
+    return element
+        .attribute("draggable")
+        .map((attribute) => attribute.enumerate("true", "false", "auto").getOr("auto"))
+        .some((draggable) => {
+        switch (draggable) {
+            case "true":
+                return true;
+            case "false":
+                return false;
+            case "auto":
+                switch (element.name) {
+                    case "img":
+                        return true;
+                    case "a":
+                        return element.attribute("href").isSome();
+                    default:
+                        return false;
+                }
+        }
+    });
+}
+//# sourceMappingURL=is-draggable.js.map

package/dist/node/element/predicate/is-editing-host.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/#editing-host}
+ *
+ * @public
+ */
+export declare function isEditingHost(element: Element): boolean;
+//# sourceMappingURL=is-editing-host.d.ts.map

package/dist/node/element/predicate/is-editing-host.js

@@ -0,0 +1,20 @@
+/**
+ * {@link https://html.spec.whatwg.org/#editing-host}
+ *
+ * @public
+ */
+export function isEditingHost(element) {
+    return element
+        .attribute("contenteditable")
+        .flatMap((attribute) => attribute.enumerate("", "true", "false"))
+        .some((contenteditable) => {
+        switch (contenteditable) {
+            case "":
+            case "true":
+                return true;
+            case "false":
+                return false;
+        }
+    });
+}
+//# sourceMappingURL=is-editing-host.js.map

package/dist/node/element/predicate/is-fallback.d.ts

@@ -0,0 +1,15 @@
+import type { Node } from "../../../node.js";
+/**
+ * Children of <iframe>, <audio>, <video> elements act as fallback content in
+ * legacy user agents.
+ *
+ * <track> and <source> children of audio and video are allowed by the content
+ * model of both. Thus, they will be not act as fallback
+ *
+ * {@link https://html.spec.whatwg.org/multipage/#the-video-element}
+ * {@link https://html.spec.whatwg.org/multipage/#the-audio-element}
+ *
+ * @public
+ */
+export declare function isFallback(node: Node): boolean;
+//# sourceMappingURL=is-fallback.d.ts.map

package/dist/node/element/predicate/is-fallback.js

@@ -0,0 +1,28 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { Element } from "../../element.js";
+import { hasName } from "./has-name.js";
+const { not, or, test } = Predicate;
+const { and } = Refinement;
+/**
+ * Children of <iframe>, <audio>, <video> elements act as fallback content in
+ * legacy user agents.
+ *
+ * <track> and <source> children of audio and video are allowed by the content
+ * model of both. Thus, they will be not act as fallback
+ *
+ * {@link https://html.spec.whatwg.org/multipage/#the-video-element}
+ * {@link https://html.spec.whatwg.org/multipage/#the-audio-element}
+ *
+ * @public
+ */
+export function isFallback(node) {
+    return test(or(hasParentName("iframe"), and(hasParentName("audio", "video"), not(and(Element.isElement, hasName("track", "source"))))), node);
+}
+function hasParentName(name, ...names) {
+    return (node) => node
+        .parent()
+        .filter(Element.isElement)
+        .some(hasName(name, ...names));
+}
+//# sourceMappingURL=is-fallback.js.map

package/dist/node/element/predicate/is-replaced.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/#replaced-elements}
+ *
+ * @public
+ */
+export declare function isReplaced(element: Element): element is Element<"audio" | "canvas" | "embed" | "iframe" | "img" | "input" | "object" | "video">;
+//# sourceMappingURL=is-replaced.d.ts.map

package/dist/node/element/predicate/is-replaced.js

@@ -0,0 +1,17 @@
+import { Refinement } from "@siteimprove/alfa-refinement";
+import { hasName } from "./has-name.js";
+const { test } = Refinement;
+// For some reason, type inference by "yarn document" seems to depend on
+// machine (?) and returns the list of elements' names in different orders.
+// This notably breaks the CI if "yarn document" there builds a different type
+// than on local machine. Using a function with explicit type seems to stabilize
+// things.
+/**
+ * {@link https://html.spec.whatwg.org/#replaced-elements}
+ *
+ * @public
+ */
+export function isReplaced(element) {
+    return test(hasName("audio", "canvas", "embed", "iframe", "img", "input", "object", "video"), element);
+}
+//# sourceMappingURL=is-replaced.js.map

package/dist/node/element/predicate/is-scoped-to.d.ts

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function isScopedTo(name: string, ...rest: Array<string>): Predicate<Element>;
+//# sourceMappingURL=is-scoped-to.d.ts.map

package/dist/node/element/predicate/is-scoped-to.js

@@ -0,0 +1,11 @@
+import { Element } from "../../element.js";
+/**
+ * @public
+ */
+export function isScopedTo(name, ...rest) {
+    return (element) => element
+        .ancestors()
+        .filter(Element.isElement)
+        .some(Element.hasName(name, ...rest));
+}
+//# sourceMappingURL=is-scoped-to.js.map

package/dist/node/element/predicate/is-suggested-focusable.d.ts

@@ -0,0 +1,14 @@
+import { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/multipage/#tabindex-value}
+ *
+ * @remarks
+ * Draggable elements for which the user agent supports drag operations without
+ * a pointer device are also suggested focusable. However, we're not aware of
+ * any such cases and therefore don't suggest making draggable elements
+ * focusable.
+ *
+ * @public
+ */
+export declare function isSuggestedFocusable(element: Element): boolean;
+//# sourceMappingURL=is-suggested-focusable.d.ts.map

package/dist/node/element/predicate/is-suggested-focusable.js

@@ -0,0 +1,47 @@
+import { Element } from "../../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/multipage/#tabindex-value}
+ *
+ * @remarks
+ * Draggable elements for which the user agent supports drag operations without
+ * a pointer device are also suggested focusable. However, we're not aware of
+ * any such cases and therefore don't suggest making draggable elements
+ * focusable.
+ *
+ * @public
+ */
+export function isSuggestedFocusable(element) {
+    switch (element.name) {
+        case "a":
+        case "link":
+            return element.attribute("href").isSome();
+        case "input":
+            return element
+                .attribute("type")
+                .flatMap((attribute) => attribute.enumerate("hidden"))
+                .isNone();
+        case "audio":
+        case "video":
+            return element.attribute("controls").isSome();
+        case "button":
+        case "select":
+        case "textarea":
+            return true;
+        case "summary":
+            return element
+                .parent()
+                .filter(Element.isElement)
+                .some((parent) => parent.name === "details" &&
+                // Checking that element is the first <summary> child of parent.
+                parent
+                    .children()
+                    .filter(Element.isElement)
+                    // Switching on element.name does not narrow the type, so we must
+                    // keep it as Element<string>.
+                    .find(Element.hasName("summary"))
+                    .includes(element));
+    }
+    return (Element.isEditingHost(element) ||
+        Element.isBrowsingContextContainer(element));
+}
+//# sourceMappingURL=is-suggested-focusable.js.map

package/dist/node/element/predicate.d.ts

@@ -0,0 +1,20 @@
+export * from "./predicate/has-attribute.js";
+export * from "./predicate/has-box.js";
+export * from "./predicate/has-display-size.js";
+export * from "./predicate/has-id.js";
+export * from "./predicate/has-input-type.js";
+export * from "./predicate/has-name.js";
+export * from "./predicate/has-namespace.js";
+export * from "./predicate/has-tab-index.js";
+export * from "./predicate/has-unique-id.js";
+export * from "./predicate/is-browsing-context-container.js";
+export * from "./predicate/is-content.js";
+export * from "./predicate/is-actually-disabled.js";
+export * from "./predicate/is-document-element.js";
+export * from "./predicate/is-draggable.js";
+export * from "./predicate/is-editing-host.js";
+export * from "./predicate/is-fallback.js";
+export * from "./predicate/is-scoped-to.js";
+export * from "./predicate/is-suggested-focusable.js";
+export * from "./predicate/is-replaced.js";
+//# sourceMappingURL=predicate.d.ts.map

package/dist/node/element/predicate.js

@@ -0,0 +1,20 @@
+export * from "./predicate/has-attribute.js";
+export * from "./predicate/has-box.js";
+export * from "./predicate/has-display-size.js";
+export * from "./predicate/has-id.js";
+export * from "./predicate/has-input-type.js";
+export * from "./predicate/has-name.js";
+export * from "./predicate/has-namespace.js";
+export * from "./predicate/has-tab-index.js";
+export * from "./predicate/has-unique-id.js";
+export * from "./predicate/is-browsing-context-container.js";
+export * from "./predicate/is-content.js";
+export * from "./predicate/is-actually-disabled.js";
+export * from "./predicate/is-document-element.js";
+export * from "./predicate/is-draggable.js";
+export * from "./predicate/is-editing-host.js";
+export * from "./predicate/is-fallback.js";
+export * from "./predicate/is-scoped-to.js";
+export * from "./predicate/is-suggested-focusable.js";
+export * from "./predicate/is-replaced.js";
+//# sourceMappingURL=predicate.js.map