elements-kit 0.12.0 → 0.14.0

package/dist/{benchmark.CX_oY03V-CsUg-gW0.mjs → benchmark.CX_oY03V-CSLAXL5f.mjs}

@@ -4099,14 +4099,6 @@ function afterEach(fn, timeout) {
 	};
 	return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 }
-createTestHook("onTestFailed", (test, handler, timeout) => {
-	test.onFailed ||= [];
-	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
-});
-createTestHook("onTestFinished", (test, handler, timeout) => {
-	test.onFinished ||= [];
-	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
-});
 /**
 * Registers a callback function that wraps around all tests within the current suite.
 * The callback receives a `runSuite` function that must be called to run the suite's tests.
@@ -4206,14 +4198,6 @@ function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex
 		})();
 	};
 }
-function createTestHook(name, handler) {
-	return (fn, timeout) => {
-		assertTypes(fn, `"${name}" callback`, ["function"]);
-		const current = getCurrentTest();
-		if (!current) throw new Error(`Hook ${name}() can only be called inside a test`);
-		return handler(current, fn, timeout);
-	};
-}
 function findTestFileStackTrace(testFilePath, error) {
 	const lines = error.split("\n").slice(1);
 	for (const line of lines) {
@@ -4942,7 +4926,7 @@ function makeTimeoutError(isHook, timeout, stackTraceError) {
 }
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-const unixNow = Date.now;
+Date.now;
 const { clearTimeout, setTimeout: setTimeout$1 } = getSafeTimers();
 const packs = /* @__PURE__ */ new Map();
 const eventsPacks = [];
@@ -4969,21 +4953,6 @@ async function finishSendTasksUpdate(runner) {
 	sendTasksUpdate(runner);
 	await Promise.all(pendingTasksUpdates);
 }
-function throttle(fn, ms) {
-	let last = 0;
-	let pendingCall;
-	return function call(...args) {
-		const now = unixNow();
-		if (now - last > ms) {
-			last = now;
-			clearTimeout(pendingCall);
-			pendingCall = void 0;
-			return fn.apply(this, args);
-		}
-		pendingCall ??= setTimeout$1(() => call.bind(this)(...args), ms);
-	};
-}
-throttle(sendTasksUpdate, 100);
 /**
 * @experimental
 * @advanced

package/dist/{element-Y3uP_2p9.mjs → element-D6xVuWdX.mjs}

@@ -1,4 +1,4 @@
-import { c as effectScope, g as untracked, p as onCleanup, s as effect } from "./lib-Cg8fI7K5.mjs";
+import { c as effectScope, g as untracked, p as onCleanup, s as effect } from "./lib-Dkc7cV5F.mjs";
 import "./polyfill-CdZVCxdo.mjs";
 import { isReactive, resolveProps } from "./signals/index.mjs";
 import { on } from "./utilities/event-listener.mjs";
@@ -96,6 +96,116 @@ function svgNamespace(ns) {
 	if (ns === "xlink") return "http://www.w3.org/1999/xlink";
 	if (ns === "xml") return "http://www.w3.org/XML/1998/namespace";
 }
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+/**
+* Tag names that must be created in the SVG namespace. `document.createElement`
+* (no namespace) produces an HTMLUnknownElement for these and the browser
+* won't paint the visual; createElementNS is required. Ambiguous tags that
+* exist in both HTML and SVG (`a`, `script`, `style`, `title`) are deliberately
+* left out and default to HTML — consumers using the SVG variants are rare and
+* can build them imperatively.
+*/
+const SvgElements = new Set([
+	"svg",
+	"g",
+	"path",
+	"circle",
+	"rect",
+	"line",
+	"polyline",
+	"polygon",
+	"ellipse",
+	"defs",
+	"use",
+	"symbol",
+	"text",
+	"tspan",
+	"textPath",
+	"mask",
+	"clipPath",
+	"linearGradient",
+	"radialGradient",
+	"stop",
+	"pattern",
+	"marker",
+	"image",
+	"foreignObject",
+	"switch",
+	"desc",
+	"metadata",
+	"view",
+	"filter",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"set",
+	"mpath"
+]);
+/**
+* Tag names that must be created in the MathML namespace. Same problem as
+* `SvgElements` — `document.createElement("math")` is an HTMLUnknownElement,
+* formulae render only when created via `createElementNS(MATHML_NAMESPACE, …)`.
+*/
+const MathMLElements = new Set([
+	"math",
+	"annotation",
+	"annotation-xml",
+	"maction",
+	"menclose",
+	"merror",
+	"mfenced",
+	"mfrac",
+	"mi",
+	"mmultiscripts",
+	"mn",
+	"mo",
+	"mover",
+	"mpadded",
+	"mphantom",
+	"mprescripts",
+	"mroot",
+	"mrow",
+	"ms",
+	"mspace",
+	"msqrt",
+	"mstyle",
+	"msub",
+	"msubsup",
+	"msup",
+	"mtable",
+	"mtd",
+	"mtext",
+	"mtr",
+	"munder",
+	"munderover",
+	"semantics"
+]);
 const ReservedNameSpaces = new Set([
 	"class",
 	"on",
@@ -412,7 +522,11 @@ function createNodeElement(type, props, ref) {
 	return result;
 }
 function resolveNode(type) {
-	if (typeof type === "string") return document.createElement(type);
+	if (typeof type === "string") {
+		if (SvgElements.has(type)) return document.createElementNS(SVG_NAMESPACE, type);
+		if (MathMLElements.has(type)) return document.createElementNS(MATHML_NAMESPACE, type);
+		return document.createElement(type);
+	}
 	if (type instanceof Element || type instanceof DocumentFragment) return type;
 	return new type();
 }

package/dist/for.mjs

@@ -1,6 +1,6 @@
-import { c as effectScope, g as untracked, h as trigger, m as signal, p as onCleanup, s as effect } from "./lib-Cg8fI7K5.mjs";
+import { c as effectScope, g as untracked, h as trigger, m as signal, p as onCleanup, s as effect } from "./lib-Dkc7cV5F.mjs";
 import "./signals/index.mjs";
-import { n as disposeElement } from "./element-Y3uP_2p9.mjs";
+import { n as disposeElement } from "./element-D6xVuWdX.mjs";
 //#region src/for.ts
 /**
 * Keyed list renderer. See {@link ForProps} for prop details.

package/dist/integrations/react.mjs

@@ -1,6 +1,6 @@
-import { m as signal, s as effect } from "../lib-Cg8fI7K5.mjs";
+import { m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
 import "../signals/index.mjs";
-import { t as scope } from "../scope-De6rSJvq.mjs";
+import { t as scope } from "../scope-CnEvL9Nd.mjs";
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 //#region src/integrations/react.ts
 /**

package/dist/jsx-runtime/index.d.mts

@@ -1,2 +1,2 @@
 import { U as createElement, _ as SlotProps, a as RawProps, b as MaybeReactive, c as ResolveProps, d as ComponentClass, f as ComponentFn, g as JSX, h as Attrs, i as Props, l as Child, m as PropsTarget, n as ElementProps, o as ReactiveProps, p as ComponentInstance, r as MaybeReactiveProps, s as Require, t as ComponentProps, u as Component, v as Fragment } from "../infer-DGtBn6Nm.mjs";
-export { Attrs, Child, Component, ComponentClass, ComponentFn, ComponentInstance, ComponentProps, ElementProps, Fragment, JSX, MaybeReactive, MaybeReactiveProps, Props, PropsTarget, RawProps, ReactiveProps, Require, ResolveProps, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };
+export { Attrs, type Child, type Component, type ComponentClass, type ComponentFn, type ComponentInstance, type ComponentProps, type ElementProps, Fragment, JSX, type MaybeReactive, type MaybeReactiveProps, type Props, type PropsTarget, type RawProps, type ReactiveProps, type Require, type ResolveProps, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/jsx-runtime/index.mjs

@@ -1,4 +1,4 @@
-import { r as mountChild, t as createElement } from "../element-Y3uP_2p9.mjs";
+import { r as mountChild, t as createElement } from "../element-D6xVuWdX.mjs";
 //#region src/jsx-runtime/fragment.ts
 /**
 * Used by the JSX transform for `<>...</>` fragments.

package/dist/{lib-Cg8fI7K5.mjs → lib-Dkc7cV5F.mjs}

@@ -295,12 +295,27 @@ const COMPUTED = Symbol("computed");
 const EFFECT = Symbol("effect");
 const EFFECT_SCOPE = Symbol("effectScope");
 const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	/**
+	* Called by the graph engine when a Mutable+Dirty node needs to recompute.
+	* Dispatches by tagged property:
+	*
+	* - `'getter' in node`     → computed: delegate to `updateComputed`.
+	* - `'currentValue' in node` → signal: delegate to `updateSignal`.
+	* - else                    → effectScope: mark `Mutable` and report
+	*   "changed", so any parent effect re-evaluates as if the scope itself
+	*   propagated.
+	*/
 	update(node) {
 		if ("getter" in node) return updateComputed(node);
 		if ("currentValue" in node) return updateSignal(node);
 		node.flags = 1;
 		return true;
 	},
+	/**
+	* Called when an effect node is notified that one of its deps is dirty.
+	* Inserts the effect into the flush queue in dependency order (parents
+	* before children) so that effects always run in topological order.
+	*/
 	notify(effect) {
 		let insertIndex = queuedLength;
 		let firstInsertedIndex = insertIndex;
@@ -317,6 +332,22 @@ const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactive
 			queued[insertIndex] = left;
 		}
 	},
+	/**
+	* Called when a dep node loses its last subscriber.
+	*
+	* Dispatch by tagged property:
+	*
+	* - **computed** (`'getter' in node`): if it had deps, reset to Dirty so
+	*   it recomputes lazily if a new subscriber appears later. Cleanups
+	*   registered via {@link onCleanup} during the previous run are flushed
+	*   (outside any tracking context). Child effects/scopes created in the
+	*   getter are released in LIFO order via {@link disposeAllDepsInReverse}.
+	* - **signal** (`'currentValue' in node`): no-op. Signals stay live so a
+	*   future subscriber can read the latest value.
+	* - **effect** (`'fn' in node`): cascade-dispose via `effectOper`
+	*   (children first, then own cleanup).
+	* - **effectScope** (else): cascade-dispose via `effectScopeOper`.
+	*/
 	unwatched(node) {
 		if ("getter" in node) {
 			const c = node;

package/dist/render.mjs

@@ -1,4 +1,4 @@
-import { t as scope } from "./scope-De6rSJvq.mjs";
+import { t as scope } from "./scope-CnEvL9Nd.mjs";
 //#region src/render.ts
 /**
 * Mount a node into `target` with a scoped lifetime.

package/dist/{scope-De6rSJvq.mjs → scope-CnEvL9Nd.mjs}

@@ -1,4 +1,4 @@
-import { c as effectScope, g as untracked } from "./lib-Cg8fI7K5.mjs";
+import { c as effectScope, g as untracked } from "./lib-Dkc7cV5F.mjs";
 //#region src/signals/scope.ts
 /**
 * Run `setup` inside a fresh `effectScope`. Returns `[result, stop]`.

package/dist/signals/index.mjs

@@ -1,4 +1,4 @@
-import { a as batch, c as effectScope, d as isEffectScope, f as isSignal, g as untracked, h as trigger, i as SIGNAL, l as isComputed, m as signal, n as EFFECT, o as computed, p as onCleanup, r as EFFECT_SCOPE, s as effect, t as COMPUTED, u as isEffect } from "../lib-Cg8fI7K5.mjs";
+import { a as batch, c as effectScope, d as isEffectScope, f as isSignal, g as untracked, h as trigger, i as SIGNAL, l as isComputed, m as signal, n as EFFECT, o as computed, p as onCleanup, r as EFFECT_SCOPE, s as effect, t as COMPUTED, u as isEffect } from "../lib-Dkc7cV5F.mjs";
 import "../polyfill-CdZVCxdo.mjs";
 //#region src/signals/index.ts
 /**

package/dist/{test.BmQO5GaM-ZC2MPXQb.mjs → test.BmQO5GaM-Ddz9cDxc.mjs}

@@ -1,4 +1,4 @@
-import { A as plugins, C as getCallLastIndex, D as ordinal, E as noop, O as stringify, S as createSimpleStackTrace, T as isObject, _ as getSafeTimers, a as waitForImportsToResolve, b as printDiffOrStringify, d as getNames, g as delay, h as parseSingleStack, i as resetModules, j as y, k as format, m as parseErrorStacktrace, n as getWorkerState, r as isChildProcess, u as getCurrentTest, v as processError, w as getType, x as assertTypes, y as diff } from "./benchmark.CX_oY03V-CsUg-gW0.mjs";
+import { A as plugins, C as getCallLastIndex, D as ordinal, E as noop, O as stringify, S as createSimpleStackTrace, T as isObject, _ as getSafeTimers, a as waitForImportsToResolve, b as printDiffOrStringify, d as getNames, g as delay, h as parseSingleStack, i as resetModules, j as y, k as format, m as parseErrorStacktrace, n as getWorkerState, r as isChildProcess, u as getCurrentTest, v as processError, w as getType, x as assertTypes, y as diff } from "./benchmark.CX_oY03V-CSLAXL5f.mjs";
 //#region node_modules/.pnpm/@vitest+spy@4.1.3/node_modules/@vitest/spy/dist/index.js
 function isMockFunction(fn) {
 	return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction === true;
@@ -997,16 +997,115 @@ function inspect(value, opts = {}) {
 }
 __name(inspect, "inspect");
 var config = {
+	/**
+	* ### config.includeStack
+	*
+	* User configurable property, influences whether stack trace
+	* is included in Assertion error message. Default of false
+	* suppresses stack trace in the error message.
+	*
+	*     chai.config.includeStack = true;  // enable stack on error
+	*
+	* @param {boolean}
+	* @public
+	*/
 	includeStack: false,
+	/**
+	* ### config.showDiff
+	*
+	* User configurable property, influences whether or not
+	* the `showDiff` flag should be included in the thrown
+	* AssertionErrors. `false` will always be `false`; `true`
+	* will be true when the assertion has requested a diff
+	* be shown.
+	*
+	* @param {boolean}
+	* @public
+	*/
 	showDiff: true,
+	/**
+	* ### config.truncateThreshold
+	*
+	* User configurable property, sets length threshold for actual and
+	* expected values in assertion errors. If this threshold is exceeded, for
+	* example for large data structures, the value is replaced with something
+	* like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.
+	*
+	* Set it to zero if you want to disable truncating altogether.
+	*
+	* This is especially userful when doing assertions on arrays: having this
+	* set to a reasonable large value makes the failure messages readily
+	* inspectable.
+	*
+	*     chai.config.truncateThreshold = 0;  // disable truncating
+	*
+	* @param {number}
+	* @public
+	*/
 	truncateThreshold: 40,
+	/**
+	* ### config.useProxy
+	*
+	* User configurable property, defines if chai will use a Proxy to throw
+	* an error when a non-existent property is read, which protects users
+	* from typos when using property-based assertions.
+	*
+	* Set it to false if you want to disable this feature.
+	*
+	*     chai.config.useProxy = false;  // disable use of Proxy
+	*
+	* This feature is automatically disabled regardless of this config value
+	* in environments that don't support proxies.
+	*
+	* @param {boolean}
+	* @public
+	*/
 	useProxy: true,
+	/**
+	* ### config.proxyExcludedKeys
+	*
+	* User configurable property, defines which properties should be ignored
+	* instead of throwing an error if they do not exist on the assertion.
+	* This is only applied if the environment Chai is running in supports proxies and
+	* if the `useProxy` configuration setting is enabled.
+	* By default, `then` and `inspect` will not throw an error if they do not exist on the
+	* assertion object because the `.inspect` property is read by `util.inspect` (for example, when
+	* using `console.log` on the assertion object) and `.then` is necessary for promise type-checking.
+	*
+	*     // By default these keys will not throw an error if they do not exist on the assertion object
+	*     chai.config.proxyExcludedKeys = ['then', 'inspect'];
+	*
+	* @param {Array}
+	* @public
+	*/
 	proxyExcludedKeys: [
 		"then",
 		"catch",
 		"inspect",
 		"toJSON"
 	],
+	/**
+	* ### config.deepEqual
+	*
+	* User configurable property, defines which a custom function to use for deepEqual
+	* comparisons.
+	* By default, the function used is the one from the `deep-eql` package without custom comparator.
+	*
+	*     // use a custom comparator
+	*     chai.config.deepEqual = (expected, actual) => {
+	*         return chai.util.eql(expected, actual, {
+	*             comparator: (expected, actual) => {
+	*                 // for non number comparison, use the default behavior
+	*                 if(typeof expected !== 'number') return null;
+	*                 // allow a difference of 10 between compared numbers
+	*                 return typeof actual === 'number' && Math.abs(actual - expected) < 10
+	*             }
+	*         })
+	*     };
+	*
+	* @param {Function}
+	* @public
+	*/
 	deepEqual: null
 };
 function inspect2(obj, showHidden, depth, colors) {

package/dist/ui/accordion/accordion.css

@@ -0,0 +1,180 @@
+.x-accordion::details-content {
+  content-visibility: hidden;
+  padding-inline: var(--accordion-summary-padding-inline);
+  transition: content-visibility var(--accordion-duration) ease allow-discrete,
+    grid-template-rows var(--accordion-duration) ease,
+    padding-block-start var(--accordion-duration) ease,
+    padding-block-end var(--accordion-duration) ease;
+  grid-template-rows: 0fr;
+  padding-block: 0;
+  display: grid;
+  overflow: clip;
+}
+
+.x-accordion[open]::details-content {
+  content-visibility: visible;
+  grid-template-rows: 1fr;
+  padding-block-start: var(--accordion-summary-padding-block);
+  padding-block-end: var(--accordion-summary-padding-block);
+}
+
+.x-accordion > :not(summary) {
+  min-block-size: 0;
+  overflow: clip;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .x-accordion::details-content {
+    transition: none;
+  }
+}
+
+.x-accordion > summary {
+  cursor: var(--cursor-button);
+  align-items: center;
+  gap: var(--space-2);
+  padding: var(--accordion-summary-padding-block)
+    var(--accordion-summary-padding-inline);
+  font-size: var(--accordion-font-size);
+  color: var(--color-11);
+  -webkit-user-select: none;
+  user-select: none;
+  font-weight: 500;
+  line-height: 1.4;
+  list-style: none;
+  transition: background-color .12s ease-out;
+  display: flex;
+}
+
+.x-accordion > summary::-webkit-details-marker {
+  display: none;
+}
+
+.x-accordion > summary:where(:focus-visible) {
+  outline: 2px solid var(--focus-8);
+  outline-offset: -2px;
+}
+
+.x-accordion:where([data-size="1"]) {
+  --accordion-summary-padding-block: var(--space-2);
+  --accordion-summary-padding-inline: var(--space-3);
+  --accordion-font-size: var(--font-size-2);
+  --accordion-duration: .18s;
+}
+
+.x-accordion:where([data-size="2"]) {
+  --accordion-summary-padding-block: var(--space-3);
+  --accordion-summary-padding-inline: var(--space-4);
+  --accordion-font-size: var(--font-size-3);
+  --accordion-duration: .2s;
+}
+
+.x-accordion:where([data-size="3"]) {
+  --accordion-summary-padding-block: var(--space-4);
+  --accordion-summary-padding-inline: var(--space-5);
+  --accordion-font-size: var(--font-size-4);
+  --accordion-duration: .22s;
+}
+
+.x-accordion:where(:not([data-size])) {
+  --accordion-summary-padding-block: var(--space-3);
+  --accordion-summary-padding-inline: var(--space-4);
+  --accordion-font-size: var(--font-size-3);
+  --accordion-duration: .2s;
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"], [data-variant="soft"]) {
+  border-radius: var(--radius-4);
+  --accordion-summary-bg: transparent;
+  --accordion-summary-hover-bg: var(--base-color-a2);
+  --accordion-body-bg: var(--base-color-a2);
+  overflow: hidden;
+}
+
+:where(.dark, .dark-theme) .x-accordion:where(:not([data-variant]), [data-variant="surface"], [data-variant="soft"]) {
+  --accordion-summary-bg: var(--base-color-a2);
+  --accordion-summary-hover-bg: var(--base-color-a3);
+  --accordion-body-bg: transparent;
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"], [data-variant="soft"]) > summary {
+  background-color: var(--accordion-summary-bg);
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"], [data-variant="soft"])::details-content {
+  background-color: var(--accordion-body-bg);
+}
+
+@media (hover: hover) {
+  .x-accordion:where(:not([data-variant]), [data-variant="surface"], [data-variant="soft"]) > summary:where(:hover) {
+    background-color: var(--accordion-summary-hover-bg);
+  }
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"]) {
+  background-color: var(--color-material, var(--color-surface));
+  border: 1px solid var(--base-color-a5);
+}
+
+.x-accordion:where([data-variant="soft"]) {
+  background-color: var(--color-a2);
+  --accordion-summary-bg: var(--color-a2);
+  --accordion-summary-hover-bg: var(--color-a3);
+  --accordion-body-bg: transparent;
+}
+
+:where(.dark, .dark-theme) .x-accordion:where([data-variant="soft"]) {
+  background-color: var(--color-a2);
+  --accordion-summary-bg: var(--color-a2);
+  --accordion-summary-hover-bg: var(--color-a3);
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"]) + .x-accordion:where(:not([data-variant]), [data-variant="surface"]) {
+  border-start-start-radius: 0;
+  border-start-end-radius: 0;
+  margin-block-start: -1px;
+}
+
+.x-accordion:where(:not([data-variant]), [data-variant="surface"]):has( + .x-accordion:where(:not([data-variant]), [data-variant="surface"])) {
+  border-end-end-radius: 0;
+  border-end-start-radius: 0;
+}
+
+.x-accordion:where([data-variant="soft"]) + .x-accordion:where([data-variant="soft"]) {
+  border-start-start-radius: 0;
+  border-start-end-radius: 0;
+}
+
+.x-accordion:where([data-variant="soft"]):has( + .x-accordion:where([data-variant="soft"])) {
+  border-end-end-radius: 0;
+  border-end-start-radius: 0;
+}
+
+.x-accordion:where([data-variant="borderless"]) > summary {
+  color: var(--color-a11);
+  padding-inline: 0;
+  transition: background-color .12s ease-out, color .12s ease-out;
+}
+
+@media (hover: hover) {
+  .x-accordion:where([data-variant="borderless"]) > summary:where(:hover) {
+    color: var(--color-12);
+  }
+}
+
+.x-accordion:where([data-variant="borderless"][open]) > summary {
+  color: var(--color-12);
+}
+
+.x-accordion:where([data-variant="borderless"])::details-content {
+  padding-inline: 0;
+}
+
+.x-accordion:where([aria-disabled="true"]) {
+  opacity: .6;
+}
+
+.x-accordion:where([aria-disabled="true"]) > summary {
+  pointer-events: none;
+  cursor: var(--cursor-disabled);
+}