@siteimprove/alfa-dom 0.89.2

package/CHANGELOG.md

@@ -0,0 +1,291 @@
+# @siteimprove/alfa-dom
+
+## 0.89.2
+
+### Patch Changes
+
+- **Changed:** Trying to fix a problem in generating provenance statements ([#1674](https://github.com/Siteimprove/alfa/pull/1674))
+
+## 0.89.1
+
+### Patch Changes
+
+- **Added:** Trying to publish Alfa packages on the npm registry ([#1673](https://github.com/Siteimprove/alfa/pull/1673))
+
+## 0.89.0
+
+## 0.88.0
+
+### Minor Changes
+
+- **Fixed:** The publish flow was updated to a new version. ([`a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2`](https://github.com/Siteimprove/alfa/commit/a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2))
+
+  Some 0.87.\* versions were generating uninstallable package. This should be fixed now.
+
+## 0.87.12
+
+## 0.87.11
+
+## 0.87.10
+
+## 0.87.7
+
+## 0.87.6
+
+## 0.87.5
+
+## 0.87.4
+
+## 0.87.3
+
+### Patch Changes
+
+- **Fixed:** Workaround for when adopted style sheets are missing has been added. ([#1656](https://github.com/Siteimprove/alfa/pull/1656))
+
+## 0.87.2
+
+## 0.87.1
+
+## 0.87.0
+
+### Minor Changes
+
+- **Added:** A new function `getInclusiveElementDescendants` was added to the `Query` namespace. ([#1651](https://github.com/Siteimprove/alfa/pull/1651))
+
+- **Breaking:** Optional serialization type parameters have been removed. ([#1651](https://github.com/Siteimprove/alfa/pull/1651))
+
+- **Added:** `Element` serialised with high verbosity now include the serialisation ID of their assigned slot, if any. ([#1651](https://github.com/Siteimprove/alfa/pull/1651))
+
+  This help de-serialise the shadow trees for tools that do not want to re-compute slot assignement.
+
+## 0.86.2
+
+## 0.86.1
+
+## 0.86.0
+
+### Minor Changes
+
+- **Breaking:** TS resolution has been changed to `Node16`, target to `es2022`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+- **Breaking:** Alfa is now distributed as ESM rather than CJS modules; projects using it must be ESM or use dynamic `import()`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+  ⚠️ This is the last of a series of changes on the internal structure and build process of distributed packages that was started with v0.85.0.
+
+## 0.85.1
+
+## 0.85.0
+
+### Minor Changes
+
+- **Breaking:** The .js files are now built in the `dist` folder rather than in `src`. ([#1628](https://github.com/Siteimprove/alfa/pull/1628))
+
+  ⚠️ This is the first of a series of changes on the internal structure and build process of distributed packages. It is probably better to not use this version and wait until more of these internal changes have been done to jump directly to the final result. We are internally releasing these changes for validation purpose only.
+
+  This should not impact consumers, the `package.json` files should be set correctly to consume these files.
+
+## 0.84.0
+
+## 0.83.1
+
+## 0.83.0
+
+## 0.82.0
+
+### Minor Changes
+
+- **Added:** DOM node builders like `Element.of` etc. now optionally accept `serializationId` which will be used when serializing depending on the verbosity chosen. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+  If one is not supplied it will be randomly generated as an UUID.
+
+- **Added:** Verbosity option has been added to JSON serialization of alfa-tree `Node` and to `Outcome` and `Group`. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+- **Breaking:** Node 18 is no longer supported. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+## 0.81.0
+
+### Patch Changes
+
+- **Added:** Each package now contains its internal dependency graph in its `docs` directory. ([#1610](https://github.com/Siteimprove/alfa/pull/1610))
+
+- **Fixed:** `Native.fromWindow` now behaves better in case when injected in content scripts. ([#1619](https://github.com/Siteimprove/alfa/pull/1619))
+
+  Some browsers make content scripts live in different worlds than the actual page. This causes `.constructor.name` to fail when run from the content script on object created in the page (typically, all DOM objects), in turn crashing the CSS rule type detection.
+
+  This introduces a heuristic to catch this case and fall back on other solutions.
+
+## 0.80.0
+
+### Patch Changes
+
+- **Fixed:** `Native.fromNode` now correctly handles sheets without conditions. ([#1608](https://github.com/Siteimprove/alfa/pull/1608))
+
+## 0.79.1
+
+### Patch Changes
+
+- **Fixed:** Correctly encapsulated sub-functions of `Native.fromNode`. ([#1606](https://github.com/Siteimprove/alfa/pull/1606))
+
+## 0.79.0
+
+### Minor Changes
+
+- **Breaking:** `ImportRule.queries` has been renamed `ImportRule.mediaQueries`. ([#1603](https://github.com/Siteimprove/alfa/pull/1603))
+
+  This allows support queries in import rules in a unified naming scheme.
+
+- **Breaking:** `Native.fromNode()` is now asynchronous. ([#1600](https://github.com/Siteimprove/alfa/pull/1600))
+
+  This allows to perform asynchronous operations on the page being scraped.
+
+- **Added:** CSS `import` rules now support `layer`, and `supports` condition. ([#1603](https://github.com/Siteimprove/alfa/pull/1603))
+
+### Patch Changes
+
+- **Added:** `Native.fromNode()` now includes an option to enforce `crossorigin: anonymous` on `<link>` elements missing a CORS. ([#1600](https://github.com/Siteimprove/alfa/pull/1600))
+
+  This can help solve some problems encountered during scraping, when they are tied to missing CORS policy.
+
+- **Fixed:** `Native.fromNode()` now correctly handles CSS shorthands whose value is a `var(…)`. ([#1600](https://github.com/Siteimprove/alfa/pull/1600))
+
+- **Fixed:** Bug where boxes where not being serialized due to device not being passed down when recursing has been fixed. ([#1605](https://github.com/Siteimprove/alfa/pull/1605))
+
+- **Fixed:** `Node.tabOrder()` now correctly inserts shadow tree content in its place, instead of at the start. ([#1599](https://github.com/Siteimprove/alfa/pull/1599))
+
+- **Added:** `Native.fromNode` now parses `@layer` rules. ([#1600](https://github.com/Siteimprove/alfa/pull/1600))
+
+## 0.78.2
+
+## 0.78.1
+
+## 0.78.0
+
+## 0.77.0
+
+## 0.76.0
+
+## 0.75.2
+
+## 0.75.1
+
+## 0.75.0
+
+### Minor Changes
+
+- **Added:** Most CSS conditional rules now have a `.matches(device)` helper, checking against the parsed queries. ([#1581](https://github.com/Siteimprove/alfa/pull/1581))
+
+- **Added:** CSS `@layer` rules are now handled when building cascades. ([#1574](https://github.com/Siteimprove/alfa/pull/1574))
+
+## 0.74.0
+
+## 0.73.0
+
+### Patch Changes
+
+- **Fixed:** Parents of `Comment` inside a shadow tree now correctly skip over the shadow root when traversing the flat tree. ([#1547](https://github.com/Siteimprove/alfa/pull/1547))
+
+- **Fixed:** Nested style rules now correctly get their sheet as owner. ([#1560](https://github.com/Siteimprove/alfa/pull/1560))
+
+- **Fixed:** `Node.toString()` now stops dropping text nodes with only spaces. ([#1566](https://github.com/Siteimprove/alfa/pull/1566))
+
+## 0.72.0
+
+## 0.71.1
+
+## 0.71.0
+
+## 0.70.0
+
+### Minor Changes
+
+- **Added:** New functions `Node.clone` for cloning nodes and optionally replacing child elements based on a predicate. ([#1523](https://github.com/Siteimprove/alfa/pull/1523))
+
+## 0.69.0
+
+### Minor Changes
+
+- **Added:** Tree `Node`, and DOM `Node` can now have an `externalId` (`string`) and some `extraData` (`any`). ([#1498](https://github.com/Siteimprove/alfa/pull/1498))
+
+  These are intended for callers that need to record some extra data during audits and retrieve it afterward. Especially, the `externalId` is intended for callers who already have an identifier for nodes and do not want to lose it during audits, nor maintain a map between these identifiers and Alfa nodes.
+
+  Alfa is guaranteed to never interact with the `extraData` in any way; except that it will be typed as `any`, so any type guard or assertions must be re-applied afterward.
+
+  Alfa may, in the future, decide that `Node` with the same `externalId` can be identified in some way, e.g., because they represent two versions of the same object that were turned into two different Alfa object. This can for example happen when two copies of the same page in different states (e.g., different tab opened) are audited; this creates two Alfa `Document`, but the external caller may have the extra knowledge that some of the nodes should be identified.
+
+  It is up to the callers to ensure that the `externalId` are unique, since they are meant to carry knowledge that Alfa cannot infer.
+
+  The `externalId`, if any, is included in the serialisation of nodes. The `extraData` is never included because Alfa does not ensure it is serializable (it may contain circular references, …)
+
+  `extraData` can only be provided when building DOM nodes with the `#of` methods, or the `h.*` functions. `externalId` for `Element` can also be provided by a key with the same name in the JSX syntax.
+
+## 0.68.0
+
+### Minor Changes
+
+- **Breaking:** `Element#of` now requires the device used when scraping a page in order to store a box. ([#1474](https://github.com/Siteimprove/alfa/pull/1474))
+
+  This ensures that the boxes of the elements will be stored with and only be accessible for the same device instance. If no device is provided, no box is stored with the element.
+
+- **Added:** `Document#toJSON` now optionally accepts serialization options containing device. ([#1474](https://github.com/Siteimprove/alfa/pull/1474))
+
+  The options will be passed down to all children of the document and used by `Element` to serialize the box corresponding to the device.
+
+## 0.67.0
+
+## 0.66.0
+
+## 0.65.1
+
+## 0.65.0
+
+### Minor Changes
+
+- **Added:** Support for optional `box` everywhere when constructing an `Element`. ([#1440](https://github.com/Siteimprove/alfa/pull/1440))
+
+  Boxes are expected to be the result of `getBoundingClientRect`, i.e. contain adding and border.
+
+  It is up to the caller to ensure that the boxes were generated on the same `Device` that is used for audits. Alfa does not (and cannot) verify this.
+
+  Alfa assumes that the boxes where generated with an empty `Context`. It is up to the caller to ensure that this is the case.
+
+- **Removed:** Many pieces of code are no longer exported. These were mostly internal exports that are no longer used in other files and should not impact intended usage of the packages. ([#1437](https://github.com/Siteimprove/alfa/pull/1437))
+
+- **Breaking:** Renamed public property `rectangle` to `box` which was overlooked in the last version ([#1440](https://github.com/Siteimprove/alfa/pull/1440))
+
+- **Added:** A `Element.hasBox` predicate builder is now available. ([#1450](https://github.com/Siteimprove/alfa/pull/1450))
+
+## 0.64.0
+
+### Minor Changes
+
+- **Added:** Optional `Rectangle` property on `Element`. ([#1427](https://github.com/Siteimprove/alfa/pull/1427))
+
+  The new property can optionally be set when constructing an element, but it doesn't do anything yet.
+
+- **Breaking:** The method `.elementDescendants()` on the classes `Document` and `Node` has been removed. In stead the function `Query.getElementDescendants()` should be used. ([#1425](https://github.com/Siteimprove/alfa/pull/1425))
+
+- **Added:** `Query` namespace with functions for querying element descendants and elements by id. ([#1413](https://github.com/Siteimprove/alfa/pull/1413))
+
+  The result of the queries are cached.
+
+## 0.63.3
+
+## 0.63.2
+
+## 0.63.1
+
+## 0.63.0
+
+### Minor Changes
+
+- **Breaking:** `hasUniqueId` is now directly a `Predicate` ([#1408](https://github.com/Siteimprove/alfa/pull/1408))
+
+  It used to a be `() => Predicate`, the useless void parameter has now been removed. To migrate, simply replace any call to `hasUniqueId()` by `hasUniqueId` (remove the useless empty parameter).
+
+- **Added:** `hasTabIndex` now also accepts number values ([#1409](https://github.com/Siteimprove/alfa/pull/1409))
+
+  `hasTabIndex` accepts numbers and will be satisfied if the tabindex is any of these numbers. It still alternatively accepts a `Predicate<number>`.
+
+## 0.62.2
+
+## 0.62.1

package/dist/h.d.ts

@@ -0,0 +1,37 @@
+import { Device } from "@siteimprove/alfa-device";
+import type { Rectangle } from "@siteimprove/alfa-rectangle";
+import type { Node, Rule } from "./index.js";
+import { Attribute, Block, Declaration, Document, Element, FontFaceRule, Fragment, ImportRule, Layer, KeyframeRule, KeyframesRule, MediaRule, Namespace, NamespaceRule, PageRule, Shadow, Sheet, StyleRule, SupportsRule, Text, Type } from "./index.js";
+/**
+ * @public
+ */
+export declare function h<N extends string = string>(name: N, attributes?: Array<Attribute> | Record<string, string | boolean>, children?: Array<Node | string>, style?: Array<Declaration> | Record<string, string>, box?: Rectangle, device?: Device, externalId?: string, serializationId?: string, extraData?: any): Element<N>;
+/**
+ * @public
+ */
+export declare namespace h {
+    function element<N extends string = string>(name: N, attributes?: Array<Attribute> | Record<string, string | boolean>, children?: Array<Node | string>, style?: Array<Declaration> | Record<string, string>, namespace?: Namespace, box?: Rectangle, device?: Device, externalId?: string, serializationId?: string, extraData?: any): Element<N>;
+    function attribute<N extends string = string>(name: N, value: string, externalId?: string, serializationId?: string, extraData?: any): Attribute<N>;
+    function text(data: string, externalId?: string, serializationId?: string, extraData?: any): Text;
+    function document(children: Array<Node | string>, style?: Array<Sheet>, externalId?: string, serializationId?: string, extraData?: any): Document;
+    function shadow(children: Array<Node | string>, style?: Array<Sheet>, mode?: Shadow.Mode, externalId?: string, serializationId?: string, extraData?: any): Shadow;
+    function type<N extends string = string>(name: N, publicId?: string, systemId?: string, externalId?: string, serializationId?: string, extraData?: any): Type<N>;
+    function fragment(children: Array<Node | string>, externalId?: string, extraData?: any): Fragment;
+    function sheet(rules: Array<Rule>, disabled?: boolean, condition?: string): Sheet;
+    function block(declarations: Array<Declaration> | Record<string, string>): Block;
+    function declaration(name: string, value: string, important?: boolean): Declaration;
+    namespace rule {
+        function fontFace(declarations: Array<Declaration> | Record<string, string>): FontFaceRule;
+        function importRule(url: string, sheet: Sheet, mediaCondition?: string, supportCondition?: string, layer?: string): ImportRule;
+        function keyframe(key: string, declarations: Array<Declaration> | Record<string, string>): KeyframeRule;
+        function keyframes(name: string, rules: Array<Rule>): KeyframesRule;
+        function layerBlock(rules: Array<Rule>, layer?: string): Layer.BlockRule;
+        function layerStatement(layers: Array<string>): Layer.StatementRule;
+        function media(condition: string, rules: Array<Rule>): MediaRule;
+        function namespace(namespace: string, prefix?: string): NamespaceRule;
+        function page(selector: string, declarations: Array<Declaration> | Record<string, string>): PageRule;
+        function style(selector: string, declarations: Array<Declaration> | Record<string, string>, hint?: boolean): StyleRule;
+        function supports(condition: string, rules: Array<Rule>): SupportsRule;
+    }
+}
+//# sourceMappingURL=h.d.ts.map

package/dist/h.js

@@ -0,0 +1,214 @@
+import { None, Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Device } from "@siteimprove/alfa-device";
+import { Attribute, Block, Declaration, Document, Element, FontFaceRule, Fragment, ImportRule, Layer, KeyframeRule, KeyframesRule, MediaRule, Namespace, NamespaceRule, PageRule, Shadow, Sheet, StyleRule, SupportsRule, Text, Type, } from "./index.js";
+const { entries } = Object;
+const { nor } = Predicate;
+/**
+ * @public
+ */
+export function h(name, attributes, children, style, box, device = Device.standard(), externalId, serializationId, extraData) {
+    return h.element(name, attributes, children, style, undefined, box, device, externalId, serializationId, extraData);
+}
+/**
+ * @public
+ */
+(function (h) {
+    function element(name, attributes = [], children = [], style = [], namespace, box, device, externalId, serializationId, extraData) {
+        attributes = Array.isArray(attributes)
+            ? attributes
+            : entries(attributes).reduce((attributes, [name, value]) => {
+                if (value === false) {
+                    return attributes;
+                }
+                return [
+                    ...attributes,
+                    h.attribute(hyphenate(name), value === true ? "" : value),
+                ];
+            }, []);
+        const block = h.block(style);
+        if (block.size > 0) {
+            attributes = [...attributes, h.attribute("style", block.toString())];
+        }
+        namespace =
+            namespace ??
+                Option.from(attributes.find((attribute) => attribute.name === "xmlns"))
+                    .map((attribute) => attribute.value)
+                    .filter(Namespace.isNamespace)
+                    .getOr(defaultNamespace(name));
+        const content = children.find(Document.isDocument);
+        const shadow = children.find(Shadow.isShadow);
+        const element = Element.of(Option.of(namespace), None, name, attributes, children
+            .filter(nor(Document.isDocument, Shadow.isShadow))
+            .map((child) => (typeof child === "string" ? h.text(child) : child)), (Array.isArray(style) && style.length === 0) ||
+            Object.keys(style).length === 0
+            ? None
+            : Option.of(block), Option.from(box), Option.from(device), externalId, serializationId, extraData);
+        if (content !== undefined) {
+            element._attachContent(content);
+        }
+        if (shadow !== undefined) {
+            element._attachShadow(shadow);
+        }
+        return element;
+    }
+    h.element = element;
+    function attribute(name, value, externalId, serializationId, extraData) {
+        return Attribute.of(None, None, name, value, externalId, serializationId, extraData);
+    }
+    h.attribute = attribute;
+    function text(data, externalId, serializationId, extraData) {
+        return Text.of(data, externalId, serializationId, extraData);
+    }
+    h.text = text;
+    function document(children, style, externalId, serializationId, extraData) {
+        return Document.of(children.map((child) => typeof child === "string" ? text(child) : child), style, externalId, serializationId, extraData);
+    }
+    h.document = document;
+    function shadow(children, style, mode, externalId, serializationId, extraData) {
+        return Shadow.of(children.map((child) => typeof child === "string" ? text(child) : child), style, mode, externalId, serializationId, extraData);
+    }
+    h.shadow = shadow;
+    function type(name, publicId, systemId, externalId, serializationId, extraData) {
+        return Type.of(name, Option.from(publicId), Option.from(systemId), externalId, serializationId, extraData);
+    }
+    h.type = type;
+    function fragment(children, externalId, extraData) {
+        return Fragment.of(children.map((child) => typeof child === "string" ? text(child) : child), externalId, extraData);
+    }
+    h.fragment = fragment;
+    function sheet(rules, disabled, condition) {
+        return Sheet.of(rules, disabled, Option.from(condition));
+    }
+    h.sheet = sheet;
+    function block(declarations) {
+        return Block.of(Array.isArray(declarations)
+            ? declarations
+            : entries(declarations).map(([name, value]) => {
+                const important = value.endsWith("!important");
+                value = value.replace(/!important$/, "").trim();
+                // Hyphenate the declaration name unless it's the name of a custom
+                // property; these we keep as-is.
+                if (!name.startsWith("--")) {
+                    name = hyphenate(name);
+                }
+                return Declaration.of(name, value, important);
+            }));
+    }
+    h.block = block;
+    function declaration(name, value, important) {
+        return Declaration.of(name, value, important);
+    }
+    h.declaration = declaration;
+    let rule;
+    (function (rule) {
+        function fontFace(declarations) {
+            return FontFaceRule.of(block(declarations));
+        }
+        rule.fontFace = fontFace;
+        function importRule(url, sheet, mediaCondition, supportCondition, 
+        // Use "" for anonymous layer.
+        layer) {
+            return ImportRule.of(url, sheet, Option.from(mediaCondition), Option.from(supportCondition), Option.from(layer));
+        }
+        rule.importRule = importRule;
+        function keyframe(key, declarations) {
+            return KeyframeRule.of(key, block(declarations));
+        }
+        rule.keyframe = keyframe;
+        function keyframes(name, rules) {
+            return KeyframesRule.of(name, rules);
+        }
+        rule.keyframes = keyframes;
+        function layerBlock(rules, layer) {
+            return Layer.BlockRule.of(rules, layer);
+        }
+        rule.layerBlock = layerBlock;
+        function layerStatement(layers) {
+            return Layer.StatementRule.of(layers);
+        }
+        rule.layerStatement = layerStatement;
+        function media(condition, rules) {
+            return MediaRule.of(condition, rules);
+        }
+        rule.media = media;
+        function namespace(namespace, prefix) {
+            return NamespaceRule.of(namespace, Option.from(prefix));
+        }
+        rule.namespace = namespace;
+        function page(selector, declarations) {
+            return PageRule.of(selector, block(declarations));
+        }
+        rule.page = page;
+        function style(selector, declarations, hint) {
+            return StyleRule.of(selector, block(declarations), hint);
+        }
+        rule.style = style;
+        function supports(condition, rules) {
+            return SupportsRule.of(condition, rules);
+        }
+        rule.supports = supports;
+    })(rule = h.rule || (h.rule = {}));
+})(h || (h = {}));
+function hyphenate(value) {
+    return value.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function defaultNamespace(name) {
+    switch (name) {
+        // The <a> element exists both in SVG and HTML namespaces.
+        // It is defaulted in the HTML namespace and must be explicitly built in
+        // the SVG one if needed.
+        case "circle":
+        case "ellipse":
+        case "foreignObject":
+        case "g":
+        case "image":
+        case "line":
+        case "mesh":
+        case "path":
+        case "polygon":
+        case "polyline":
+        case "rect":
+        case "svg":
+        case "symbol":
+        case "text":
+        case "textPath":
+        case "use":
+            return Namespace.SVG;
+        case "annotation":
+        case "annotation-xml":
+        case "maction":
+        case "math":
+        case "merror":
+        case "mfrac":
+        case "mi":
+        case "mmultiscripts":
+        case "mn":
+        case "mo":
+        case "mover":
+        case "mpadded":
+        case "mphantom":
+        case "mprescripts":
+        case "mroot":
+        case "mrow":
+        case "ms":
+        case "mspace":
+        case "msqrt":
+        case "mstyle":
+        case "msub":
+        case "msubsup":
+        case "msup":
+        case "mtable":
+        case "mtd":
+        case "mtext":
+        case "mtr":
+        case "munder":
+        case "munderover":
+        case "none":
+        case "semantics":
+            return Namespace.MathML;
+        default:
+            return Namespace.HTML;
+    }
+}
+//# sourceMappingURL=h.js.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./namespace.js";
+export * from "./style/block.js";
+export * from "./style/declaration.js";
+export * from "./style/rule.js";
+export * from "./style/rule/grouping.js";
+export * from "./style/rule/condition.js";
+export * from "./style/rule/font-face.js";
+export * from "./style/rule/import.js";
+export * from "./style/rule/keyframe.js";
+export * from "./style/rule/keyframes.js";
+export * from "./style/rule/layer.js";
+export * from "./style/rule/media.js";
+export * from "./style/rule/namespace.js";
+export * from "./style/rule/page.js";
+export * from "./style/rule/style.js";
+export * from "./style/rule/supports.js";
+export * from "./style/sheet.js";
+export * from "./node.js";
+export * from "./node/slot.js";
+export * from "./node/slotable.js";
+export * from "./node/attribute.js";
+export * from "./node/comment.js";
+export * from "./node/document.js";
+export * from "./node/element.js";
+export * from "./node/fragment.js";
+export * from "./node/shadow.js";
+export * from "./node/text.js";
+export * from "./node/type.js";
+export * from "./node/query/index.js";
+export * from "./h.js";
+export * from "./jsx.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,32 @@
+export * from "./namespace.js";
+export * from "./style/block.js";
+export * from "./style/declaration.js";
+export * from "./style/rule.js";
+export * from "./style/rule/grouping.js";
+export * from "./style/rule/condition.js";
+export * from "./style/rule/font-face.js";
+export * from "./style/rule/import.js";
+export * from "./style/rule/keyframe.js";
+export * from "./style/rule/keyframes.js";
+export * from "./style/rule/layer.js";
+export * from "./style/rule/media.js";
+export * from "./style/rule/namespace.js";
+export * from "./style/rule/page.js";
+export * from "./style/rule/style.js";
+export * from "./style/rule/supports.js";
+export * from "./style/sheet.js";
+export * from "./node.js";
+export * from "./node/slot.js";
+export * from "./node/slotable.js";
+export * from "./node/attribute.js";
+export * from "./node/comment.js";
+export * from "./node/document.js";
+export * from "./node/element.js";
+export * from "./node/fragment.js";
+export * from "./node/shadow.js";
+export * from "./node/text.js";
+export * from "./node/type.js";
+export * from "./node/query/index.js";
+export * from "./h.js";
+export * from "./jsx.js";
+//# sourceMappingURL=index.js.map

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "./jsx.js";
+import type { Element } from "./index.js";
+export declare namespace JSX {
+    type Element = _jsx.JSX.Element;
+    interface IntrinsicElements extends _jsx.JSX.IntrinsicElements {
+    }
+}
+/**
+ * @public
+ */
+export declare function jsx<N extends string = string>(name: N, properties: _jsx.Properties & {
+    children?: _jsx.Child;
+}): Element<N>;
+/**
+ * @public
+ */
+export declare function jsxs<N extends string = string>(name: N, properties: _jsx.Properties & {
+    children?: _jsx.Children;
+}): Element<N>;
+/**
+ * @public
+ */
+export declare function jsxDEV<N extends string = string>(name: N, properties: _jsx.Properties & {
+    children?: _jsx.Child | _jsx.Children;
+}): Element<N>;
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist/jsx-runtime.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "./jsx.js";
+/**
+ * @public
+ */
+export function jsx(name, properties) {
+    const { children, ...rest } = properties;
+    if (children === undefined) {
+        return _jsx(name, rest);
+    }
+    else {
+        return _jsx(name, rest, children);
+    }
+}
+/**
+ * @public
+ */
+export function jsxs(name, properties) {
+    const { children, ...rest } = properties;
+    if (children === undefined) {
+        return _jsx(name, rest);
+    }
+    else {
+        return _jsx(name, rest, ...children);
+    }
+}
+/**
+ * @public
+ */
+export function jsxDEV(name, properties) {
+    const { children, ...rest } = properties;
+    if (children === undefined) {
+        return _jsx(name, rest);
+    }
+    else if (Array.isArray(children)) {
+        return _jsx(name, rest, ...children);
+    }
+    else {
+        return _jsx(name, rest, children);
+    }
+}
+//# sourceMappingURL=jsx-runtime.js.map