@siteimprove/alfa-dom 0.89.2

package/dist/style/rule/font-face.js

@@ -0,0 +1,47 @@
+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 FontFaceRule extends Rule {
+    static of(declarations) {
+        return new FontFaceRule(Array.from(declarations));
+    }
+    _style;
+    constructor(declarations) {
+        super("font-face");
+        this._style = Block.of(declarations.filter((declaration) => declaration._attachParent(this)));
+    }
+    get style() {
+        return this._style;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            style: this._style.toJSON(),
+        };
+    }
+    toString() {
+        const style = this._style.toString();
+        return `@font-face {${style === "" ? "" : `\n${String.indent(style)}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (FontFaceRule) {
+    function isFontFaceRule(value) {
+        return value instanceof FontFaceRule;
+    }
+    FontFaceRule.isFontFaceRule = isFontFaceRule;
+    /**
+     * @internal
+     */
+    function fromFontFaceRule(json) {
+        return Trampoline.done(FontFaceRule.of(Block.from(json.style)));
+    }
+    FontFaceRule.fromFontFaceRule = fromFontFaceRule;
+})(FontFaceRule || (FontFaceRule = {}));
+//# sourceMappingURL=font-face.js.map

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

@@ -0,0 +1,22 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export declare abstract class GroupingRule<T extends string = string> extends Rule<T> {
+    protected readonly _rules: Array<Rule>;
+    protected constructor(type: T, rules: Array<Rule>);
+    get rules(): Iterable<Rule>;
+    children(): Iterable<Rule>;
+    toJSON(): GroupingRule.JSON<T>;
+}
+/**
+ * @public
+ */
+export declare namespace GroupingRule {
+    interface JSON<T extends string = string> extends Rule.JSON<T> {
+        rules: Array<Rule.JSON>;
+    }
+    function isGroupingRule(value: unknown): value is GroupingRule;
+}
+//# sourceMappingURL=grouping.d.ts.map

package/dist/style/rule/grouping.js

@@ -0,0 +1,34 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Rule } from "../rule.js";
+/**
+ * @public
+ */
+export class GroupingRule extends Rule {
+    _rules;
+    constructor(type, rules) {
+        super(type);
+        this._rules = rules.filter((rule) => rule._attachParent(this));
+    }
+    get rules() {
+        return this._rules;
+    }
+    *children() {
+        yield* this._rules;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            rules: Array.toJSON(this._rules),
+        };
+    }
+}
+/**
+ * @public
+ */
+(function (GroupingRule) {
+    function isGroupingRule(value) {
+        return value instanceof GroupingRule;
+    }
+    GroupingRule.isGroupingRule = isGroupingRule;
+})(GroupingRule || (GroupingRule = {}));
+//# sourceMappingURL=grouping.js.map

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

@@ -0,0 +1,47 @@
+import { Feature } from "@siteimprove/alfa-css-feature";
+import type { Device } from "@siteimprove/alfa-device";
+import { Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { Sheet } from "../sheet.js";
+import { ConditionRule } from "./condition.js";
+/**
+ * @public
+ */
+export declare class ImportRule extends ConditionRule<"import"> {
+    static of(href: string, sheet: Sheet, mediaCondition?: Option<string>, supportCondition?: Option<string>, layer?: Option<string>): ImportRule;
+    private readonly _href;
+    private readonly _sheet;
+    private readonly _mediaQueries;
+    private readonly _supportCondition;
+    private readonly _supportQuery;
+    private _layer;
+    private constructor();
+    get supportCondition(): Option<string>;
+    get mediaQueries(): Feature.Media.List;
+    get supportQuery(): Option<Option<Feature.Supports.Query>>;
+    get layer(): Option<string>;
+    get rules(): Iterable<Rule>;
+    get href(): string;
+    get sheet(): Sheet;
+    toJSON(): ImportRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace ImportRule {
+    interface JSON extends ConditionRule.JSON<"import"> {
+        href: string;
+        supportText: string | null;
+        layer: string | null;
+    }
+    function isImportRule(value: unknown): value is ImportRule;
+    function matches(device: Device): Predicate<ImportRule>;
+    /**
+     * @internal
+     */
+    function fromImportRule(json: JSON): Trampoline<ImportRule>;
+}
+//# sourceMappingURL=import.d.ts.map

package/dist/style/rule/import.js

@@ -0,0 +1,114 @@
+import { Lexer } from "@siteimprove/alfa-css";
+import { Feature } from "@siteimprove/alfa-css-feature";
+import { Option, None } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { Sheet } from "../sheet.js";
+import { ConditionRule } from "./condition.js";
+const { and } = Predicate;
+/**
+ * @public
+ */
+export class ImportRule extends ConditionRule {
+    static of(href, sheet, mediaCondition = None, supportCondition = None, layer = None) {
+        return new ImportRule(href, sheet, mediaCondition, supportCondition, layer);
+    }
+    _href;
+    _sheet;
+    _mediaQueries;
+    _supportCondition;
+    // There may be no support condition, or an unparsable (i.e. non-supported) one.
+    // The former is None, the later is Some(None).
+    _supportQuery;
+    // Anonymous layers are represented with the empty string, matching the
+    // CSSImportRule interface
+    _layer;
+    constructor(href, sheet, mediaCondition, supportCondition, layer) {
+        super("import", mediaCondition.getOr("all"), []);
+        this._href = href;
+        this._sheet = sheet;
+        this._supportCondition = supportCondition;
+        this._layer = layer;
+        this._mediaQueries = mediaCondition
+            .flatMap((condition) => Feature.parseMediaQuery(Lexer.lex(condition)).ok())
+            .map(([, queries]) => queries)
+            .getOr(Feature.Media.List.of([]));
+        this._supportQuery = supportCondition.map((condition) => Feature.parseSupportsQuery(
+        // We're not sure where the condition comes from, but Alfa only parses
+        // them when they are parenthesised, while CSSImportRule.supportsText
+        // provides the raw text. Extra parenthesis don't block parsing.
+        // In doubt, adding some to avoid potential problems.
+        Lexer.lex(`(${condition})`))
+            .ok()
+            .map(([, query]) => query));
+    }
+    get supportCondition() {
+        return this._supportCondition;
+    }
+    get mediaQueries() {
+        return this._mediaQueries;
+    }
+    get supportQuery() {
+        return this._supportQuery;
+    }
+    get layer() {
+        return this._layer;
+    }
+    get rules() {
+        return this._sheet.rules;
+    }
+    get href() {
+        return this._href;
+    }
+    get sheet() {
+        return this._sheet;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            href: this._href,
+            // We match the CSSImportRule interface returning null when no support
+            // text exist
+            supportText: this._supportCondition.getOr(null),
+            // We match the CSSImportRule interface returning null when no layer
+            // is declared, and "" for an anonymous layer.
+            layer: this._layer.getOr(null),
+        };
+    }
+    toString() {
+        return (`@import url(${this._href}) ` +
+            `${this._layer.map((layer) => `layer${layer === "" ? "" : `(${layer}) `}`)}` +
+            `${this._supportCondition.map((condition) => `supports(${condition}) `).getOr("")}` +
+            `${this._condition}`);
+    }
+}
+/**
+ * @public
+ */
+(function (ImportRule) {
+    function isImportRule(value) {
+        return value instanceof ImportRule;
+    }
+    ImportRule.isImportRule = isImportRule;
+    function matchesMedia(device) {
+        return (rule) => rule.mediaQueries.matches(device);
+    }
+    function matchesSupport(device) {
+        // If there is no support condition (None), it is matched.
+        // If there is an unparsable one (Some(None)), it is not matched.
+        return (rule) => rule.supportQuery.every((option) => option.some((query) => query.matches(device)));
+    }
+    function matches(device) {
+        return and(matchesMedia(device), matchesSupport(device));
+    }
+    ImportRule.matches = matches;
+    /**
+     * @internal
+     */
+    function fromImportRule(json) {
+        return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => ImportRule.of(json.href, Sheet.of(rules), Option.of(json.condition), Option.from(json.supportText), Option.from(json.layer)));
+    }
+    ImportRule.fromImportRule = fromImportRule;
+})(ImportRule || (ImportRule = {}));
+//# sourceMappingURL=import.js.map

package/dist/style/rule/keyframe.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 KeyframeRule extends Rule<"keyframe"> {
+    static of(key: string, declarations: Iterable<Declaration>): KeyframeRule;
+    private readonly _key;
+    private readonly _style;
+    private constructor();
+    get key(): string;
+    get style(): Block;
+    toJSON(): KeyframeRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace KeyframeRule {
+    interface JSON extends Rule.JSON<"keyframe"> {
+        key: string;
+        style: Block.JSON | string;
+    }
+    function isKeyframeRule(value: unknown): value is KeyframeRule;
+    /**
+     * @internal
+     */
+    function fromKeyframeRule(json: JSON): Trampoline<KeyframeRule>;
+}
+//# sourceMappingURL=keyframe.d.ts.map

package/dist/style/rule/keyframe.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 KeyframeRule extends Rule {
+    static of(key, declarations) {
+        return new KeyframeRule(key, Array.from(declarations));
+    }
+    _key;
+    _style;
+    constructor(key, declarations) {
+        super("keyframe");
+        this._key = key;
+        this._style = Block.of(declarations.filter((declaration) => declaration._attachParent(this)));
+    }
+    get key() {
+        return this._key;
+    }
+    get style() {
+        return this._style;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            key: this._key,
+            style: this._style.toJSON(),
+        };
+    }
+    toString() {
+        const style = this._style.toString();
+        return `@keyframe ${this._key} {${style === "" ? "" : `\n${String.indent(style)}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (KeyframeRule) {
+    function isKeyframeRule(value) {
+        return value instanceof KeyframeRule;
+    }
+    KeyframeRule.isKeyframeRule = isKeyframeRule;
+    /**
+     * @internal
+     */
+    function fromKeyframeRule(json) {
+        return Trampoline.done(KeyframeRule.of(json.key, Block.from(json.style).declarations));
+    }
+    KeyframeRule.fromKeyframeRule = fromKeyframeRule;
+})(KeyframeRule || (KeyframeRule = {}));
+//# sourceMappingURL=keyframe.js.map

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

@@ -0,0 +1,28 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { GroupingRule } from "./grouping.js";
+/**
+ * @public
+ */
+export declare class KeyframesRule extends GroupingRule<"keyframes"> {
+    static of(name: string, rules: Iterable<Rule>): KeyframesRule;
+    private readonly _name;
+    private constructor();
+    get name(): string;
+    toJSON(): KeyframesRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace KeyframesRule {
+    interface JSON extends GroupingRule.JSON<"keyframes"> {
+        name: string;
+    }
+    function isKeyframesRule(value: unknown): value is KeyframesRule;
+    /**
+     * @internal
+     */
+    function fromKeyframesRule(json: JSON): Trampoline<KeyframesRule>;
+}
+//# sourceMappingURL=keyframes.d.ts.map

package/dist/style/rule/keyframes.js

@@ -0,0 +1,49 @@
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { GroupingRule } from "./grouping.js";
+/**
+ * @public
+ */
+export class KeyframesRule extends GroupingRule {
+    static of(name, rules) {
+        return new KeyframesRule(name, Array.from(rules));
+    }
+    _name;
+    constructor(name, rules) {
+        super("keyframes", rules);
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            name: this._name,
+        };
+    }
+    toString() {
+        const rules = this._rules
+            .map((rule) => String.indent(rule.toString()))
+            .join("\n\n");
+        return `@keyframes ${this._name} {${rules === "" ? "" : `\n${rules}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (KeyframesRule) {
+    function isKeyframesRule(value) {
+        return value instanceof KeyframesRule;
+    }
+    KeyframesRule.isKeyframesRule = isKeyframesRule;
+    /**
+     * @internal
+     */
+    function fromKeyframesRule(json) {
+        return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => KeyframesRule.of(json.name, rules));
+    }
+    KeyframesRule.fromKeyframesRule = fromKeyframesRule;
+})(KeyframesRule || (KeyframesRule = {}));
+//# sourceMappingURL=keyframes.js.map

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

@@ -0,0 +1,61 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { GroupingRule } from "./grouping.js";
+/**
+ * Model for CSS layers
+ *
+ * @remarks
+ * There are actually two kinds of `@layer` rules: block and statements.
+ * Both are introduced by the same keyword, and work closely together,
+ * hence they are kept here for better cohesion. They are, however,
+ * represented as separated Classes, with separated `type`, mimicking the two
+ * JS interfaces that exist in native DOM.
+ *
+ * @public
+ */
+export declare namespace Layer {
+    /**
+     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/@layer}
+     * {@link https://drafts.csswg.org/css-cascade-5/#layer-empty}
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSLayerStatementRule}
+     */
+    class StatementRule extends Rule<"layer-statement"> {
+        static of(layers: Iterable<string>): StatementRule;
+        private readonly _layers;
+        private constructor();
+        get layers(): Iterable<string>;
+        toJSON(): StatementRule.JSON;
+        toString(): string;
+    }
+    namespace StatementRule {
+        interface JSON extends Rule.JSON<"layer-statement"> {
+            layers: Array<string>;
+        }
+        function fromLayerStatementRule(json: JSON): Trampoline<StatementRule>;
+        function isLayerStatementRule(value: unknown): value is StatementRule;
+    }
+    /**
+     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/@layer}
+     * {@link https://drafts.csswg.org/css-cascade-5/#layer-block}
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSLayerBlockRule}
+     */
+    class BlockRule extends GroupingRule<"layer-block"> {
+        static of(rules: Iterable<Rule>, layer?: string | null): BlockRule;
+        private readonly _layer;
+        private constructor();
+        get layer(): Option<string>;
+        equals(value: unknown): value is this;
+        toJSON(): BlockRule.JSON;
+        toString(): string;
+    }
+    namespace BlockRule {
+        interface JSON extends GroupingRule.JSON<"layer-block"> {
+            layer: string | null;
+        }
+        function fromLayerBlockRule(json: JSON): Trampoline<BlockRule>;
+        function isLayerBlockRule(value: unknown): value is BlockRule;
+    }
+}
+//# sourceMappingURL=layer.d.ts.map

package/dist/style/rule/layer.js

@@ -0,0 +1,106 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Option } from "@siteimprove/alfa-option";
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { GroupingRule } from "./grouping.js";
+/**
+ * Model for CSS layers
+ *
+ * @remarks
+ * There are actually two kinds of `@layer` rules: block and statements.
+ * Both are introduced by the same keyword, and work closely together,
+ * hence they are kept here for better cohesion. They are, however,
+ * represented as separated Classes, with separated `type`, mimicking the two
+ * JS interfaces that exist in native DOM.
+ *
+ * @public
+ */
+export var Layer;
+(function (Layer) {
+    /**
+     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/@layer}
+     * {@link https://drafts.csswg.org/css-cascade-5/#layer-empty}
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSLayerStatementRule}
+     */
+    class StatementRule extends Rule {
+        static of(layers) {
+            return new StatementRule(Array.from(layers));
+        }
+        _layers;
+        constructor(layers) {
+            super("layer-statement");
+            this._layers = layers;
+        }
+        get layers() {
+            return this._layers;
+        }
+        toJSON() {
+            return {
+                ...super.toJSON(),
+                layers: this._layers,
+            };
+        }
+        toString() {
+            return `@layer ${this._layers.join(", ")};`;
+        }
+    }
+    Layer.StatementRule = StatementRule;
+    (function (StatementRule) {
+        function fromLayerStatementRule(json) {
+            return Trampoline.done(StatementRule.of(json.layers));
+        }
+        StatementRule.fromLayerStatementRule = fromLayerStatementRule;
+        function isLayerStatementRule(value) {
+            return value instanceof StatementRule;
+        }
+        StatementRule.isLayerStatementRule = isLayerStatementRule;
+    })(StatementRule = Layer.StatementRule || (Layer.StatementRule = {}));
+    /**
+     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/@layer}
+     * {@link https://drafts.csswg.org/css-cascade-5/#layer-block}
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSLayerBlockRule}
+     */
+    class BlockRule extends GroupingRule {
+        static of(rules, layer) {
+            return new BlockRule(Option.from(layer), Array.from(rules));
+        }
+        _layer;
+        constructor(layer, rules) {
+            super("layer-block", rules);
+            this._layer = layer;
+        }
+        get layer() {
+            return this._layer;
+        }
+        equals(value) {
+            return (value instanceof BlockRule &&
+                value._layer.equals(this._layer) &&
+                super.equals(value));
+        }
+        toJSON() {
+            return {
+                ...super.toJSON(),
+                layer: this._layer.getOr(null),
+            };
+        }
+        toString() {
+            const rules = this._rules
+                .map((rule) => String.indent(rule.toString()))
+                .join("\n\n");
+            return `@layer ${this._layer.isSome() ? this._layer.getUnsafe() + " " : ""}{${rules === "" ? "" : `\n${rules}\n`}}`;
+        }
+    }
+    Layer.BlockRule = BlockRule;
+    (function (BlockRule) {
+        function fromLayerBlockRule(json) {
+            return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => BlockRule.of(rules, json.layer));
+        }
+        BlockRule.fromLayerBlockRule = fromLayerBlockRule;
+        function isLayerBlockRule(value) {
+            return value instanceof BlockRule;
+        }
+        BlockRule.isLayerBlockRule = isLayerBlockRule;
+    })(BlockRule = Layer.BlockRule || (Layer.BlockRule = {}));
+})(Layer || (Layer = {}));
+//# sourceMappingURL=layer.js.map

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

@@ -0,0 +1,32 @@
+import { Feature } from "@siteimprove/alfa-css-feature";
+import type { Device } from "@siteimprove/alfa-device";
+import type { Iterable } from "@siteimprove/alfa-iterable";
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import { Rule } from "../rule.js";
+import { ConditionRule } from "./condition.js";
+/**
+ * @public
+ */
+export declare class MediaRule extends ConditionRule<"media"> {
+    static of(condition: string, rules: Iterable<Rule>): MediaRule;
+    private readonly _queries;
+    private constructor();
+    get queries(): Feature.Media.List;
+    toJSON(): MediaRule.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace MediaRule {
+    interface JSON extends ConditionRule.JSON<"media"> {
+    }
+    function isMediaRule(value: unknown): value is MediaRule;
+    function matches(device: Device): Predicate<MediaRule>;
+    /**
+     * @internal
+     */
+    function fromMediaRule(json: JSON): Trampoline<MediaRule>;
+}
+//# sourceMappingURL=media.d.ts.map

package/dist/style/rule/media.js

@@ -0,0 +1,54 @@
+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 MediaRule extends ConditionRule {
+    static of(condition, rules) {
+        return new MediaRule(condition, Array.from(rules));
+    }
+    _queries;
+    constructor(condition, rules) {
+        super("media", condition, rules);
+        this._queries = Feature.parseMediaQuery(Lexer.lex(condition))
+            .map(([, queries]) => queries)
+            .getOr(Feature.Media.List.of([]));
+    }
+    get queries() {
+        return this._queries;
+    }
+    toJSON() {
+        return super.toJSON();
+    }
+    toString() {
+        const rules = this._rules
+            .map((rule) => String.indent(rule.toString()))
+            .join("\n\n");
+        return `@media ${this._condition} {${rules === "" ? "" : `\n${rules}\n`}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (MediaRule) {
+    function isMediaRule(value) {
+        return value instanceof MediaRule;
+    }
+    MediaRule.isMediaRule = isMediaRule;
+    function matches(device) {
+        return (rule) => rule.queries.matches(device);
+    }
+    MediaRule.matches = matches;
+    /**
+     * @internal
+     */
+    function fromMediaRule(json) {
+        return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => MediaRule.of(json.condition, rules));
+    }
+    MediaRule.fromMediaRule = fromMediaRule;
+})(MediaRule || (MediaRule = {}));
+//# sourceMappingURL=media.js.map