@siteimprove/alfa-dom 0.89.2

package/dist/style/rule/namespace.d.ts

@@ -0,0 +1,31 @@
+import { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export declare class NamespaceRule extends Rule<"namespace"> {
+    static of(namespace: string, prefix: Option<string>): NamespaceRule;
+    private readonly _namespace;
+    private readonly _prefix;
+    private constructor();
+    get namespace(): string;
+    get prefix(): Option<string>;
+    toJSON(): NamespaceRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace NamespaceRule {
+    interface JSON extends Rule.JSON<"namespace"> {
+        namespace: string;
+        prefix: string | null;
+    }
+    function isNamespaceRule(value: unknown): value is NamespaceRule;
+    /**
+     * @internal
+     */
+    function fromNamespaceRule(json: JSON): Trampoline<NamespaceRule>;
+}
+//# sourceMappingURL=namespace.d.ts.map

package/dist/style/rule/namespace.js

@@ -0,0 +1,52 @@
+import { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export class NamespaceRule extends Rule {
+    static of(namespace, prefix) {
+        return new NamespaceRule(namespace, prefix);
+    }
+    _namespace;
+    _prefix;
+    constructor(namespace, prefix) {
+        super("namespace");
+        this._namespace = namespace;
+        this._prefix = prefix;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            namespace: this._namespace,
+            prefix: this._prefix.getOr(null),
+        };
+    }
+    toString() {
+        const prefix = this._prefix.map((prefix) => ` ${prefix}`).getOr("");
+        return `@namespace ${prefix}url(${this._namespace})`;
+    }
+}
+/**
+ * @public
+ */
+(function (NamespaceRule) {
+    function isNamespaceRule(value) {
+        return value instanceof NamespaceRule;
+    }
+    NamespaceRule.isNamespaceRule = isNamespaceRule;
+    /**
+     * @internal
+     */
+    function fromNamespaceRule(json) {
+        return Trampoline.done(NamespaceRule.of(json.namespace, Option.from(json.prefix)));
+    }
+    NamespaceRule.fromNamespaceRule = fromNamespaceRule;
+})(NamespaceRule || (NamespaceRule = {}));
+//# sourceMappingURL=namespace.js.map

package/dist/style/rule/page.d.ts

@@ -0,0 +1,32 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Block } from "../block.js";
+import type { Declaration } from "../declaration.js";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export declare class PageRule extends Rule<"page"> {
+    static of(selector: string, declarations: Iterable<Declaration>): PageRule;
+    private readonly _selector;
+    private readonly _style;
+    private constructor();
+    get selector(): string;
+    get style(): Block;
+    toJSON(): PageRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace PageRule {
+    interface JSON extends Rule.JSON<"page"> {
+        selector: string;
+        style: Block.JSON | string;
+    }
+    function isPageRule(value: unknown): value is PageRule;
+    /**
+     * @internal
+     */
+    function fromPageRule(json: JSON): Trampoline<PageRule>;
+}
+//# sourceMappingURL=page.d.ts.map

package/dist/style/rule/page.js

@@ -0,0 +1,53 @@
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Block } from "../block.js";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export class PageRule extends Rule {
+    static of(selector, declarations) {
+        return new PageRule(selector, Array.from(declarations));
+    }
+    _selector;
+    _style;
+    constructor(selector, declarations) {
+        super("page");
+        this._selector = selector;
+        this._style = Block.of(declarations.filter((declaration) => declaration._attachParent(this)));
+    }
+    get selector() {
+        return this._selector;
+    }
+    get style() {
+        return this._style;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            selector: this._selector,
+            style: this._style.toJSON(),
+        };
+    }
+    toString() {
+        const style = this._style.toString();
+        return `@page ${this._selector} {${style === "" ? "" : `\n${String.indent(style)}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (PageRule) {
+    function isPageRule(value) {
+        return value instanceof PageRule;
+    }
+    PageRule.isPageRule = isPageRule;
+    /**
+     * @internal
+     */
+    function fromPageRule(json) {
+        return Trampoline.done(PageRule.of(json.selector, Block.from(json.style)));
+    }
+    PageRule.fromPageRule = fromPageRule;
+})(PageRule || (PageRule = {}));
+//# sourceMappingURL=page.js.map

package/dist/style/rule/style.d.ts

@@ -0,0 +1,35 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Block } from "../block.js";
+import type { Declaration } from "../declaration.js";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export declare class StyleRule extends Rule<"style"> {
+    static of(selector: string, declarations: Iterable<Declaration>, hint?: boolean): StyleRule;
+    private readonly _selector;
+    private readonly _style;
+    private readonly _hint;
+    private constructor();
+    get selector(): string;
+    get style(): Block;
+    get hint(): boolean;
+    toJSON(): StyleRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace StyleRule {
+    interface JSON extends Rule.JSON<"style"> {
+        selector: string;
+        style: Block.JSON | string;
+    }
+    function isStyleRule(value: unknown): value is StyleRule;
+    function isEmpty(rule: StyleRule): boolean;
+    /**
+     * @internal
+     */
+    function fromStyleRule(json: JSON): Trampoline<StyleRule>;
+}
+//# sourceMappingURL=style.d.ts.map

package/dist/style/rule/style.js

@@ -0,0 +1,62 @@
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Block } from "../block.js";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export class StyleRule extends Rule {
+    static of(selector, declarations, hint = false) {
+        return new StyleRule(selector, Array.from(declarations), hint);
+    }
+    _selector;
+    _style;
+    _hint;
+    constructor(selector, declarations, hint) {
+        super("style");
+        this._selector = selector;
+        this._style = Block.of(declarations.filter((declaration) => declaration._attachParent(this)));
+        this._hint = hint;
+    }
+    get selector() {
+        return this._selector;
+    }
+    get style() {
+        return this._style;
+    }
+    get hint() {
+        return this._hint;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            selector: this._selector,
+            style: this._style.toJSON(),
+        };
+    }
+    toString() {
+        const style = this._style.toString();
+        return `${this._selector} {${style === "" ? "" : `\n${String.indent(style)}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (StyleRule) {
+    function isStyleRule(value) {
+        return value instanceof StyleRule;
+    }
+    StyleRule.isStyleRule = isStyleRule;
+    function isEmpty(rule) {
+        return rule.style.isEmpty();
+    }
+    StyleRule.isEmpty = isEmpty;
+    /**
+     * @internal
+     */
+    function fromStyleRule(json) {
+        return Trampoline.done(StyleRule.of(json.selector, Block.from(json.style)));
+    }
+    StyleRule.fromStyleRule = fromStyleRule;
+})(StyleRule || (StyleRule = {}));
+//# sourceMappingURL=style.js.map

package/dist/style/rule/supports.d.ts

@@ -0,0 +1,32 @@
+import { Feature } from "@siteimprove/alfa-css-feature";
+import type { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { ConditionRule } from "./condition.js";
+import type { Device } from "@siteimprove/alfa-device";
+import type { Predicate } from "@siteimprove/alfa-predicate";
+/**
+ * @public
+ */
+export declare class SupportsRule extends ConditionRule<"supports"> {
+    static of(condition: string, rules: Iterable<Rule>): SupportsRule;
+    private readonly _query;
+    private constructor();
+    get query(): Option<Feature.Supports.Query>;
+    toJSON(): SupportsRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace SupportsRule {
+    interface JSON extends ConditionRule.JSON<"supports"> {
+    }
+    function isSupportsRule(value: unknown): value is SupportsRule;
+    function matches(device: Device): Predicate<SupportsRule>;
+    /**
+     * @internal
+     */
+    function fromSupportsRule(json: JSON): Trampoline<SupportsRule>;
+}
+//# sourceMappingURL=supports.d.ts.map

package/dist/style/rule/supports.js

@@ -0,0 +1,56 @@
+import { Lexer } from "@siteimprove/alfa-css";
+import { Feature } from "@siteimprove/alfa-css-feature";
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { ConditionRule } from "./condition.js";
+/**
+ * @public
+ */
+export class SupportsRule extends ConditionRule {
+    static of(condition, rules) {
+        return new SupportsRule(condition, Array.from(rules));
+    }
+    _query;
+    constructor(condition, rules) {
+        super("supports", condition, rules);
+        this._query = Feature.parseSupportsQuery(Lexer.lex(condition))
+            .map(([, query]) => query)
+            .ok();
+    }
+    get query() {
+        return this._query;
+    }
+    toJSON() {
+        return super.toJSON();
+    }
+    toString() {
+        const rules = this._rules
+            .map((rule) => String.indent(rule.toString()))
+            .join("\n\n");
+        return `@supports ${this._condition} {${rules === "" ? "" : `\n${rules}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (SupportsRule) {
+    function isSupportsRule(value) {
+        return value instanceof SupportsRule;
+    }
+    SupportsRule.isSupportsRule = isSupportsRule;
+    function matches(device) {
+        // If rule.query is None, Alfa couldn't parse the query which
+        // means it does not support it.
+        return (rule) => rule.query.some((query) => query.matches(device));
+    }
+    SupportsRule.matches = matches;
+    /**
+     * @internal
+     */
+    function fromSupportsRule(json) {
+        return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => SupportsRule.of(json.condition, rules));
+    }
+    SupportsRule.fromSupportsRule = fromSupportsRule;
+})(SupportsRule || (SupportsRule = {}));
+//# sourceMappingURL=supports.js.map

package/dist/style/rule.d.ts

@@ -0,0 +1,60 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import type { Serializable } from "@siteimprove/alfa-json";
+import { Option } from "@siteimprove/alfa-option";
+import type { Trampoline } from "@siteimprove/alfa-trampoline";
+import type * as json from "@siteimprove/alfa-json";
+import type { Sheet } from "./sheet.js";
+import { FontFaceRule, ImportRule, KeyframeRule, KeyframesRule, Layer, MediaRule, NamespaceRule, PageRule, StyleRule, SupportsRule } from "../index.js";
+/**
+ * @public
+ */
+export declare abstract class Rule<T extends string = string> implements Equatable, Serializable {
+    protected _owner: Option<Sheet>;
+    protected _parent: Option<Rule>;
+    private readonly _type;
+    protected constructor(type: T);
+    get type(): T;
+    get owner(): Option<Sheet>;
+    get parent(): Option<Rule>;
+    children(): Iterable<Rule>;
+    descendants(): Iterable<Rule>;
+    ancestors(): Iterable<Rule>;
+    inclusiveAncestors(): Iterable<Rule>;
+    equals(value: unknown): value is this;
+    toJSON(): Rule.JSON<T>;
+    /**
+     * @internal
+     */
+    _attachOwner(owner: Sheet): boolean;
+    /**
+     * @internal
+     */
+    _attachParent(parent: Rule): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Rule {
+    interface JSON<T extends string = string> {
+        [key: string]: json.JSON;
+        type: T;
+    }
+    function from(json: FontFaceRule.JSON): FontFaceRule;
+    function from(json: ImportRule.JSON): ImportRule;
+    function from(json: KeyframeRule.JSON): KeyframeRule;
+    function from(json: KeyframesRule.JSON): KeyframesRule;
+    function from(json: Layer.BlockRule.JSON): Layer.BlockRule;
+    function from(json: Layer.StatementRule.JSON): Layer.StatementRule;
+    function from(json: MediaRule.JSON): MediaRule;
+    function from(json: NamespaceRule.JSON): NamespaceRule;
+    function from(json: PageRule.JSON): PageRule;
+    function from(json: StyleRule.JSON): StyleRule;
+    function from(json: SupportsRule.JSON): SupportsRule;
+    function from(json: JSON): Rule;
+    /**
+     * @internal
+     */
+    function fromRule(json: JSON): Trampoline<Rule>;
+}
+//# sourceMappingURL=rule.d.ts.map

package/dist/style/rule.js

@@ -0,0 +1,109 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { None, Option } from "@siteimprove/alfa-option";
+import { FontFaceRule, ImportRule, KeyframeRule, KeyframesRule, Layer, MediaRule, NamespaceRule, PageRule, StyleRule, SupportsRule, } from "../index.js";
+/**
+ * @public
+ */
+export class Rule {
+    _owner = None;
+    _parent = None;
+    _type;
+    constructor(type) {
+        this._type = type;
+    }
+    get type() {
+        return this._type;
+    }
+    get owner() {
+        return this._owner;
+    }
+    get parent() {
+        return this._parent;
+    }
+    *children() { }
+    *descendants() {
+        for (const child of this.children()) {
+            yield child;
+            yield* child.descendants();
+        }
+    }
+    *ancestors() {
+        for (const parent of this._parent) {
+            yield parent;
+            yield* parent.ancestors();
+        }
+    }
+    *inclusiveAncestors() {
+        yield this;
+        yield* this.ancestors();
+    }
+    equals(value) {
+        return value === this;
+    }
+    toJSON() {
+        return { type: this._type };
+    }
+    /**
+     * @internal
+     */
+    _attachOwner(owner) {
+        if (this._owner.isSome()) {
+            return false;
+        }
+        this._owner = Option.of(owner);
+        // Recursively attach the owner to all children.
+        return Iterable.every(this.children(), (rule) => rule._attachOwner(owner));
+    }
+    /**
+     * @internal
+     */
+    _attachParent(parent) {
+        if (this._parent.isSome()) {
+            return false;
+        }
+        this._parent = Option.of(parent);
+        return true;
+    }
+}
+/**
+ * @public
+ */
+(function (Rule) {
+    function from(json) {
+        return fromRule(json).run();
+    }
+    Rule.from = from;
+    /**
+     * @internal
+     */
+    function fromRule(json) {
+        switch (json.type) {
+            case "font-face":
+                return FontFaceRule.fromFontFaceRule(json);
+            case "import":
+                return ImportRule.fromImportRule(json);
+            case "keyframe":
+                return KeyframeRule.fromKeyframeRule(json);
+            case "keyframes":
+                return KeyframesRule.fromKeyframesRule(json);
+            case "layer-block":
+                return Layer.BlockRule.fromLayerBlockRule(json);
+            case "layer-statement":
+                return Layer.StatementRule.fromLayerStatementRule(json);
+            case "media":
+                return MediaRule.fromMediaRule(json);
+            case "namespace":
+                return NamespaceRule.fromNamespaceRule(json);
+            case "page":
+                return PageRule.fromPageRule(json);
+            case "style":
+                return StyleRule.fromStyleRule(json);
+            case "supports":
+                return SupportsRule.fromSupportsRule(json);
+            default:
+                throw new Error(`Unexpected rule of type: ${json.type}`);
+        }
+    }
+    Rule.fromRule = fromRule;
+})(Rule || (Rule = {}));
+//# sourceMappingURL=rule.js.map

package/dist/style/sheet.d.ts

@@ -0,0 +1,37 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { Serializable } from "@siteimprove/alfa-json";
+import { Option } from "@siteimprove/alfa-option";
+import type * as json from "@siteimprove/alfa-json";
+import { Rule } from "./rule.js";
+/**
+ * @public
+ */
+export declare class Sheet implements Equatable, Serializable {
+    static of(rules: Iterable<Rule>, disabled?: boolean, condition?: Option<string>): Sheet;
+    static empty(): Sheet;
+    private _rules;
+    private readonly _disabled;
+    private readonly _condition;
+    private constructor();
+    get rules(): Iterable<Rule>;
+    get disabled(): boolean;
+    get condition(): Option<string>;
+    children(): Iterable<Rule>;
+    descendants(): Iterable<Rule>;
+    equals(value: unknown): value is this;
+    toJSON(): Sheet.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Sheet {
+    interface JSON {
+        [key: string]: json.JSON;
+        rules: Array<Rule.JSON>;
+        disabled: boolean;
+        condition: string | null;
+    }
+    function from(json: JSON): Sheet;
+}
+//# sourceMappingURL=sheet.d.ts.map

package/dist/style/sheet.js

@@ -0,0 +1,66 @@
+import { Option, None } from "@siteimprove/alfa-option";
+import { Rule } from "./rule.js";
+/**
+ * @public
+ */
+export class Sheet {
+    static of(rules, disabled = false, condition = None) {
+        return new Sheet(Array.from(rules), disabled, condition);
+    }
+    static empty() {
+        return new Sheet([], false, None);
+    }
+    _rules;
+    _disabled;
+    _condition;
+    constructor(rules, disabled, condition) {
+        this._rules = rules.filter((rule) => rule._attachOwner(this));
+        this._disabled = disabled;
+        this._condition = condition;
+    }
+    get rules() {
+        return this._rules;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get condition() {
+        return this._condition;
+    }
+    *children() {
+        yield* this._rules;
+    }
+    *descendants() {
+        for (const child of this.children()) {
+            yield child;
+            yield* child.descendants();
+        }
+    }
+    equals(value) {
+        return (value instanceof Sheet &&
+            value._disabled === this._disabled &&
+            value._condition.equals(this._condition) &&
+            value._rules.length === this._rules.length &&
+            value._rules.every((rule, i) => rule.equals(this._rules[i])));
+    }
+    toJSON() {
+        return {
+            rules: [...this._rules].map((rule) => rule.toJSON()),
+            disabled: this._disabled,
+            condition: this._condition.getOr(null),
+        };
+    }
+    toString() {
+        return this._rules.join("\n");
+    }
+}
+/**
+ * @public
+ */
+(function (Sheet) {
+    function from(json) {
+        return Sheet.of(json.rules.map(Rule.from), json.disabled, Option.from(json.condition));
+    }
+    Sheet.from = from;
+})(Sheet || (Sheet = {}));
+//# sourceMappingURL=sheet.js.map