@siteimprove/alfa-dom 0.112.0 → 0.113.0

package/dist/node/slotable/slot.d.ts

@@ -0,0 +1,21 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Element } from "./element.js";
+import type { Slotable } from "./index.js";
+/** @public */
+export type Slot = Element<"slot">;
+declare module "./element.js" {
+    interface Element<N extends string> {
+        /**
+         * Get the slotables assigned to this slot.
+         *
+         * {@link https://html.spec.whatwg.org/#dom-slot-assignednodes}
+         * {@link https://dom.spec.whatwg.org/#find-slotables}
+         */
+        assignedNodes(this: Slot): Iterable<Slotable>;
+        /**
+         * {@link https://dom.spec.whatwg.org/#slot-name}
+         */
+        slotName(this: Slot): string;
+    }
+}
+//# sourceMappingURL=slot.d.ts.map

package/dist/node/slotable/slot.js

@@ -0,0 +1,23 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Element } from "./element.js";
+import { Shadow } from "../shadow.js";
+import { Slotable as BaseSlotable } from "./slotable.js";
+Element.prototype.assignedNodes = function* () {
+    const root = this.root();
+    if (Shadow.isShadow(root)) {
+        for (const host of root.host) {
+            for (const child of host.children()) {
+                if (BaseSlotable.isSlotable(child) &&
+                    child.assignedSlot().includes(this)) {
+                    yield child;
+                }
+            }
+        }
+    }
+};
+Element.prototype.slotName = function () {
+    return this.attribute("name")
+        .map((name) => name.value)
+        .getOr("");
+};
+//# sourceMappingURL=slot.js.map

package/dist/node/slotable/slotable.d.ts

@@ -0,0 +1,31 @@
+import type { Option } from "@siteimprove/alfa-option";
+import { BaseNode } from "../node.js";
+import type { Slot } from "./slot.js";
+/**
+ * @public
+ */
+export declare abstract class Slotable<T extends string = string> extends BaseNode<T> {
+    /**
+     * Get the slot that this slotable is assigned to.
+     *
+     * {@link https://dom.spec.whatwg.org/#dom-slotable-assignedslot}
+     * {@link https://dom.spec.whatwg.org/#find-a-slot}
+     *
+     * @privateRemarks
+     * While the implementation is the same for Element and Text nodes, it uses
+     * type guards from Element and therefore cannot really live here without
+     * creating circular dependencies.
+     */
+    abstract assignedSlot(): Option<Slot>;
+    /**
+     * {@link https://dom.spec.whatwg.org/#slotable-name}
+     */
+    abstract slotableName(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Slotable {
+    function isSlotable(value: unknown): value is Slotable;
+}
+//# sourceMappingURL=slotable.d.ts.map

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)
@@ -15,7 +15,7 @@ import { Node } from "../../index.js";
  *
  * @public
  */
-export declare function getNodesBetween(node1: Node, node2: Node, includeOptions?: Options, treeOptions?: Node.Traversal): Sequence<Node>;
+export declare function getNodesBetween(defaultTreeOptions: Node.Traversal): (node1: Node, node2: Node, includeOptions?: Options) => Sequence<Node>;
 type Options = {
     includeFirst: boolean;
     includeSecond: boolean;

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

@@ -1,6 +1,5 @@
 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;
 /**
@@ -18,41 +17,43 @@ const { equals, or } = Predicate;
  *
  * @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()) {
+export function getNodesBetween(defaultTreeOptions) {
+    return function getNodes(node1, node2, includeOptions = { includeFirst: false, includeSecond: false }, treeOptions = defaultTreeOptions) {
+        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;
-    }
-    // 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)
+    return lowestCommonAncestor(treeOptions)(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 { BaseNode } from "../node.js";
 /**
  * Find the lowest common ancestor of two nodes:
  * * get the ancestors chain of both
@@ -9,5 +9,5 @@ import { Node } from "../../index.js";
  *
  * @internal
  */
-export declare function lowestCommonAncestor(node1: Node, node2: Node, options?: Node.Traversal): Option<Node>;
+export declare function lowestCommonAncestor(defaultTraversal: BaseNode.Traversal): (node1: BaseNode, node2: BaseNode, options?: BaseNode.Traversal) => Option<BaseNode>;
 //# sourceMappingURL=lowest-common-ancestor.d.ts.map

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

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