@siteimprove/alfa-dom 0.112.0 → 0.114.0

package/dist/node/slotable/slotable.js

@@ -0,0 +1,16 @@
+import { BaseNode } from "../node.js";
+/**
+ * @public
+ */
+export class Slotable extends BaseNode {
+}
+/**
+ * @public
+ */
+(function (Slotable) {
+    function isSlotable(value) {
+        return value instanceof Slotable;
+    }
+    Slotable.isSlotable = isSlotable;
+})(Slotable || (Slotable = {}));
+//# sourceMappingURL=slotable.js.map

package/dist/node/{text.d.ts → slotable/text.d.ts}

@@ -4,13 +4,13 @@ import { Predicate } from "@siteimprove/alfa-predicate";
 import { Rectangle } from "@siteimprove/alfa-rectangle";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import * as json from "@siteimprove/alfa-json";
-import { Node } from "../node.js";
+import { BaseNode } from "../node.js";
 import type { Slot } from "./slot.js";
 import { Slotable } from "./slotable.js";
 /**
  * @public
  */
-export declare class Text extends Node<"text"> implements Slotable {
+export declare class Text extends Slotable<"text"> {
     static of(data: string, box?: Option<Rectangle>, device?: Option<Device>, externalId?: string, internalId?: string, extraData?: any): Text;
     static empty(): Text;
     private readonly _data;
@@ -18,25 +18,26 @@ export declare class Text extends Node<"text"> implements Slotable {
     protected constructor(data: string, box: Option<Rectangle>, device: Option<Device>, externalId?: string, internalId?: string, extraData?: any);
     get data(): string;
     assignedSlot(): Option<Slot>;
+    slotableName(): string;
     getBoundingBox(device: Device): Option<Rectangle>;
     is(predicate: Predicate<string>): boolean;
     /**
      * @internal
      **/
-    protected _internalPath(options?: Node.Traversal): string;
-    toJSON(options: Node.SerializationOptions & {
+    protected _internalPath(options?: BaseNode.Traversal): string;
+    toJSON(options: BaseNode.SerializationOptions & {
         verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
     }): Text.MinimalJSON;
-    toJSON(options?: Node.SerializationOptions): Text.JSON;
+    toJSON(options?: BaseNode.SerializationOptions): Text.JSON;
     toString(): string;
 }
 /**
  * @public
  */
 export declare namespace Text {
-    interface MinimalJSON extends Node.JSON<"text"> {
+    interface MinimalJSON extends BaseNode.JSON<"text"> {
     }
-    interface JSON extends Node.JSON<"text"> {
+    interface JSON extends BaseNode.JSON<"text"> {
         data: string;
         box: Rectangle.JSON | null;
     }
@@ -46,9 +47,5 @@ export declare namespace Text {
      * @internal
      */
     function fromText(json: JSON, device?: Device): Trampoline<Text>;
-    /**
-     * @internal
-     */
-    function cloneText(device?: Device): (text: Text) => Trampoline<Text>;
 }
 //# sourceMappingURL=text.d.ts.map

package/dist/node/{text.js → slotable/text.js}

@@ -4,12 +4,13 @@ import { Predicate } from "@siteimprove/alfa-predicate";
 import { Rectangle } from "@siteimprove/alfa-rectangle";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import * as json from "@siteimprove/alfa-json";
-import { Node } from "../node.js";
+import { BaseNode } from "../node.js";
+import { Element } from "./element.js";
 import { Slotable } from "./slotable.js";
 /**
  * @public
  */
-export class Text extends Node {
+export class Text extends Slotable {
     static of(data, box = None, device = None, externalId, internalId, extraData) {
         return new Text(data, box, device, externalId, internalId, extraData);
     }
@@ -27,7 +28,16 @@ export class Text extends Node {
         return this._data;
     }
     assignedSlot() {
-        return Slotable.findSlot(this);
+        const name = this.slotableName();
+        return this.parent()
+            .filter(Element.isElement)
+            .flatMap((parent) => parent.shadow.flatMap((shadow) => shadow
+            .descendants()
+            .filter(Element.isSlot)
+            .find((slot) => slot.slotName() === name)));
+    }
+    slotableName() {
+        return "";
     }
     getBoundingBox(device) {
         return this._boxes.get(device);
@@ -95,12 +105,5 @@ export class Text extends Node {
         return Trampoline.done(Text.of(json.data, Option.from(json.box).map(Rectangle.from), Option.from(device), json.externalId, undefined, json.internalId));
     }
     Text.fromText = fromText;
-    /**
-     * @internal
-     */
-    function cloneText(device) {
-        return (text) => Trampoline.done(Text.of(text.data, Option.from(device).flatMap((d) => text.getBoundingBox(d)), Option.from(device), text.externalId, text.extraData, text.internalId));
-    }
-    Text.cloneText = cloneText;
 })(Text || (Text = {}));
 //# sourceMappingURL=text.js.map

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

@@ -1,5 +1,5 @@
 import { Sequence } from "@siteimprove/alfa-sequence";
-import { Node } from "../../index.js";
+import type { 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)

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

@@ -1,6 +1,6 @@
 import { Predicate } from "@siteimprove/alfa-predicate";
 import { Sequence } from "@siteimprove/alfa-sequence";
-import { Node } from "../../index.js";
+import { BaseNode } from "../node.js";
 import { lowestCommonAncestor } from "./lowest-common-ancestor.js";
 const { equals, or } = Predicate;
 /**
@@ -18,7 +18,7 @@ const { equals, or } = Predicate;
  *
  * @public
  */
-export function getNodesBetween(node1, node2, includeOptions = { includeFirst: false, includeSecond: false }, treeOptions = Node.fullTree) {
+export function getNodesBetween(node1, node2, includeOptions = { includeFirst: false, includeSecond: false }, treeOptions = BaseNode.Traversal.empty) {
     let between = getNodesInclusivelyBetween(node1, node2, treeOptions);
     // If somehow there is nothing between them, escape now
     if (between.isEmpty()) {
@@ -52,7 +52,7 @@ export function getNodesBetween(node1, node2, includeOptions = { includeFirst: f
  */
 function getNodesInclusivelyBetween(node1, node2, treeOptions) {
     const isFrontier = or(equals(node1), equals(node2));
-    return lowestCommonAncestor(node1, node2, treeOptions)
+    return lowestCommonAncestor(node1, node2)
         .map((context) => context
         .inclusiveDescendants(treeOptions)
         .skipUntil(isFrontier)

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

@@ -0,0 +1,2 @@
+export * from "./get-nodes-between.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/traversal/index.js

@@ -0,0 +1,2 @@
+export * from "./get-nodes-between.js";
+//# sourceMappingURL=index.js.map

package/dist/node/traversal/lowest-common-ancestor.d.ts

@@ -1,5 +1,5 @@
 import { Option } from "@siteimprove/alfa-option";
-import { Node } from "../../index.js";
+import type { Node } from "../../index.js";
 /**
  * Find the lowest common ancestor of two nodes:
  * * get the ancestors chain of both

package/dist/node/traversal/lowest-common-ancestor.js

@@ -1,5 +1,5 @@
 import { None, Option } from "@siteimprove/alfa-option";
-import { Node } from "../../index.js";
+import { BaseNode } from "../node.js";
 /**
  * Find the lowest common ancestor of two nodes:
  * * get the ancestors chain of both
@@ -9,7 +9,7 @@ import { Node } from "../../index.js";
  *
  * @internal
  */
-export function lowestCommonAncestor(node1, node2, options = Node.Traversal.empty) {
+export function lowestCommonAncestor(node1, node2, options = BaseNode.Traversal.empty) {
     return node1
         .inclusiveAncestors(options)
         .reverse()

package/dist/node/type.d.ts

@@ -1,11 +1,11 @@
 import { Option } from "@siteimprove/alfa-option";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import * as json from "@siteimprove/alfa-json";
-import { Node } from "../node.js";
+import { BaseNode } from "./node.js";
 /**
  * @public
  */
-export declare class Type<N extends string = string> extends Node<"type"> {
+export declare class Type<N extends string = string> extends BaseNode<"type"> {
     static of<N extends string = string>(name: N, publicId?: Option<string>, systemId?: Option<string>, externalId?: string, internalId?: string, extraData?: any): Type<N>;
     static empty(): Type;
     private readonly _name;
@@ -15,19 +15,19 @@ export declare class Type<N extends string = string> extends Node<"type"> {
     get name(): N;
     get publicId(): Option<string>;
     get systemId(): Option<string>;
-    toJSON(options: Node.SerializationOptions & {
+    toJSON(options: BaseNode.SerializationOptions & {
         verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
     }): Type.MinimalJSON;
-    toJSON(options?: Node.SerializationOptions): Type.JSON<N>;
+    toJSON(options?: BaseNode.SerializationOptions): Type.JSON<N>;
     toString(): string;
 }
 /**
  * @public
  */
 export declare namespace Type {
-    interface MinimalJSON extends Node.JSON<"type"> {
+    interface MinimalJSON extends BaseNode.JSON<"type"> {
     }
-    interface JSON<N extends string = string> extends Node.JSON<"type"> {
+    interface JSON<N extends string = string> extends BaseNode.JSON<"type"> {
         name: N;
         publicId: string | null;
         systemId: string | null;
@@ -37,9 +37,5 @@ export declare namespace Type {
      * @internal
      */
     function fromType<N extends string = string>(json: JSON<N>): Trampoline<Type<N>>;
-    /**
-     * @internal
-     */
-    function cloneType<N extends string = string>(type: Type<N>): Trampoline<Type<N>>;
 }
 //# sourceMappingURL=type.d.ts.map

package/dist/node/type.js

@@ -1,11 +1,11 @@
 import { None, Option } from "@siteimprove/alfa-option";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import * as json from "@siteimprove/alfa-json";
-import { Node } from "../node.js";
+import { BaseNode } from "./node.js";
 /**
  * @public
  */
-export class Type extends Node {
+export class Type extends BaseNode {
     static of(name, publicId = None, systemId = None, externalId, internalId, extraData) {
         return new Type(name, publicId, systemId, externalId, internalId, extraData);
     }
@@ -63,12 +63,5 @@ export class Type extends Node {
         return Trampoline.done(Type.of(json.name, Option.from(json.publicId), Option.from(json.systemId), json.externalId, json.internalId));
     }
     Type.fromType = fromType;
-    /**
-     * @internal
-     */
-    function cloneType(type) {
-        return Trampoline.done(Type.of(type.name, type.publicId, type.systemId, type.externalId, type.internalId));
-    }
-    Type.cloneType = cloneType;
 })(Type || (Type = {}));
 //# sourceMappingURL=type.js.map

package/dist/style/declaration.d.ts

@@ -2,8 +2,8 @@ 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 type { Element } from "../node/element.js";
-import type { Rule } from "./rule.js";
+import type { Element } from "../node/slotable/element.js";
+import type { Rule } from "./rule/index.js";
 /**
  * @public
  */

package/dist/style/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./block.js";
+export * from "./declaration.js";
+export * from "./rule/index.js";
+export * from "./sheet.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/style/index.js

@@ -0,0 +1,5 @@
+export * from "./block.js";
+export * from "./declaration.js";
+export * from "./rule/index.js";
+export * from "./sheet.js";
+//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,4 @@
-import type { Rule } from "../rule.js";
+import type { Rule } from "./index.js";
 import { GroupingRule } from "./grouping.js";
 /**
  * @public

package/dist/style/rule/font-face.d.ts

@@ -1,11 +1,11 @@
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import { Block } from "../block.js";
 import type { Declaration } from "../declaration.js";
-import { Rule } from "../rule.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export declare class FontFaceRule extends Rule<"font-face"> {
+export declare class FontFaceRule extends BaseRule<"font-face"> {
     static of(declarations: Iterable<Declaration>): FontFaceRule;
     private readonly _style;
     protected constructor(declarations: Array<Declaration>);
@@ -17,7 +17,7 @@ export declare class FontFaceRule extends Rule<"font-face"> {
  * @public
  */
 export declare namespace FontFaceRule {
-    interface JSON extends Rule.JSON<"font-face"> {
+    interface JSON extends BaseRule.JSON<"font-face"> {
         style: Block.JSON | string;
     }
     function isFontFaceRule(value: unknown): value is FontFaceRule;

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

@@ -1,11 +1,11 @@
 import { String } from "@siteimprove/alfa-string";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import { Block } from "../block.js";
-import { Rule } from "../rule.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export class FontFaceRule extends Rule {
+export class FontFaceRule extends BaseRule {
     static of(declarations) {
         return new FontFaceRule(Array.from(declarations));
     }

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

@@ -1,9 +1,10 @@
 import { Array } from "@siteimprove/alfa-array";
-import { Rule } from "../rule.js";
+import type { Rule } from "./index.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export declare abstract class GroupingRule<T extends string = string> extends Rule<T> {
+export declare abstract class GroupingRule<T extends string = string> extends BaseRule<T> {
     protected readonly _rules: Array<Rule>;
     protected constructor(type: T, rules: Array<Rule>);
     get rules(): Iterable<Rule>;
@@ -14,7 +15,7 @@ export declare abstract class GroupingRule<T extends string = string> extends Ru
  * @public
  */
 export declare namespace GroupingRule {
-    interface JSON<T extends string = string> extends Rule.JSON<T> {
+    interface JSON<T extends string = string> extends BaseRule.JSON<T> {
         rules: Array<Rule.JSON>;
     }
     function isGroupingRule(value: unknown): value is GroupingRule;

package/dist/style/rule/grouping.js

@@ -1,9 +1,9 @@
 import { Array } from "@siteimprove/alfa-array";
-import { Rule } from "../rule.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export class GroupingRule extends Rule {
+export class GroupingRule extends BaseRule {
     _rules;
     constructor(type, rules) {
         super(type);

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

@@ -4,8 +4,8 @@ import { Iterable } from "@siteimprove/alfa-iterable";
 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 type { Rule } from "./index.js";
+import type { Sheet } from "../sheet.js";
 import { ConditionRule } from "./condition.js";
 /**
  * @public
@@ -43,6 +43,6 @@ export declare namespace ImportRule {
     /**
      * @internal
      */
-    function fromImportRule(json: JSON): Trampoline<ImportRule>;
+    function fromImportRule(json: JSON, fromRule: (json: Rule.JSON) => Trampoline<Rule>, sheetFactory: (rules: Iterable<Rule>) => Sheet): Trampoline<ImportRule>;
 }
 //# sourceMappingURL=import.d.ts.map

package/dist/style/rule/import.js

@@ -4,8 +4,6 @@ import { Iterable } from "@siteimprove/alfa-iterable";
 import { None, 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";
 const { and } = Predicate;
 /**
@@ -108,8 +106,8 @@ export class ImportRule extends ConditionRule {
     /**
      * @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)));
+    function fromImportRule(json, fromRule, sheetFactory) {
+        return Trampoline.traverse(json.rules, fromRule).map((rules) => ImportRule.of(json.href, sheetFactory(rules), Option.of(json.condition), Option.from(json.supportText), Option.from(json.layer)));
     }
     ImportRule.fromImportRule = fromImportRule;
 })(ImportRule || (ImportRule = {}));

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

@@ -0,0 +1,65 @@
+import type { Trampoline } from "@siteimprove/alfa-trampoline";
+import type { Sheet } from "../sheet.js";
+import { FontFaceRule } from "./font-face.js";
+import { GroupingRule } from "./grouping.js";
+import { ImportRule } from "./import.js";
+import { KeyframeRule } from "./keyframe.js";
+import { KeyframesRule } from "./keyframes.js";
+import { Layer as LayerRules } from "./layer.js";
+import { MediaRule } from "./media.js";
+import { NamespaceRule } from "./namespace.js";
+import { PageRule } from "./page.js";
+import { StyleRule } from "./style.js";
+import { SupportsRule } from "./supports.js";
+/**
+ * @public
+ */
+export type Rule = Rule.FontFace | Rule.Grouping | Rule.Import | Rule.Keyframe | Rule.Keyframes | Rule.Layer.Block | Rule.Layer.Statement | Rule.Media | Rule.Namespace | Rule.Page | Rule.Style | Rule.Supports;
+/**
+ * @public
+ */
+export declare namespace Rule {
+    export import FontFace = FontFaceRule;
+    export import Grouping = GroupingRule;
+    export import Import = ImportRule;
+    export import Keyframe = KeyframeRule;
+    export import Keyframes = KeyframesRule;
+    namespace Layer {
+        export import Block = LayerRules.BlockRule;
+        export import Statement = LayerRules.StatementRule;
+    }
+    export import Media = MediaRule;
+    export import Namespace = NamespaceRule;
+    export import Page = PageRule;
+    export import Style = StyleRule;
+    export import Supports = SupportsRule;
+    type JSON = FontFace.JSON | Grouping.JSON | Import.JSON | Keyframe.JSON | Keyframes.JSON | Layer.Block.JSON | Layer.Statement.JSON | Media.JSON | Namespace.JSON | Page.JSON | Style.JSON | Supports.JSON;
+    const fontFace: typeof FontFace.of, isFontFaceRule: typeof FontFace.isFontFaceRule;
+    const importRule: typeof Import.of, isImportRule: typeof Import.isImportRule;
+    const keyframe: typeof Keyframe.of, isKeyframeRule: typeof Keyframe.isKeyframeRule;
+    const keyframes: typeof Keyframes.of, isKeyframesRule: typeof Keyframes.isKeyframesRule;
+    const layerBlock: typeof LayerRules.BlockRule.of, isLayerBlockRule: typeof LayerRules.BlockRule.isLayerBlockRule;
+    const layerStatement: typeof LayerRules.StatementRule.of, isLayerStatementRule: typeof LayerRules.StatementRule.isLayerStatementRule;
+    const media: typeof Media.of, isMediaRule: typeof Media.isMediaRule;
+    const namespace: typeof Namespace.of, isNamespaceRule: typeof Namespace.isNamespaceRule;
+    const page: typeof Page.of, isPageRule: typeof Page.isPageRule;
+    const style: typeof Style.of, isStyleRule: typeof Style.isStyleRule;
+    const supports: typeof Supports.of, isSupportsRule: typeof Supports.isSupportsRule;
+    function from(json: FontFace.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): FontFace;
+    function from(json: Import.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Import;
+    function from(json: Keyframe.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Keyframe;
+    function from(json: Keyframes.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Keyframes;
+    function from(json: Layer.Block.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Layer.Block;
+    function from(json: Layer.Statement.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Layer.Statement;
+    function from(json: Media.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Media;
+    function from(json: Namespace.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Namespace;
+    function from(json: Page.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Page;
+    function from(json: Style.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Style;
+    function from(json: Supports.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Supports;
+    function from(json: Rule.JSON, sheetFactory: (rules: Iterable<Rule>) => Sheet): Rule;
+    /**
+     * @internal
+     */
+    function fromRule(sheetFactory: (rules: Iterable<Rule>) => Sheet): (json: Rule.JSON) => Trampoline<Rule>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/style/rule/index.js

@@ -0,0 +1,83 @@
+import { FontFaceRule } from "./font-face.js";
+import { GroupingRule } from "./grouping.js";
+import { ImportRule } from "./import.js";
+import { KeyframeRule } from "./keyframe.js";
+import { KeyframesRule } from "./keyframes.js";
+import { Layer as LayerRules } from "./layer.js";
+import { MediaRule } from "./media.js";
+import { NamespaceRule } from "./namespace.js";
+import { PageRule } from "./page.js";
+import { StyleRule } from "./style.js";
+import { SupportsRule } from "./supports.js";
+/**
+ * @public
+ */
+export var Rule;
+(function (Rule) {
+    var _a, _b;
+    Rule.FontFace = FontFaceRule;
+    Rule.Grouping = GroupingRule;
+    Rule.Import = ImportRule;
+    Rule.Keyframe = KeyframeRule;
+    Rule.Keyframes = KeyframesRule;
+    let Layer;
+    (function (Layer) {
+        Layer.Block = LayerRules.BlockRule;
+        Layer.Statement = LayerRules.StatementRule;
+    })(Layer = Rule.Layer || (Rule.Layer = {}));
+    Rule.Media = MediaRule;
+    Rule.Namespace = NamespaceRule;
+    Rule.Page = PageRule;
+    Rule.Style = StyleRule;
+    Rule.Supports = SupportsRule;
+    Rule.fontFace = Rule.FontFace.of, Rule.isFontFaceRule = Rule.FontFace.isFontFaceRule;
+    Rule.importRule = Rule.Import.of, Rule.isImportRule = Rule.Import.isImportRule;
+    Rule.keyframe = Rule.Keyframe.of, Rule.isKeyframeRule = Rule.Keyframe.isKeyframeRule;
+    Rule.keyframes = Rule.Keyframes.of, Rule.isKeyframesRule = Rule.Keyframes.isKeyframesRule;
+    _a = Layer.Block, Rule.layerBlock = _a.of, Rule.isLayerBlockRule = _a.isLayerBlockRule;
+    _b = Layer.Statement, Rule.layerStatement = _b.of, Rule.isLayerStatementRule = _b.isLayerStatementRule;
+    Rule.media = Rule.Media.of, Rule.isMediaRule = Rule.Media.isMediaRule;
+    Rule.namespace = Rule.Namespace.of, Rule.isNamespaceRule = Rule.Namespace.isNamespaceRule;
+    Rule.page = Rule.Page.of, Rule.isPageRule = Rule.Page.isPageRule;
+    Rule.style = Rule.Style.of, Rule.isStyleRule = Rule.Style.isStyleRule;
+    Rule.supports = Rule.Supports.of, Rule.isSupportsRule = Rule.Supports.isSupportsRule;
+    function from(json, sheetFactory) {
+        return fromRule(sheetFactory)(json).run();
+    }
+    Rule.from = from;
+    /**
+     * @internal
+     */
+    function fromRule(sheetFactory) {
+        return function from(json) {
+            switch (json.type) {
+                case "font-face":
+                    return Rule.FontFace.fromFontFaceRule(json);
+                case "import":
+                    return Rule.Import.fromImportRule(json, from, sheetFactory);
+                case "keyframe":
+                    return Rule.Keyframe.fromKeyframeRule(json);
+                case "keyframes":
+                    return Rule.Keyframes.fromKeyframesRule(json, from);
+                case "layer-block":
+                    return Layer.Block.fromLayerBlockRule(json, from);
+                case "layer-statement":
+                    return Layer.Statement.fromLayerStatementRule(json);
+                case "media":
+                    return Rule.Media.fromMediaRule(json, from);
+                case "namespace":
+                    return Rule.Namespace.fromNamespaceRule(json);
+                case "page":
+                    return Rule.Page.fromPageRule(json);
+                case "style":
+                    return Rule.Style.fromStyleRule(json);
+                case "supports":
+                    return Rule.Supports.fromSupportsRule(json, from);
+                default:
+                    throw new Error(`Unexpected rule of type: ${json.type}`);
+            }
+        };
+    }
+    Rule.fromRule = fromRule;
+})(Rule || (Rule = {}));
+//# sourceMappingURL=index.js.map

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

@@ -1,11 +1,11 @@
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import { Block } from "../block.js";
 import type { Declaration } from "../declaration.js";
-import { Rule } from "../rule.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export declare class KeyframeRule extends Rule<"keyframe"> {
+export declare class KeyframeRule extends BaseRule<"keyframe"> {
     static of(key: string, declarations: Iterable<Declaration>): KeyframeRule;
     private readonly _key;
     private readonly _style;
@@ -19,7 +19,7 @@ export declare class KeyframeRule extends Rule<"keyframe"> {
  * @public
  */
 export declare namespace KeyframeRule {
-    interface JSON extends Rule.JSON<"keyframe"> {
+    interface JSON extends BaseRule.JSON<"keyframe"> {
         key: string;
         style: Block.JSON | string;
     }

package/dist/style/rule/keyframe.js

@@ -1,11 +1,11 @@
 import { String } from "@siteimprove/alfa-string";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
 import { Block } from "../block.js";
-import { Rule } from "../rule.js";
+import { BaseRule } from "./rule.js";
 /**
  * @public
  */
-export class KeyframeRule extends Rule {
+export class KeyframeRule extends BaseRule {
     static of(key, declarations) {
         return new KeyframeRule(key, Array.from(declarations));
     }

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

@@ -1,5 +1,5 @@
 import { Trampoline } from "@siteimprove/alfa-trampoline";
-import { Rule } from "../rule.js";
+import type { Rule } from "./index.js";
 import { GroupingRule } from "./grouping.js";
 /**
  * @public
@@ -23,6 +23,6 @@ export declare namespace KeyframesRule {
     /**
      * @internal
      */
-    function fromKeyframesRule(json: JSON): Trampoline<KeyframesRule>;
+    function fromKeyframesRule(json: JSON, fromRule: (json: Rule.JSON) => Trampoline<Rule>): Trampoline<KeyframesRule>;
 }
 //# sourceMappingURL=keyframes.d.ts.map

package/dist/style/rule/keyframes.js

@@ -1,6 +1,5 @@
 import { String } from "@siteimprove/alfa-string";
 import { Trampoline } from "@siteimprove/alfa-trampoline";
-import { Rule } from "../rule.js";
 import { GroupingRule } from "./grouping.js";
 /**
  * @public
@@ -41,8 +40,8 @@ export class KeyframesRule extends GroupingRule {
     /**
      * @internal
      */
-    function fromKeyframesRule(json) {
-        return Trampoline.traverse(json.rules, Rule.fromRule).map((rules) => KeyframesRule.of(json.name, rules));
+    function fromKeyframesRule(json, fromRule) {
+        return Trampoline.traverse(json.rules, fromRule).map((rules) => KeyframesRule.of(json.name, rules));
     }
     KeyframesRule.fromKeyframesRule = fromKeyframesRule;
 })(KeyframesRule || (KeyframesRule = {}));