@siteimprove/alfa-dom 0.89.2

package/dist/node/query/element-descendants.js

@@ -0,0 +1,17 @@
+import { Cache } from "@siteimprove/alfa-cache";
+import { Node } from "../../node.js";
+import { Element } from "../element.js";
+const _elementDescendantsCache = Cache.empty();
+/**
+ * @public
+ */
+export function getElementDescendants(node, options = Node.Traversal.empty) {
+    const optionsMap = _elementDescendantsCache.get(node, () => []);
+    if (optionsMap[options.value] === undefined) {
+        optionsMap[options.value] = node
+            .descendants(options)
+            .filter(Element.isElement);
+    }
+    return optionsMap[options.value];
+}
+//# sourceMappingURL=element-descendants.js.map

package/dist/node/query/element-id-map.d.ts

@@ -0,0 +1,14 @@
+import { Map } from "@siteimprove/alfa-map";
+import type { Node } from "../../node.js";
+import type { Element } from "../element.js";
+/**
+ * Returns a map from id to elements, in the subtree rooted at a given node.
+ *
+ * @privateRemarks
+ * Since `id` are scoped to trees, and do not cross shadow or content boundaries,
+ * we never need traversal options.
+ *
+ * @public
+ */
+export declare function getElementIdMap(node: Node): Map<string, Element>;
+//# sourceMappingURL=element-id-map.d.ts.map

package/dist/node/query/element-id-map.js

@@ -0,0 +1,30 @@
+import { Cache } from "@siteimprove/alfa-cache";
+import { Map } from "@siteimprove/alfa-map";
+import { Document } from "../document.js";
+import { getElementDescendants } from "./element-descendants.js";
+const elementMapCache = Cache.empty();
+/**
+ * Returns a map from id to elements, in the subtree rooted at a given node.
+ *
+ * @privateRemarks
+ * Since `id` are scoped to trees, and do not cross shadow or content boundaries,
+ * we never need traversal options.
+ *
+ * @public
+ */
+export function getElementIdMap(node) {
+    if (Document.isDocument(node)) {
+        return elementMapCache.get(node, () => buildElementIdMap(node));
+    }
+    return buildElementIdMap(node);
+}
+function buildElementIdMap(node) {
+    // Build a map from ID -> element to allow fast resolution of ID references.
+    // The collected references are added to the map in reverse order to ensure
+    // that the first occurrence of a given ID is what ends up in the map in
+    // event of duplicates.
+    return Map.from(getElementDescendants(node)
+        .collect((element) => element.id.map((id) => [id, element]))
+        .reverse());
+}
+//# sourceMappingURL=element-id-map.js.map

package/dist/node/query/inclusive-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 getInclusiveElementDescendants(node: Element, options?: Node.Traversal): Sequence<Element>;
+//# sourceMappingURL=inclusive-element-descendants.d.ts.map

package/dist/node/query/inclusive-element-descendants.js

@@ -0,0 +1,10 @@
+import { Node } from "../../node.js";
+import { Element } from "../element.js";
+import { getElementDescendants } from "./element-descendants.js";
+/**
+ * @public
+ */
+export function getInclusiveElementDescendants(node, options = Node.Traversal.empty) {
+    return getElementDescendants(node, options).prepend(node);
+}
+//# sourceMappingURL=inclusive-element-descendants.js.map

package/dist/node/query/index.d.ts

@@ -0,0 +1,12 @@
+import * as elementDescendants from "./element-descendants.js";
+import * as elementIdMap from "./element-id-map.js";
+import * as inclusiveElementDescendants from "./inclusive-element-descendants.js";
+/**
+ * @public
+ */
+export declare namespace Query {
+    const getElementDescendants: typeof elementDescendants.getElementDescendants;
+    const getElementIdMap: typeof elementIdMap.getElementIdMap;
+    const getInclusiveElementDescendants: typeof inclusiveElementDescendants.getInclusiveElementDescendants;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/node/query/index.js

@@ -0,0 +1,13 @@
+import * as elementDescendants from "./element-descendants.js";
+import * as elementIdMap from "./element-id-map.js";
+import * as inclusiveElementDescendants from "./inclusive-element-descendants.js";
+/**
+ * @public
+ */
+export var Query;
+(function (Query) {
+    Query.getElementDescendants = elementDescendants.getElementDescendants;
+    Query.getElementIdMap = elementIdMap.getElementIdMap;
+    Query.getInclusiveElementDescendants = inclusiveElementDescendants.getInclusiveElementDescendants;
+})(Query || (Query = {}));
+//# sourceMappingURL=index.js.map

package/dist/node/shadow.d.ts

@@ -0,0 +1,66 @@
+import { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import type { Device } from "@siteimprove/alfa-device";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Sheet } from "../style/sheet.js";
+import { Element } from "./element.js";
+/**
+ * @public
+ */
+export declare class Shadow extends Node<"shadow"> {
+    static of(children: Iterable<Node>, style?: Iterable<Sheet>, mode?: Shadow.Mode, externalId?: string, serializationId?: string, extraData?: any): Shadow;
+    static empty(): Shadow;
+    private readonly _mode;
+    private _host;
+    private readonly _style;
+    private constructor();
+    get mode(): Shadow.Mode;
+    get host(): Option<Element>;
+    get style(): Iterable<Sheet>;
+    parent(options?: Node.Traversal): Option<Node>;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Shadow.MinimalJSON;
+    toJSON(options?: Node.SerializationOptions): Shadow.JSON;
+    toString(): string;
+    /**
+     * @internal
+     */
+    _attachParent(): boolean;
+    /**
+     * @internal
+     */
+    _attachHost(host: Element): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Shadow {
+    enum Mode {
+        Open = "open",
+        Closed = "closed"
+    }
+    interface MinimalJSON extends Node.JSON {
+    }
+    interface JSON extends Node.JSON {
+        type: "shadow";
+        mode: string;
+        style: Array<Sheet.JSON>;
+    }
+    function isShadow(value: unknown): value is Shadow;
+    /**
+     * @internal
+     */
+    function fromShadow(json: JSON, device?: Device): Trampoline<Shadow>;
+    /**
+     * @internal
+     */
+    function cloneShadow(options: Node.ElementReplacementOptions, device?: Device): (shadow: Shadow) => Trampoline<Shadow>;
+}
+//# sourceMappingURL=shadow.d.ts.map

package/dist/node/shadow.js

@@ -0,0 +1,128 @@
+import { None, Option } from "@siteimprove/alfa-option";
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Sheet } from "../style/sheet.js";
+import { Element } from "./element.js";
+/**
+ * @public
+ */
+export class Shadow extends Node {
+    static of(children, style = [], mode = Shadow.Mode.Open, externalId, serializationId, extraData) {
+        return new Shadow(Array.from(children), Array.from(style), mode, externalId, serializationId, extraData);
+    }
+    static empty() {
+        return new Shadow([], [], Shadow.Mode.Open);
+    }
+    _mode;
+    _host = None;
+    _style;
+    constructor(children, style, mode, externalId, serializationId, extraData) {
+        super(children, "shadow", externalId, serializationId, extraData);
+        this._mode = mode;
+        this._style = style;
+    }
+    get mode() {
+        return this._mode;
+    }
+    get host() {
+        return this._host;
+    }
+    get style() {
+        return this._style;
+    }
+    parent(options = Node.Traversal.empty) {
+        // We only "land" on Shadow roots when traversing the composed tree.
+        // Notably, flattening the tree "jumps" over them.
+        if (options.isSet(Node.Traversal.composed)) {
+            return this._host;
+        }
+        return None;
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options = Node.Traversal.empty) {
+        if (options.isSet(Node.Traversal.composed)) {
+            return (this._host.map((host) => host.path(options)).getOr("") +
+                "/shadow-root()");
+        }
+        if (options.isSet(Node.Traversal.flattened)) {
+            return this._host.map((host) => host.path(options)).getOr("/");
+        }
+        return "/";
+    }
+    toJSON(options) {
+        const result = {
+            ...super.toJSON(options),
+        };
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        result.mode = this._mode;
+        result.style = this._style.map((sheet) => sheet.toJSON());
+        return result;
+    }
+    toString() {
+        const children = this._children
+            .map((child) => String.indent(child.toString()))
+            .join("\n");
+        return `#shadow-root (${this._mode})${children === "" ? "" : `\n${children}`}`;
+    }
+    /**
+     * @internal
+     */
+    _attachParent() {
+        return false;
+    }
+    /**
+     * @internal
+     */
+    _attachHost(host) {
+        if (this._frozen || this._host.isSome()) {
+            return false;
+        }
+        this._host = Option.of(host);
+        this._frozen = true;
+        return true;
+    }
+}
+/**
+ * @public
+ */
+(function (Shadow) {
+    let Mode;
+    (function (Mode) {
+        Mode["Open"] = "open";
+        Mode["Closed"] = "closed";
+    })(Mode = Shadow.Mode || (Shadow.Mode = {}));
+    function isShadow(value) {
+        return value instanceof Shadow;
+    }
+    Shadow.isShadow = isShadow;
+    /**
+     * @internal
+     */
+    function fromShadow(json, device) {
+        return Trampoline.traverse(json.children ?? [], (child) => Node.fromNode(child, device)).map((children) => Shadow.of(children, json.style.map(Sheet.from), json.mode, json.externalId, json.serializationId));
+    }
+    Shadow.fromShadow = fromShadow;
+    /**
+     * @internal
+     */
+    function cloneShadow(options, device) {
+        return (shadow) => Trampoline.traverse(shadow.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 Shadow.of(Iterable.flatten(children), shadow.style, shadow.mode, shadow.externalId, shadow.extraData, shadow.serializationId);
+        });
+    }
+    Shadow.cloneShadow = cloneShadow;
+})(Shadow || (Shadow = {}));
+//# sourceMappingURL=shadow.js.map

package/dist/node/slot.d.ts

@@ -0,0 +1,29 @@
+import { Element } from "./element.js";
+import { Slotable } from "./slotable.js";
+/**
+ * @public
+ */
+export interface Slot extends Element {
+    /**
+     * Get the slotables assigned to this slot.
+     *
+     * {@link https://html.spec.whatwg.org/#dom-slot-assignednodes}
+     */
+    assignedNodes(): Iterable<Slotable>;
+}
+/**
+ * @public
+ */
+export declare namespace Slot {
+    function isSlot(element: Element): boolean;
+    function isSlot(value: unknown): value is Slot;
+    /**
+     * {@link https://dom.spec.whatwg.org/#slot-name}
+     */
+    function name(slot: Slot): string;
+    /**
+     * {@link https://dom.spec.whatwg.org/#find-slotables}
+     */
+    function findSlotables(slot: Slot): Iterable<Slotable>;
+}
+//# sourceMappingURL=slot.d.ts.map

package/dist/node/slot.js

@@ -0,0 +1,41 @@
+import { Element } from "./element.js";
+import { Shadow } from "./shadow.js";
+import { Slotable } from "./slotable.js";
+/**
+ * @public
+ */
+export var Slot;
+(function (Slot) {
+    function isSlot(value) {
+        return Element.isElement(value) && value.name === "slot";
+    }
+    Slot.isSlot = isSlot;
+    /**
+     * {@link https://dom.spec.whatwg.org/#slot-name}
+     */
+    function name(slot) {
+        return slot
+            .attribute("name")
+            .map((name) => name.value)
+            .getOr("");
+    }
+    Slot.name = name;
+    /**
+     * {@link https://dom.spec.whatwg.org/#find-slotables}
+     */
+    function* findSlotables(slot) {
+        const root = slot.root();
+        if (Shadow.isShadow(root)) {
+            for (const host of root.host) {
+                for (const child of host.children()) {
+                    if (Slotable.isSlotable(child) &&
+                        child.assignedSlot().includes(slot)) {
+                        yield child;
+                    }
+                }
+            }
+        }
+    }
+    Slot.findSlotables = findSlotables;
+})(Slot || (Slot = {}));
+//# sourceMappingURL=slot.js.map

package/dist/node/slotable.d.ts

@@ -0,0 +1,29 @@
+import type { Option } from "@siteimprove/alfa-option";
+import type { Node } from "../node.js";
+import { Slot } from "./slot.js";
+/**
+ * @public
+ */
+export interface Slotable extends Node {
+    /**
+     * Get the slot that this slotable is assigned to.
+     *
+     * {@link https://dom.spec.whatwg.org/#dom-slotable-assignedslot}
+     */
+    assignedSlot(): Option<Slot>;
+}
+/**
+ * @public
+ */
+export declare namespace Slotable {
+    function isSlotable(value: unknown): value is Slotable;
+    /**
+     * {@link https://dom.spec.whatwg.org/#slotable-name}
+     */
+    function name(slotable: Slotable): string;
+    /**
+     * {@link https://dom.spec.whatwg.org/#find-a-slot}
+     */
+    function findSlot(slotable: Slotable): Option<Slot>;
+}
+//# sourceMappingURL=slotable.d.ts.map

package/dist/node/slotable.js

@@ -0,0 +1,40 @@
+import { Element } from "./element.js";
+import { Slot } from "./slot.js";
+import { Text } from "./text.js";
+/**
+ * @public
+ */
+export var Slotable;
+(function (Slotable) {
+    function isSlotable(value) {
+        return Element.isElement(value) || Text.isText(value);
+    }
+    Slotable.isSlotable = isSlotable;
+    /**
+     * {@link https://dom.spec.whatwg.org/#slotable-name}
+     */
+    function name(slotable) {
+        return Element.isElement(slotable)
+            ? slotable
+                .attribute("slot")
+                .map((slot) => slot.value)
+                .getOr("")
+            : "";
+    }
+    Slotable.name = name;
+    /**
+     * {@link https://dom.spec.whatwg.org/#find-a-slot}
+     */
+    function findSlot(slotable) {
+        const name = Slotable.name(slotable);
+        return slotable
+            .parent()
+            .filter(Element.isElement)
+            .flatMap((parent) => parent.shadow.flatMap((shadow) => shadow
+            .descendants()
+            .filter(Slot.isSlot)
+            .find((slot) => Slot.name(slot) === name)));
+    }
+    Slotable.findSlot = findSlot;
+})(Slotable || (Slotable = {}));
+//# sourceMappingURL=slotable.js.map

package/dist/node/text.d.ts

@@ -0,0 +1,46 @@
+import type { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import type { Slot } from "./slot.js";
+import { Slotable } from "./slotable.js";
+/**
+ * @public
+ */
+export declare class Text extends Node<"text"> implements Slotable {
+    static of(data: string, externalId?: string, serializationId?: string, extraData?: any): Text;
+    static empty(): Text;
+    private readonly _data;
+    private constructor();
+    get data(): string;
+    assignedSlot(): Option<Slot>;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Text.MinimalJSON;
+    toJSON(options?: Node.SerializationOptions): Text.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Text {
+    interface MinimalJSON extends Node.JSON<"text"> {
+    }
+    interface JSON extends Node.JSON<"text"> {
+        data: string;
+    }
+    function isText(value: unknown): value is Text;
+    /**
+     * @internal
+     */
+    function fromText(json: JSON): Trampoline<Text>;
+    /**
+     * @internal
+     */
+    function cloneText(text: Text): Trampoline<Text>;
+}
+//# sourceMappingURL=text.d.ts.map

package/dist/node/text.js

@@ -0,0 +1,83 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Slotable } from "./slotable.js";
+/**
+ * @public
+ */
+export class Text extends Node {
+    static of(data, externalId, serializationId, extraData) {
+        return new Text(data, externalId, serializationId, extraData);
+    }
+    static empty() {
+        return new Text("");
+    }
+    _data;
+    constructor(data, externalId, serializationId, extraData) {
+        super([], "text", externalId, serializationId, extraData);
+        this._data = data;
+    }
+    get data() {
+        return this._data;
+    }
+    assignedSlot() {
+        return Slotable.findSlot(this);
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options) {
+        let path = this.parent(options)
+            .map((parent) => parent.path(options))
+            .getOr("/");
+        path += path === "/" ? "" : "/";
+        path += "text()";
+        const index = this.preceding(options).count(Text.isText);
+        path += `[${index + 1}]`;
+        return path;
+    }
+    toJSON(options) {
+        const result = {
+            ...super.toJSON(options),
+        };
+        delete result.children;
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        result.data = this.data;
+        return result;
+    }
+    toString() {
+        const value = this.data;
+        // 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();
+    }
+}
+/**
+ * @public
+ */
+(function (Text) {
+    function isText(value) {
+        return value instanceof Text;
+    }
+    Text.isText = isText;
+    /**
+     * @internal
+     */
+    function fromText(json) {
+        return Trampoline.done(Text.of(json.data, json.externalId, undefined, json.serializationId));
+    }
+    Text.fromText = fromText;
+    /**
+     * @internal
+     */
+    function cloneText(text) {
+        return Trampoline.done(Text.of(text.data, text.externalId, text.extraData, text.serializationId));
+    }
+    Text.cloneText = cloneText;
+})(Text || (Text = {}));
+//# sourceMappingURL=text.js.map

package/dist/node/traversal/get-nodes-between.d.ts

@@ -0,0 +1,24 @@
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Node } from "../../index.js";
+/**
+ * Get content between two nodes. The relative order of the nodes is unknown.
+ * Options let it choose whether the first or second node (in tree order)
+ * should be included. By default, exclude both.
+ *
+ * When the first node is not included, all its subtree is skipped, that is we
+ * start looking after the closing tag, not after the opening one.
+ *
+ * Returns empty sequence in the corner case where both nodes are the same and
+ * at least one is excluded (i.e. considers that [X,X[ and ]X,X] are empty).
+ *
+ * Complexity: the size of the subtree anchored at the lowest common ancestor.
+ *
+ * @public
+ */
+export declare function getNodesBetween(node1: Node, node2: Node, includeOptions?: Options, treeOptions?: Node.Traversal): Sequence<Node>;
+type Options = {
+    includeFirst: boolean;
+    includeSecond: boolean;
+};
+export {};
+//# sourceMappingURL=get-nodes-between.d.ts.map

package/dist/node/traversal/get-nodes-between.js

@@ -0,0 +1,62 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Node } from "../../index.js";
+import { lowestCommonAncestor } from "./lowest-common-ancestor.js";
+const { equals, or } = Predicate;
+/**
+ * Get content between two nodes. The relative order of the nodes is unknown.
+ * Options let it choose whether the first or second node (in tree order)
+ * should be included. By default, exclude both.
+ *
+ * When the first node is not included, all its subtree is skipped, that is we
+ * start looking after the closing tag, not after the opening one.
+ *
+ * Returns empty sequence in the corner case where both nodes are the same and
+ * at least one is excluded (i.e. considers that [X,X[ and ]X,X] are empty).
+ *
+ * Complexity: the size of the subtree anchored at the lowest common ancestor.
+ *
+ * @public
+ */
+export function getNodesBetween(node1, node2, includeOptions = { includeFirst: false, includeSecond: false }, treeOptions = Node.fullTree) {
+    let between = getNodesInclusivelyBetween(node1, node2, treeOptions);
+    // If somehow there is nothing between them, escape now
+    if (between.isEmpty()) {
+        return between;
+    }
+    // Do we keep the first node or skip its subtree?
+    if (!includeOptions.includeFirst) {
+        // By previous test, between is not empty
+        const first = between.first().getUnsafe();
+        // The 'first node after the subtree rooted at first' is the next sibling
+        // of the closest ancestor having one.
+        between = first
+            // Closest ancestor with a next sibling.
+            .closest((ancestor) => ancestor.next(treeOptions).isSome(), treeOptions)
+            // Get that sibling.
+            .flatMap((node) => node.next(treeOptions))
+            // Skip everything until next.
+            .map((next) => between.skipUntil((node) => node.equals(next)))
+            // If nothing after the subtree at first, just escape.
+            .getOrElse(Sequence.empty);
+    }
+    // Do we keep the second node or remove it?
+    between =
+        includeOptions.includeSecond || between.isEmpty()
+            ? between
+            : between.skipLast(1);
+    return between;
+}
+/**
+ * Get all nodes between node1 and node2, included.
+ */
+function getNodesInclusivelyBetween(node1, node2, treeOptions) {
+    const isFrontier = or(equals(node1), equals(node2));
+    return lowestCommonAncestor(node1, node2, treeOptions)
+        .map((context) => context
+        .inclusiveDescendants(treeOptions)
+        .skipUntil(isFrontier)
+        .skipLastUntil(isFrontier))
+        .getOrElse(Sequence.empty);
+}
+//# sourceMappingURL=get-nodes-between.js.map