fashionable 0.2.0 → 0.4.0

package/dist/query/index.mjs

@@ -1,10 +1,17 @@
 import { t as __exportAll } from "../shared/rolldown-runtime-D7D4PA-g.mjs";
-import { a as prefersColorScheme$1, i as minWidth$1, n as equals$1, o as render$1, r as isMediaQuery$1, t as and$1 } from "../shared/mediaQuery.internal-B6iuMd75.mjs";
+import { a as getMinWidth$1, c as hasMinWidth$1, d as isMediaQuery$1, f as maxWidth$1, h as render$1, i as getMaxWidth$1, l as hasPrefersColorScheme$1, m as prefersColorScheme$1, o as getPrefersColorScheme$1, p as minWidth$1, r as equals$1, s as hasMaxWidth$1, t as and$1 } from "../shared/mediaQuery.internal-CKTmLVxL.mjs";
 //#region src/query/mediaQuery.ts
 var mediaQuery_exports = /* @__PURE__ */ __exportAll({
 	and: () => and,
 	equals: () => equals,
+	getMaxWidth: () => getMaxWidth,
+	getMinWidth: () => getMinWidth,
+	getPrefersColorScheme: () => getPrefersColorScheme,
+	hasMaxWidth: () => hasMaxWidth,
+	hasMinWidth: () => hasMinWidth,
+	hasPrefersColorScheme: () => hasPrefersColorScheme,
 	isMediaQuery: () => isMediaQuery,
+	maxWidth: () => maxWidth,
 	minWidth: () => minWidth,
 	prefersColorScheme: () => prefersColorScheme,
 	render: () => render
@@ -23,8 +30,11 @@ const isMediaQuery = isMediaQuery$1;
 /**
 * Creates a viewport-width lower bound.
 *
+* The result carries the `MinWidth` brand, so `getMinWidth` returns a
+* bare `number` on it and on any conjunction built from it.
+*
 * @param px - The threshold in CSS pixels. Must be a non-negative finite number.
-* @returns A one-feature `MediaQuery`.
+* @returns A one-feature `MediaQuery`, branded `MinWidth`.
 * @throws `Error` when `px` is negative or not finite.
 * @example
 * ```ts
@@ -35,15 +45,139 @@ const isMediaQuery = isMediaQuery$1;
 */
 const minWidth = minWidth$1;
 /**
+* Creates a viewport-width upper bound.
+*
+* The result carries the `MaxWidth` brand, so `getMaxWidth` returns a
+* bare `number` on it and on any conjunction built from it.
+*
+* @param px - The threshold in CSS pixels. Must be a non-negative finite number.
+* @returns A one-feature `MediaQuery`, branded `MaxWidth`.
+* @throws `Error` when `px` is negative or not finite.
+* @example
+* ```ts
+* MediaQuery.render(MediaQuery.maxWidth(1024)) // '(max-width: 1024px)'
+* MediaQuery.render(MediaQuery.maxWidth(1024), { mediaSyntax: 'range' }) // '(width <= 1024px)'
+* ```
+* @since 0.3.0
+*/
+const maxWidth = maxWidth$1;
+/**
 * Creates a `prefers-color-scheme` condition.
 *
+* The result carries the `PrefersColorScheme` brand, so
+* `getPrefersColorScheme` returns a guaranteed scheme on it and on any
+* conjunction built from it.
+*
 * @param scheme - The scheme to match, `'dark'` or `'light'`.
-* @returns A one-feature `MediaQuery`.
+* @returns A one-feature `MediaQuery`, branded `PrefersColorScheme`.
 * @since 0.1.0
 */
 const prefersColorScheme = prefersColorScheme$1;
 const and = and$1;
 /**
+* Gets the query's `min-width` threshold.
+*
+* The return type keys on the `MinWidth` brand. Where the type proves a
+* `min-width` feature is present — `minWidth`'s result, any conjunction
+* keeping its brand, or a query narrowed by `hasMinWidth` — the result is
+* a bare `number`. On any other query it is `number | undefined`.
+*
+* When several `min-width` features stack, the largest threshold is
+* returned — the conjunction's effective lower bound, since every
+* feature must hold.
+*
+* @param query - The query to read.
+* @returns The largest `min-width` threshold in CSS pixels, or `undefined` when an unbranded query carries no `min-width` feature.
+* @example
+* ```ts
+* MediaQuery.getMinWidth(MediaQuery.minWidth(768)) // 768
+* MediaQuery.getMinWidth(MediaQuery.prefersColorScheme('dark')) // undefined
+* MediaQuery.minWidth(768).pipe(
+*   MediaQuery.and(MediaQuery.minWidth(1024)),
+*   MediaQuery.getMinWidth,
+* ) // 1024
+* ```
+* @since 0.3.0
+*/
+const getMinWidth = getMinWidth$1;
+/**
+* Gets the query's `max-width` threshold.
+*
+* The return type keys on the `MaxWidth` brand. Where the type proves a
+* `max-width` feature is present — `maxWidth`'s result, any conjunction
+* keeping its brand, or a query narrowed by `hasMaxWidth` — the result is
+* a bare `number`. On any other query it is `number | undefined`.
+*
+* When several `max-width` features stack, the smallest threshold is
+* returned — the conjunction's effective upper bound, since every
+* feature must hold.
+*
+* @param query - The query to read.
+* @returns The smallest `max-width` threshold in CSS pixels, or `undefined` when an unbranded query carries no `max-width` feature.
+* @example
+* ```ts
+* MediaQuery.getMaxWidth(MediaQuery.maxWidth(1024)) // 1024
+* MediaQuery.getMaxWidth(MediaQuery.minWidth(768)) // undefined
+* ```
+* @since 0.3.0
+*/
+const getMaxWidth = getMaxWidth$1;
+/**
+* Gets the query's `prefers-color-scheme` value.
+*
+* The return type keys on the `PrefersColorScheme` brand. Where the type
+* proves the feature is present, the result is a bare `'dark' | 'light'`.
+* On any other query it may also be `undefined`.
+*
+* A query holding both schemes matches nothing; the accessor then
+* returns `'dark'`, the alphabetically first in canonical order.
+*
+* @param query - The query to read.
+* @returns The required scheme, or `undefined` when an unbranded query carries no `prefers-color-scheme` feature.
+* @example
+* ```ts
+* MediaQuery.getPrefersColorScheme(MediaQuery.prefersColorScheme('dark')) // 'dark'
+* MediaQuery.getPrefersColorScheme(MediaQuery.minWidth(768)) // undefined
+* ```
+* @since 0.3.0
+*/
+const getPrefersColorScheme = getPrefersColorScheme$1;
+/**
+* Checks if the query carries a `min-width` feature, narrowing its type
+* to `MediaQuery<MinWidth>` so `getMinWidth` returns a bare `number`.
+*
+* @param query - The query to check.
+* @returns `true` if a `min-width` feature is present, `false` otherwise.
+* @example
+* ```ts
+* declare const query: MediaQuery.MediaQuery
+* if (MediaQuery.hasMinWidth(query)) {
+*   MediaQuery.getMinWidth(query) // number, not number | undefined
+* }
+* ```
+* @since 0.3.0
+*/
+const hasMinWidth = hasMinWidth$1;
+/**
+* Checks if the query carries a `max-width` feature, narrowing its type
+* to `MediaQuery<MaxWidth>` so `getMaxWidth` returns a bare `number`.
+*
+* @param query - The query to check.
+* @returns `true` if a `max-width` feature is present, `false` otherwise.
+* @since 0.3.0
+*/
+const hasMaxWidth = hasMaxWidth$1;
+/**
+* Checks if the query carries a `prefers-color-scheme` feature, narrowing
+* its type to `MediaQuery<PrefersColorScheme>` so `getPrefersColorScheme`
+* returns a guaranteed scheme.
+*
+* @param query - The query to check.
+* @returns `true` if a `prefers-color-scheme` feature is present, `false` otherwise.
+* @since 0.3.0
+*/
+const hasPrefersColorScheme = hasPrefersColorScheme$1;
+/**
 * Renders the query as CSS text: features in canonical order —
 * `min-width` ascending, then `prefers-color-scheme` — joined with
 * ` and `. The `mediaSyntax` option picks the width-feature spelling

package/dist/query/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["internal.isMediaQuery","internal.minWidth","internal.prefersColorScheme","internal.and","internal.render","internal.equals"],"sources":["../../src/query/mediaQuery.ts"],"sourcesContent":["import type { Pipeable } from '#util'\nimport type { MediaQueryTypeId } from './mediaQuery.internal.ts'\nimport * as internal from './mediaQuery.internal.ts'\n\n/**\n * A media query: a canonically ordered, deduplicated and-set of media\n * features.\n *\n * Feature constructors (`minWidth`, `prefersColorScheme`) return\n * one-feature queries; `and` merges. Conjunction is commutative and\n * idempotent, so construction sorts features canonically and drops exact\n * duplicates — structurally equal queries compare equal however they\n * were built. The canonical order is stable public API: `min-width`\n * features first (ascending by threshold), then `prefers-color-scheme`\n * (schemes alphabetically). Distinct features always all render, even\n * when one subsumes another (`minWidth(768)` and `minWidth(1024)`):\n * simplification changes no meaning but is not this type's job.\n *\n * `or` and `not` become new node kinds when a consumer needs them.\n *\n * @since 0.1.0\n */\nexport interface MediaQuery extends Pipeable {\n  readonly [MediaQueryTypeId]: MediaQueryTypeId\n}\n\n/**\n * Options for `render` — and the base of the library's render-options\n * family: every other module's `RenderOptions` extends this interface\n * (directly or through `Declaration.RenderOptions` and\n * `RuleSet.RenderOptions`), so an options object built for a bigger\n * renderer is accepted by every smaller one. A key means the same thing\n * wherever it appears; renderers ignore inherited keys that don't apply\n * to them.\n *\n * @since 0.1.0\n */\nexport interface RenderOptions {\n  /**\n   * The width-feature spelling: classic prefix syntax\n   * (`(min-width: 768px)`, the default) or modern range syntax\n   * (`(width >= 768px)`). Text only — the model is semantic and the two\n   * spellings mean the same thing.\n   */\n  readonly mediaSyntax?: 'prefix' | 'range'\n}\n\n/**\n * Checks if a value is a `MediaQuery`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `MediaQuery`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isMediaQuery: (u: unknown) => u is MediaQuery = internal.isMediaQuery\n\n/**\n * Creates a viewport-width lower bound.\n *\n * @param px - The threshold in CSS pixels. Must be a non-negative finite number.\n * @returns A one-feature `MediaQuery`.\n * @throws `Error` when `px` is negative or not finite.\n * @example\n * ```ts\n * MediaQuery.render(MediaQuery.minWidth(768)) // '(min-width: 768px)'\n * MediaQuery.render(MediaQuery.minWidth(768), { mediaSyntax: 'range' }) // '(width >= 768px)'\n * ```\n * @since 0.1.0\n */\nexport const minWidth: (px: number) => MediaQuery = internal.minWidth\n\n/**\n * Creates a `prefers-color-scheme` condition.\n *\n * @param scheme - The scheme to match, `'dark'` or `'light'`.\n * @returns A one-feature `MediaQuery`.\n * @since 0.1.0\n */\nexport const prefersColorScheme: (scheme: 'dark' | 'light') => MediaQuery =\n  internal.prefersColorScheme\n\nexport const and: {\n  /**\n   * Returns a function that conjoins `that` with its argument.\n   *\n   * @param that - The query to merge in.\n   * @returns A function producing the conjunction.\n   * @since 0.1.0\n   */\n  (that: MediaQuery): (self: MediaQuery) => MediaQuery\n  /**\n   * Conjoins two queries: the result matches where both match. Features\n   * re-sort into canonical order and exact duplicates collapse, so `and`\n   * is commutative and idempotent.\n   *\n   * @param self - The first query.\n   * @param that - The second query.\n   * @returns The conjunction.\n   * @example\n   * ```ts\n   * MediaQuery.minWidth(1280).pipe(\n   *   MediaQuery.and(MediaQuery.prefersColorScheme('dark')),\n   *   MediaQuery.render,\n   * ) // '(min-width: 1280px) and (prefers-color-scheme: dark)'\n   * ```\n   * @since 0.1.0\n   */\n  (self: MediaQuery, that: MediaQuery): MediaQuery\n} = internal.and\n\n/**\n * Renders the query as CSS text: features in canonical order —\n * `min-width` ascending, then `prefers-color-scheme` — joined with\n * ` and `. The `mediaSyntax` option picks the width-feature spelling\n * (default `'prefix'`).\n *\n * @param query - The query to render.\n * @param options - Optional syntax selection.\n * @returns Deterministic CSS text, without the `@media ` prefix.\n * @since 0.1.0\n */\nexport const render: (query: MediaQuery, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The query to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: MediaQuery): (self: MediaQuery) => boolean\n  /**\n   * Structural equality over canonically ordered features: two queries\n   * built from the same conditions compare equal regardless of\n   * construction order.\n   *\n   * @param self - The first query.\n   * @param that - The second query.\n   * @returns `true` if the queries are structurally equal.\n   * @since 0.1.0\n   */\n  (self: MediaQuery, that: MediaQuery): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyDA,MAAa,eAAgDA;;;;;;;;;;;;;;AAe7D,MAAa,WAAuCC;;;;;;;;AASpD,MAAa,qBACXC;AAEF,MAAa,MA2BTC;;;;;;;;;;;;AAaJ,MAAa,SAAiEC;AAE9E,MAAa,SAoBTC"}
+{"version":3,"file":"index.mjs","names":["internal.isMediaQuery","internal.minWidth","internal.maxWidth","internal.prefersColorScheme","internal.and","internal.getMinWidth","internal.getMaxWidth","internal.getPrefersColorScheme","internal.hasMinWidth","internal.hasMaxWidth","internal.hasPrefersColorScheme","internal.render","internal.equals"],"sources":["../../src/query/mediaQuery.ts"],"sourcesContent":["import type { Pipeable } from '#util'\nimport type { MediaQueryFeatures, MediaQueryTypeId } from './mediaQuery.internal.ts'\nimport * as internal from './mediaQuery.internal.ts'\n\ndeclare const MinWidthId: unique symbol\ndeclare const MaxWidthId: unique symbol\ndeclare const PrefersColorSchemeId: unique symbol\n\n/**\n * A media query: a canonically ordered, deduplicated and-set of media\n * features.\n *\n * Feature constructors (`minWidth`, `maxWidth`, `prefersColorScheme`)\n * return one-feature queries; `and` merges. Conjunction is commutative\n * and idempotent, so construction sorts features canonically and drops\n * exact duplicates — structurally equal queries compare equal however\n * they were built. The canonical order is stable public API: `min-width`\n * features first (ascending by threshold), then `max-width` (ascending),\n * then `prefers-color-scheme` (schemes alphabetically). Distinct features\n * always all render, even when one subsumes another (`minWidth(768)` and\n * `minWidth(1024)`): simplification changes no meaning but is not this\n * type's job.\n *\n * `Features` records, as intersected type-level brands, which feature\n * kinds are known to be present. It defaults to `unknown` — no claims.\n * Constructors brand their result (`minWidth` returns\n * `MediaQuery<MinWidth>`), `and` keeps both sides' brands, the `has*`\n * guards recover a brand from a plain query at runtime, and the `get*`\n * accessors key their return type on it to drop `undefined`. Brands are\n * type-level only: a query is identical at runtime whatever its type\n * knows.\n *\n * `or` and `not` become new node kinds when a consumer needs them.\n *\n * @since 0.1.0\n */\nexport interface MediaQuery<out Features = unknown> extends Pipeable {\n  readonly [MediaQueryTypeId]: MediaQueryTypeId\n  readonly [MediaQueryFeatures]?: Features\n}\n\n/**\n * The brand of a query known to carry a `min-width` feature. `minWidth`\n * stamps it, `and` keeps it through conjunction, `hasMinWidth` recovers\n * it at runtime, and `getMinWidth` returns a guaranteed `number` where it\n * is present. Composes by intersection with the other feature brands.\n *\n * @since 0.3.0\n */\nexport type MinWidth = { readonly [MinWidthId]: 'minWidth' }\n\n/**\n * The brand of a query known to carry a `max-width` feature. `maxWidth`\n * stamps it, `and` keeps it through conjunction, `hasMaxWidth` recovers\n * it at runtime, and `getMaxWidth` returns a guaranteed `number` where it\n * is present. Composes by intersection with the other feature brands.\n *\n * @since 0.3.0\n */\nexport type MaxWidth = { readonly [MaxWidthId]: 'maxWidth' }\n\n/**\n * The brand of a query known to carry a `prefers-color-scheme` feature.\n * `prefersColorScheme` stamps it, `and` keeps it through conjunction,\n * `hasPrefersColorScheme` recovers it at runtime, and\n * `getPrefersColorScheme` returns a guaranteed scheme where it is\n * present. Composes by intersection with the other feature brands.\n *\n * @since 0.3.0\n */\nexport type PrefersColorScheme = { readonly [PrefersColorSchemeId]: 'prefersColorScheme' }\n\n/**\n * Options for `render` — and the base of the library's render-options\n * family: every other module's `RenderOptions` extends this interface\n * (directly or through `Declaration.RenderOptions` and\n * `RuleSet.RenderOptions`), so an options object built for a bigger\n * renderer is accepted by every smaller one. A key means the same thing\n * wherever it appears; renderers ignore inherited keys that don't apply\n * to them.\n *\n * @since 0.1.0\n */\nexport interface RenderOptions {\n  /**\n   * The width-feature spelling: classic prefix syntax\n   * (`(min-width: 768px)`, the default) or modern range syntax\n   * (`(width >= 768px)`). Text only — the model is semantic and the two\n   * spellings mean the same thing.\n   */\n  readonly mediaSyntax?: 'prefix' | 'range'\n}\n\n/**\n * Checks if a value is a `MediaQuery`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `MediaQuery`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isMediaQuery: (u: unknown) => u is MediaQuery = internal.isMediaQuery\n\n/**\n * Creates a viewport-width lower bound.\n *\n * The result carries the `MinWidth` brand, so `getMinWidth` returns a\n * bare `number` on it and on any conjunction built from it.\n *\n * @param px - The threshold in CSS pixels. Must be a non-negative finite number.\n * @returns A one-feature `MediaQuery`, branded `MinWidth`.\n * @throws `Error` when `px` is negative or not finite.\n * @example\n * ```ts\n * MediaQuery.render(MediaQuery.minWidth(768)) // '(min-width: 768px)'\n * MediaQuery.render(MediaQuery.minWidth(768), { mediaSyntax: 'range' }) // '(width >= 768px)'\n * ```\n * @since 0.1.0\n */\nexport const minWidth: (px: number) => MediaQuery<MinWidth> = internal.minWidth\n\n/**\n * Creates a viewport-width upper bound.\n *\n * The result carries the `MaxWidth` brand, so `getMaxWidth` returns a\n * bare `number` on it and on any conjunction built from it.\n *\n * @param px - The threshold in CSS pixels. Must be a non-negative finite number.\n * @returns A one-feature `MediaQuery`, branded `MaxWidth`.\n * @throws `Error` when `px` is negative or not finite.\n * @example\n * ```ts\n * MediaQuery.render(MediaQuery.maxWidth(1024)) // '(max-width: 1024px)'\n * MediaQuery.render(MediaQuery.maxWidth(1024), { mediaSyntax: 'range' }) // '(width <= 1024px)'\n * ```\n * @since 0.3.0\n */\nexport const maxWidth: (px: number) => MediaQuery<MaxWidth> = internal.maxWidth\n\n/**\n * Creates a `prefers-color-scheme` condition.\n *\n * The result carries the `PrefersColorScheme` brand, so\n * `getPrefersColorScheme` returns a guaranteed scheme on it and on any\n * conjunction built from it.\n *\n * @param scheme - The scheme to match, `'dark'` or `'light'`.\n * @returns A one-feature `MediaQuery`, branded `PrefersColorScheme`.\n * @since 0.1.0\n */\nexport const prefersColorScheme: (scheme: 'dark' | 'light') => MediaQuery<PrefersColorScheme> =\n  internal.prefersColorScheme\n\nexport const and: {\n  /**\n   * Returns a function that conjoins `that` with its argument.\n   *\n   * @param that - The query to merge in.\n   * @returns A function producing the conjunction.\n   * @since 0.1.0\n   */\n  <B>(that: MediaQuery<B>): <A>(self: MediaQuery<A>) => MediaQuery<A & B>\n  /**\n   * Conjoins two queries: the result matches where both match. Features\n   * re-sort into canonical order and exact duplicates collapse, so `and`\n   * is commutative and idempotent.\n   *\n   * Known features intersect: the result keeps every brand either side\n   * carries, so a `MinWidth` query stays `MinWidth` through conjunction.\n   *\n   * @param self - The first query.\n   * @param that - The second query.\n   * @returns The conjunction, branded with both sides' known features.\n   * @example\n   * ```ts\n   * MediaQuery.minWidth(1280).pipe(\n   *   MediaQuery.and(MediaQuery.prefersColorScheme('dark')),\n   *   MediaQuery.render,\n   * ) // '(min-width: 1280px) and (prefers-color-scheme: dark)'\n   * ```\n   * @since 0.1.0\n   */\n  <A, B>(self: MediaQuery<A>, that: MediaQuery<B>): MediaQuery<A & B>\n} = internal.and\n\n/**\n * Gets the query's `min-width` threshold.\n *\n * The return type keys on the `MinWidth` brand. Where the type proves a\n * `min-width` feature is present — `minWidth`'s result, any conjunction\n * keeping its brand, or a query narrowed by `hasMinWidth` — the result is\n * a bare `number`. On any other query it is `number | undefined`.\n *\n * When several `min-width` features stack, the largest threshold is\n * returned — the conjunction's effective lower bound, since every\n * feature must hold.\n *\n * @param query - The query to read.\n * @returns The largest `min-width` threshold in CSS pixels, or `undefined` when an unbranded query carries no `min-width` feature.\n * @example\n * ```ts\n * MediaQuery.getMinWidth(MediaQuery.minWidth(768)) // 768\n * MediaQuery.getMinWidth(MediaQuery.prefersColorScheme('dark')) // undefined\n * MediaQuery.minWidth(768).pipe(\n *   MediaQuery.and(MediaQuery.minWidth(1024)),\n *   MediaQuery.getMinWidth,\n * ) // 1024\n * ```\n * @since 0.3.0\n */\nexport const getMinWidth: <T>(\n  query: MediaQuery<T>,\n) => T extends MinWidth ? number : number | undefined = internal.getMinWidth\n\n/**\n * Gets the query's `max-width` threshold.\n *\n * The return type keys on the `MaxWidth` brand. Where the type proves a\n * `max-width` feature is present — `maxWidth`'s result, any conjunction\n * keeping its brand, or a query narrowed by `hasMaxWidth` — the result is\n * a bare `number`. On any other query it is `number | undefined`.\n *\n * When several `max-width` features stack, the smallest threshold is\n * returned — the conjunction's effective upper bound, since every\n * feature must hold.\n *\n * @param query - The query to read.\n * @returns The smallest `max-width` threshold in CSS pixels, or `undefined` when an unbranded query carries no `max-width` feature.\n * @example\n * ```ts\n * MediaQuery.getMaxWidth(MediaQuery.maxWidth(1024)) // 1024\n * MediaQuery.getMaxWidth(MediaQuery.minWidth(768)) // undefined\n * ```\n * @since 0.3.0\n */\nexport const getMaxWidth: <T>(\n  query: MediaQuery<T>,\n) => T extends MaxWidth ? number : number | undefined = internal.getMaxWidth\n\n/**\n * Gets the query's `prefers-color-scheme` value.\n *\n * The return type keys on the `PrefersColorScheme` brand. Where the type\n * proves the feature is present, the result is a bare `'dark' | 'light'`.\n * On any other query it may also be `undefined`.\n *\n * A query holding both schemes matches nothing; the accessor then\n * returns `'dark'`, the alphabetically first in canonical order.\n *\n * @param query - The query to read.\n * @returns The required scheme, or `undefined` when an unbranded query carries no `prefers-color-scheme` feature.\n * @example\n * ```ts\n * MediaQuery.getPrefersColorScheme(MediaQuery.prefersColorScheme('dark')) // 'dark'\n * MediaQuery.getPrefersColorScheme(MediaQuery.minWidth(768)) // undefined\n * ```\n * @since 0.3.0\n */\nexport const getPrefersColorScheme: <T>(\n  query: MediaQuery<T>,\n) => T extends PrefersColorScheme ? 'dark' | 'light' : 'dark' | 'light' | undefined =\n  internal.getPrefersColorScheme\n\n/**\n * Checks if the query carries a `min-width` feature, narrowing its type\n * to `MediaQuery<MinWidth>` so `getMinWidth` returns a bare `number`.\n *\n * @param query - The query to check.\n * @returns `true` if a `min-width` feature is present, `false` otherwise.\n * @example\n * ```ts\n * declare const query: MediaQuery.MediaQuery\n * if (MediaQuery.hasMinWidth(query)) {\n *   MediaQuery.getMinWidth(query) // number, not number | undefined\n * }\n * ```\n * @since 0.3.0\n */\nexport const hasMinWidth: (query: MediaQuery) => query is MediaQuery<MinWidth> =\n  internal.hasMinWidth\n\n/**\n * Checks if the query carries a `max-width` feature, narrowing its type\n * to `MediaQuery<MaxWidth>` so `getMaxWidth` returns a bare `number`.\n *\n * @param query - The query to check.\n * @returns `true` if a `max-width` feature is present, `false` otherwise.\n * @since 0.3.0\n */\nexport const hasMaxWidth: (query: MediaQuery) => query is MediaQuery<MaxWidth> =\n  internal.hasMaxWidth\n\n/**\n * Checks if the query carries a `prefers-color-scheme` feature, narrowing\n * its type to `MediaQuery<PrefersColorScheme>` so `getPrefersColorScheme`\n * returns a guaranteed scheme.\n *\n * @param query - The query to check.\n * @returns `true` if a `prefers-color-scheme` feature is present, `false` otherwise.\n * @since 0.3.0\n */\nexport const hasPrefersColorScheme: (query: MediaQuery) => query is MediaQuery<PrefersColorScheme> =\n  internal.hasPrefersColorScheme\n\n/**\n * Renders the query as CSS text: features in canonical order —\n * `min-width` ascending, then `prefers-color-scheme` — joined with\n * ` and `. The `mediaSyntax` option picks the width-feature spelling\n * (default `'prefix'`).\n *\n * @param query - The query to render.\n * @param options - Optional syntax selection.\n * @returns Deterministic CSS text, without the `@media ` prefix.\n * @since 0.1.0\n */\nexport const render: (query: MediaQuery, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The query to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: MediaQuery): (self: MediaQuery) => boolean\n  /**\n   * Structural equality over canonically ordered features: two queries\n   * built from the same conditions compare equal regardless of\n   * construction order.\n   *\n   * @param self - The first query.\n   * @param that - The second query.\n   * @returns `true` if the queries are structurally equal.\n   * @since 0.1.0\n   */\n  (self: MediaQuery, that: MediaQuery): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuGA,MAAa,eAAgDA;;;;;;;;;;;;;;;;;AAkB7D,MAAa,WAAiDC;;;;;;;;;;;;;;;;;AAkB9D,MAAa,WAAiDC;;;;;;;;;;;;AAa9D,MAAa,qBACXC;AAEF,MAAa,MA8BTC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BJ,MAAa,cAE2CC;;;;;;;;;;;;;;;;;;;;;;AAuBxD,MAAa,cAE2CC;;;;;;;;;;;;;;;;;;;;AAqBxD,MAAa,wBAGXC;;;;;;;;;;;;;;;;AAiBF,MAAa,cACXC;;;;;;;;;AAUF,MAAa,cACXC;;;;;;;;;;AAWF,MAAa,wBACXC;;;;;;;;;;;;AAaF,MAAa,SAAiEC;AAE9E,MAAa,SAoBTC"}

package/dist/rule/index.d.mts

@@ -1,2 +1,2 @@
-import { i as ruleSet_d_exports, o as styleRule_d_exports, t as mediaRule_d_exports } from "../shared/mediaRule-BDB4WCYy.mjs";
+import { a as ruleSet_d_exports, n as mediaRule_d_exports, s as styleRule_d_exports } from "../shared/mediaRule-2K7Ggwe4.mjs";
 export { mediaRule_d_exports as MediaRule, ruleSet_d_exports as RuleSet, styleRule_d_exports as StyleRule };

package/dist/rule/index.mjs

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "../shared/rolldown-runtime-D7D4PA-g.mjs";
-import { _ as equals$3, a as forMediaQuery$1, b as refs$3, c as isRuleSet$1, d as render$4, f as equals$5, g as render$5, h as refs$5, i as equals$4, l as make$4, m as make$5, n as concat$1, o as forSelector$1, p as isStyleRule$1, r as empty$1, s as isEmpty$1, t as append$1, u as refs$4, v as isMediaRule$1, x as render$3, y as make$3 } from "../shared/ruleSet.internal-DodzVMUU.mjs";
+import { _ as equals$3, a as forMediaQuery$1, b as refs, c as isRuleSet$1, d as render$4, f as equals$5, g as render$5, h as refs$2, i as equals$4, l as make$4, m as make$5, n as concat$1, o as forSelector$1, p as isStyleRule$1, r as empty$1, s as isEmpty$1, t as append$1, u as refs$1, v as isMediaRule$1, x as render$3, y as make$3 } from "../shared/ruleSet.internal-Cj4yIYFI.mjs";
 //#region src/rule/mediaRule.ts
 var mediaRule_exports = /* @__PURE__ */ __exportAll({
 	equals: () => equals$2,
 	isMediaRule: () => isMediaRule,
 	make: () => make$2,
-	refs: () => refs$2,
-	render: () => render$2
+	render: () => render$2,
+	vars: () => vars$2
 });
 /**
 * Checks if a value is a `MediaRule`.
@@ -20,11 +20,11 @@ var mediaRule_exports = /* @__PURE__ */ __exportAll({
 */
 const isMediaRule = isMediaRule$1;
 /**
-* Creates a nested `@media` rule.
+* Creates a `@media` rule.
 *
 * @param query - The media query gating the block.
-* @param block - The rule's block.
-* @returns A `MediaRule` carrying the block's reference names.
+* @param block - The rule's block. Declarations make the rule nested-only; a block of closed style rules makes it top-level-capable.
+* @returns A `MediaRule` carrying the block's variable names and requirements.
 * @example
 * ```ts
 * MediaRule.make(
@@ -36,14 +36,14 @@ const isMediaRule = isMediaRule$1;
 */
 const make$2 = make$3;
 /**
-* The rule's unbound reference names — the block's, since a query
+* The rule's unbound variable names — the block's, since a query
 * contributes none.
 *
 * @param rule - The rule to inspect.
-* @returns The set of unbound reference names.
+* @returns The set of unbound variable names.
 * @since 0.1.0
 */
-const refs$2 = refs$3;
+const vars$2 = refs;
 /**
 * Renders the rule in nested form: `@media query { ... }`, the body as
 * `RuleSet.render` emits it, one level deeper — declarations directly
@@ -51,13 +51,15 @@ const refs$2 = refs$3;
 * style rule (CSSNestedDeclarations). A rule whose block is empty
 * renders as the empty string.
 *
+* Nested style rules render as indented sub-blocks with `&` kept
+* verbatim — native CSS nesting is the output shape.
+*
 * A fragment renderer: whole sheets render via `Stylesheet.render`,
 * which emits each rule's media in this same nested shape.
 *
 * @param rule - The rule to render.
 * @param options - Optional indentation unit, precision context, and media syntax.
 * @returns Deterministic CSS text.
-* @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.
 * @example
 * ```ts
 * MediaRule.render(
@@ -80,8 +82,8 @@ var ruleSet_exports = /* @__PURE__ */ __exportAll({
 	isEmpty: () => isEmpty,
 	isRuleSet: () => isRuleSet,
 	make: () => make$1,
-	refs: () => refs$1,
-	render: () => render$1
+	render: () => render$1,
+	vars: () => vars$1
 });
 /**
 * Checks if a value is a `RuleSet`.
@@ -116,11 +118,11 @@ const isEmpty = isEmpty$1;
 * Creates a rule set holding the given members, in the given order.
 *
 * @param members - Declarations and nested rules, in authored order.
-* @returns A `RuleSet` whose `Refs` unions the members' reference names.
+* @returns A `RuleSet` whose `Vars` unions the members' variable names and whose `Requires` unions their requirement contributions.
 * @example
 * ```ts
 * const block = RuleSet.make(
-*   Declaration.make('--depth', Calc.ref('depth')),
+*   Declaration.make('--depth', Calc.var('depth')),
 *   Declaration.make('color', 'oklch(0.7 0.1 250)'),
 * ) // RuleSet<'depth'>
 * ```
@@ -132,27 +134,29 @@ const concat = concat$1;
 const forSelector = forSelector$1;
 const forMediaQuery = forMediaQuery$1;
 /**
-* The block's unbound reference names, unioned across members —
+* The block's unbound variable names, unioned across members —
 * including everything nested rules contribute.
 *
 * @param set - The block to inspect.
-* @returns The set of unbound reference names.
+* @returns The set of unbound variable names.
 * @since 0.1.0
 */
-const refs$1 = refs$4;
+const vars$1 = refs$1;
 /**
 * Renders the block's body — the text between a rule's braces, without
-* the braces: one line per declaration, nested `@media` rules as
-* indented sub-blocks, in member order. Empty blocks (and nested rules
-* whose blocks are empty) render as the empty string.
+* the braces: one line per declaration, nested `@media` and style rules
+* as indented sub-blocks (`&` kept verbatim), in member order. Empty
+* blocks (and nested rules whose blocks are empty) render as the empty
+* string.
 *
 * A fragment renderer: use it to compose blocks the model does not
-* represent. Whole sheets render via `Stylesheet.render`.
+* represent. Whole sheets render via `Stylesheet.render`, and the binder
+* invariant on nested selectors is `StyleRule.make`'s — a free-standing
+* block renders without it.
 *
 * @param set - The block to render.
 * @param options - Optional indentation unit, precision context, and media syntax.
 * @returns Deterministic CSS text.
-* @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.
 * @example
 * ```ts
 * RuleSet.render(RuleSet.make(Declaration.make('--depth', 4), Declaration.make('color', 'red')))
@@ -168,8 +172,8 @@ var styleRule_exports = /* @__PURE__ */ __exportAll({
 	equals: () => equals,
 	isStyleRule: () => isStyleRule,
 	make: () => make,
-	refs: () => refs,
-	render: () => render
+	render: () => render,
+	vars: () => vars
 });
 /**
 * Checks if a value is a `StyleRule`.
@@ -185,32 +189,41 @@ const isStyleRule = isStyleRule$1;
 /**
 * Creates a style rule.
 *
-* @param selector - The compound selector the block applies to.
+* The binder check runs here: every style rule nested in `block` —
+* directly, or inside its `@media` blocks — must reference `&` in its
+* selector, because this rule's selector is what that `&` reads. CSS
+* would silently prepend a descendant `&` instead; the model rejects
+* the shape rather than rewriting the authored selector.
+*
+* @param selector - The selector the block applies to. References `&` exactly when this rule itself nests.
 * @param block - The rule's block.
-* @returns A `StyleRule` carrying the block's reference names.
+* @returns A `StyleRule` carrying the block's variable names and the selector's requirements.
+* @throws `Error` when a style rule nested in `block` has a selector that does not reference `&`.
 * @example
 * ```ts
 * StyleRule.make(
 *   Selector.root,
-*   RuleSet.make(Declaration.make('--depth', Calc.ref('depth'))),
+*   RuleSet.make(Declaration.make('--depth', Calc.var('depth'))),
 * ) // StyleRule<'depth'>
 * ```
 * @since 0.1.0
 */
 const make = make$5;
 /**
-* The rule's unbound reference names — the block's, since a selector
+* The rule's unbound variable names — the block's, since a selector
 * contributes none.
 *
 * @param rule - The rule to inspect.
-* @returns The set of unbound reference names.
+* @returns The set of unbound variable names.
 * @since 0.1.0
 */
-const refs = refs$5;
+const vars = refs$2;
 /**
 * Renders the rule in nested form: `selector { ... }`, the body as
-* `RuleSet.render` emits it, one level deeper. A rule whose block is
-* empty renders as the empty string.
+* `RuleSet.render` emits it, one level deeper. Nested style rules render
+* as indented sub-blocks with `&` kept verbatim — native CSS nesting is
+* the output shape. A rule whose block is empty renders as the empty
+* string.
 *
 * A fragment renderer: whole sheets render via `Stylesheet.render`,
 * which emits each rule in this same nested shape.
@@ -218,7 +231,6 @@ const refs = refs$5;
 * @param rule - The rule to render.
 * @param options - Optional indentation unit, precision context, and media syntax.
 * @returns Deterministic CSS text.
-* @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.
 * @example
 * ```ts
 * StyleRule.render(StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--depth', 4))))

package/dist/rule/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["internal.isMediaRule","make","internal.make","refs","internal.refs","render","internal.render","equals","internal.equals","internal.isRuleSet","internal.empty","internal.isEmpty","make","internal.make","internal.append","internal.concat","internal.forSelector","internal.forMediaQuery","refs","internal.refs","render","internal.render","equals","internal.equals","internal.isStyleRule","internal.make","internal.refs","internal.render","internal.equals"],"sources":["../../src/rule/mediaRule.ts","../../src/rule/ruleSet.ts","../../src/rule/styleRule.ts"],"sourcesContent":["import type { MediaQuery } from '#query/mediaQuery'\nimport type { Pipeable } from '#util'\nimport type { MediaRuleTypeId } from './mediaRule.internal.ts'\nimport * as internal from './mediaRule.internal.ts'\nimport type { RenderOptions as RuleSetRenderOptions, RuleSet } from './ruleSet.ts'\n\n/**\n * A nested `@media` rule: a media query and the block it gates.\n *\n * This is the nested form — a member of an enclosing style rule's block,\n * per the CSSNestedDeclarations grammar — not a top-level `@media`\n * statement. Media enters the model inside a style rule\n * (`:root { @media ... { ... } }`) and renders there, nested. The `Refs`\n * parameter is the block's.\n *\n * Construct via `make`.\n *\n * @since 0.1.0\n */\nexport interface MediaRule<out Refs extends string = string> extends Pipeable {\n  readonly [MediaRuleTypeId]: MediaRuleTypeId\n  /**\n   * The media query gating the block.\n   */\n  readonly query: MediaQuery\n  /**\n   * The rule's block.\n   */\n  readonly block: RuleSet<Refs>\n}\n\n/**\n * Checks if a value is a `MediaRule`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `MediaRule`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isMediaRule: (u: unknown) => u is MediaRule<string> = internal.isMediaRule\n\n/**\n * Creates a nested `@media` rule.\n *\n * @param query - The media query gating the block.\n * @param block - The rule's block.\n * @returns A `MediaRule` carrying the block's reference names.\n * @example\n * ```ts\n * MediaRule.make(\n *   MediaQuery.prefersColorScheme('dark'),\n *   RuleSet.make(Declaration.make('--scheme', 'dark')),\n * )\n * ```\n * @since 0.1.0\n */\nexport const make: <Refs extends string>(\n  query: MediaQuery,\n  block: RuleSet<Refs>,\n) => MediaRule<Refs> = internal.make\n\n/**\n * The rule's unbound reference names — the block's, since a query\n * contributes none.\n *\n * @param rule - The rule to inspect.\n * @returns The set of unbound reference names.\n * @since 0.1.0\n */\nexport const refs: <Refs extends string>(rule: MediaRule<Refs>) => ReadonlySet<Refs> = internal.refs\n\n/**\n * Options for `render` — the block renderers' shared shape,\n * `RuleSet.RenderOptions`, unchanged.\n *\n * @since 0.1.0\n */\nexport type RenderOptions = RuleSetRenderOptions\n\n/**\n * Renders the rule in nested form: `@media query { ... }`, the body as\n * `RuleSet.render` emits it, one level deeper — declarations directly\n * inside the query block, the shape a media rule takes nested in a\n * style rule (CSSNestedDeclarations). A rule whose block is empty\n * renders as the empty string.\n *\n * A fragment renderer: whole sheets render via `Stylesheet.render`,\n * which emits each rule's media in this same nested shape.\n *\n * @param rule - The rule to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.\n * @example\n * ```ts\n * MediaRule.render(\n *   MediaRule.make(MediaQuery.minWidth(768), RuleSet.make(Declaration.make('--gutter', 24))),\n * ) // '@media (min-width: 768px) {\\n\\t--gutter: 24;\\n}'\n * ```\n * @since 0.1.0\n */\nexport const render: (rule: MediaRule<string>, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The rule to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: MediaRule<string>): (self: MediaRule<string>) => boolean\n  /**\n   * Structural equality: queries compare as in `MediaQuery.equals`\n   * (canonically ordered features), blocks as in `RuleSet.equals`\n   * (members in order).\n   *\n   * @param self - The first rule.\n   * @param that - The second rule.\n   * @returns `true` if the rules are structurally equal.\n   * @since 0.1.0\n   */\n  (self: MediaRule<string>, that: MediaRule<string>): boolean\n} = internal.equals\n","import type {\n  Declaration,\n  RenderOptions as DeclarationRenderOptions,\n} from '#declaration/declaration'\nimport type { MediaQuery } from '#query/mediaQuery'\nimport type { Selector } from '#selector/selector'\nimport type { Pipeable } from '#util'\nimport type { MediaRule } from './mediaRule.ts'\nimport type { RuleSetTypeId } from './ruleSet.internal.ts'\nimport * as internal from './ruleSet.internal.ts'\nimport type { StyleRule } from './styleRule.ts'\n\n/**\n * An ordered block of rule members — the nesting unit of the rule layer.\n *\n * Member order is preserved exactly as authored: never sorted, never\n * deduplicated. A block's order is cascade behavior, and since\n * CSSNestedDeclarations shipped (late 2024), declarations trailing a\n * nested rule keep their source position rather than hoisting above it —\n * so what you append is what renders.\n *\n * The `Refs` parameter unions the members' unbound reference names, as on\n * `Calc`; `refs` is the runtime set.\n *\n * Construct via `make` (or `empty` and `append`).\n *\n * @since 0.1.0\n */\nexport interface RuleSet<out Refs extends string = string> extends Pipeable {\n  readonly [RuleSetTypeId]: RuleSetTypeId\n  /**\n   * The block's members, in authored order.\n   */\n  readonly members: ReadonlyArray<Member<Refs>>\n}\n\n/**\n * The forms a rule block may contain: declarations, nested style rules,\n * and nested `@media` rules.\n *\n * Deliberately absent are the declaration-block at-rules (`@font-face`,\n * `@property`) — the CSS grammar keeps them at the top level, so this\n * union keeps them out of blocks at the type level.\n *\n * @since 0.1.0\n */\nexport type Member<Refs extends string = string> =\n  | Declaration<Refs>\n  | StyleRule<Refs>\n  | MediaRule<Refs>\n\n/**\n * The unbound reference names of a `Member`, or the union of them for a\n * union of members — the type-level counterpart of `refs`, used by the\n * container constructors to thread their members' names into the result.\n *\n * @since 0.1.0\n */\nexport type MemberRefs<M extends Member<string>> =\n  M extends Declaration<infer R>\n    ? R\n    : M extends StyleRule<infer R>\n      ? R\n      : M extends MediaRule<infer R>\n        ? R\n        : never\n\n/**\n * Checks if a value is a `RuleSet`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `RuleSet`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isRuleSet: (u: unknown) => u is RuleSet<string> = internal.isRuleSet\n\n/**\n * The empty block — the identity for `concat`.\n *\n * @since 0.1.0\n */\nexport const empty: RuleSet<never> = internal.empty\n\n/**\n * Checks if the block has no members.\n *\n * Structural emptiness only: a non-empty block can still *render* as the\n * empty string, when every member is a nested rule whose block renders\n * empty.\n *\n * @param set - The block to inspect.\n * @returns `true` if the block has no members.\n * @since 0.2.0\n */\nexport const isEmpty: (set: RuleSet<string>) => boolean = internal.isEmpty\n\n/**\n * Creates a rule set holding the given members, in the given order.\n *\n * @param members - Declarations and nested rules, in authored order.\n * @returns A `RuleSet` whose `Refs` unions the members' reference names.\n * @example\n * ```ts\n * const block = RuleSet.make(\n *   Declaration.make('--depth', Calc.ref('depth')),\n *   Declaration.make('color', 'oklch(0.7 0.1 250)'),\n * ) // RuleSet<'depth'>\n * ```\n * @since 0.1.0\n */\nexport const make: <Members extends ReadonlyArray<Member<string>>>(\n  ...members: Members\n) => RuleSet<MemberRefs<Members[number]>> = internal.make\n\nexport const append: {\n  /**\n   * Returns a function that appends `member` to its argument's block.\n   *\n   * @param member - The member to append.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <M extends Member<string>>(\n    member: M,\n  ): <Refs extends string>(self: RuleSet<Refs>) => RuleSet<Refs | MemberRefs<M>>\n  /**\n   * Returns a function that appends the style rule `selector { block }`\n   * to its argument's block.\n   *\n   * @param selector - The nested rule's selector.\n   * @param block - The nested rule's block.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <B extends string>(\n    selector: Selector,\n    block: RuleSet<B>,\n  ): <Refs extends string>(self: RuleSet<Refs>) => RuleSet<Refs | B>\n  /**\n   * Returns a function that appends the media rule `@media query { block }`\n   * to its argument's block.\n   *\n   * @param query - The nested rule's media query.\n   * @param block - The nested rule's block.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <B extends string>(\n    query: MediaQuery,\n    block: RuleSet<B>,\n  ): <Refs extends string>(self: RuleSet<Refs>) => RuleSet<Refs | B>\n  /**\n   * Appends a member at the end of the block. The result is a new set;\n   * the original is untouched.\n   *\n   * @param self - The block to extend.\n   * @param member - The member to append.\n   * @returns The extended block, with the member's reference names joined in.\n   * @example\n   * ```ts\n   * RuleSet.empty.pipe(\n   *   RuleSet.append(Declaration.make('color', 'red')),\n   *   RuleSet.append(Declaration.make('--depth', Calc.ref('depth'))),\n   * ) // RuleSet<'depth'>\n   * ```\n   * @since 0.1.0\n   */\n  <Refs extends string, M extends Member<string>>(\n    self: RuleSet<Refs>,\n    member: M,\n  ): RuleSet<Refs | MemberRefs<M>>\n  /**\n   * Appends a nested style rule from its parts — sugar for\n   * `append(self, StyleRule.make(selector, block))`, so blocks compose\n   * without naming `StyleRule` at the call site.\n   *\n   * @param self - The block to extend.\n   * @param selector - The nested rule's selector.\n   * @param block - The nested rule's block.\n   * @returns The extended block, with the nested block's reference names joined in.\n   * @example\n   * ```ts\n   * RuleSet.empty.pipe(RuleSet.append(Selector.class('btn'), RuleSet.make(Declaration.make('color', 'red'))))\n   * ```\n   * @since 0.1.0\n   */\n  <Refs extends string, B extends string>(\n    self: RuleSet<Refs>,\n    selector: Selector,\n    block: RuleSet<B>,\n  ): RuleSet<Refs | B>\n  /**\n   * Appends a nested media rule from its parts — sugar for\n   * `append(self, MediaRule.make(query, block))`, so blocks compose\n   * without naming `MediaRule` at the call site.\n   *\n   * @param self - The block to extend.\n   * @param query - The nested rule's media query.\n   * @param block - The nested rule's block.\n   * @returns The extended block, with the nested block's reference names joined in.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--gutter', 16)).pipe(\n   *   RuleSet.append(MediaQuery.minWidth(768), RuleSet.make(Declaration.make('--gutter', 24))),\n   * )\n   * ```\n   * @since 0.1.0\n   */\n  <Refs extends string, B extends string>(\n    self: RuleSet<Refs>,\n    query: MediaQuery,\n    block: RuleSet<B>,\n  ): RuleSet<Refs | B>\n} = internal.append\n\nexport const concat: {\n  /**\n   * Returns a function that appends `that`'s members after its argument's.\n   *\n   * @param that - The block whose members come second.\n   * @returns A function producing the concatenated block.\n   * @since 0.1.0\n   */\n  <B extends string>(that: RuleSet<B>): <A extends string>(self: RuleSet<A>) => RuleSet<A | B>\n  /**\n   * Concatenates two blocks: `self`'s members followed by `that`'s, order\n   * preserved on both sides. No deduplication happens here — repeated\n   * declarations are legal CSS and their repetition is cascade behavior.\n   *\n   * @param self - The block whose members come first.\n   * @param that - The block whose members come second.\n   * @returns The concatenated block, with both sides' reference names unioned.\n   * @since 0.1.0\n   */\n  <A extends string, B extends string>(self: RuleSet<A>, that: RuleSet<B>): RuleSet<A | B>\n} = internal.concat\n\nexport const forSelector: {\n  /**\n   * Returns a function that wraps its argument as the block of a style\n   * rule applying to `selector`.\n   *\n   * @param selector - The selector the resulting rule's block applies to.\n   * @returns A function that takes a block and returns the style rule applying it to `selector`.\n   * @since 0.2.0\n   */\n  (selector: Selector): <Refs extends string>(self: RuleSet<Refs>) => StyleRule<Refs>\n  /**\n   * Lifts a block into a style rule applying to `selector` — sugar for\n   * `StyleRule.make(selector, self)` with the arguments flipped, so a\n   * block built up through `pipe` caps off as a rule without naming\n   * `StyleRule` at the call site. The rule carries the block's reference\n   * names unchanged; a selector contributes none.\n   *\n   * @param self - The block the rule applies.\n   * @param selector - The selector the block applies to.\n   * @returns The style rule pairing `selector` with the block.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--depth', Calc.ref('depth'))).pipe(\n   *   RuleSet.forSelector(Selector.root),\n   * ) // StyleRule<'depth'>\n   * ```\n   * @since 0.2.0\n   */\n  <Refs extends string>(self: RuleSet<Refs>, selector: Selector): StyleRule<Refs>\n} = internal.forSelector\n\nexport const forMediaQuery: {\n  /**\n   * Returns a function that wraps its argument as the block of a nested\n   * `@media` rule gated by `query`.\n   *\n   * @param query - The media query gating the resulting rule's block.\n   * @returns A function that takes a block and returns the media rule gating it by `query`.\n   * @since 0.2.0\n   */\n  (query: MediaQuery): <Refs extends string>(self: RuleSet<Refs>) => MediaRule<Refs>\n  /**\n   * Lifts a block into a nested `@media` rule gated by `query` — sugar\n   * for `MediaRule.make(query, self)` with the arguments flipped, so a\n   * block built up through `pipe` caps off as a rule without naming\n   * `MediaRule` at the call site. The rule carries the block's reference\n   * names unchanged; a query contributes none.\n   *\n   * @param self - The block the rule gates.\n   * @param query - The media query gating the block.\n   * @returns The media rule pairing `query` with the block.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--gutter', Calc.ref('gutter'))).pipe(\n   *   RuleSet.forMediaQuery(MediaQuery.minWidth(768)),\n   * ) // MediaRule<'gutter'>\n   * ```\n   * @since 0.2.0\n   */\n  <Refs extends string>(self: RuleSet<Refs>, query: MediaQuery): MediaRule<Refs>\n} = internal.forMediaQuery\n\n/**\n * The block's unbound reference names, unioned across members —\n * including everything nested rules contribute.\n *\n * @param set - The block to inspect.\n * @returns The set of unbound reference names.\n * @since 0.1.0\n */\nexport const refs: <Refs extends string>(set: RuleSet<Refs>) => ReadonlySet<Refs> = internal.refs\n\n/**\n * Options for `render`, extending `Declaration.RenderOptions` (and\n * through it the family base, `MediaQuery.RenderOptions`) with the\n * indentation unit — the block renderers' shared shape, which\n * `StyleRule.render` and `MediaRule.render` take unchanged.\n *\n * @since 0.1.0\n */\nexport interface RenderOptions extends DeclarationRenderOptions {\n  /**\n   * The indentation unit, applied once per nesting level. Defaults to a\n   * tab.\n   */\n  readonly indent?: string\n}\n\n/**\n * Renders the block's body — the text between a rule's braces, without\n * the braces: one line per declaration, nested `@media` rules as\n * indented sub-blocks, in member order. Empty blocks (and nested rules\n * whose blocks are empty) render as the empty string.\n *\n * A fragment renderer: use it to compose blocks the model does not\n * represent. Whole sheets render via `Stylesheet.render`.\n *\n * @param set - The block to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.\n * @example\n * ```ts\n * RuleSet.render(RuleSet.make(Declaration.make('--depth', 4), Declaration.make('color', 'red')))\n * // '--depth: 4;\\ncolor: red;'\n * ```\n * @since 0.1.0\n */\nexport const render: (set: RuleSet<string>, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The block to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: RuleSet<string>): (self: RuleSet<string>) => boolean\n  /**\n   * Structural equality over members, in order. Order participates —\n   * `make(a, b)` and `make(b, a)` are different blocks, because they\n   * cascade differently.\n   *\n   * @param self - The first block.\n   * @param that - The second block.\n   * @returns `true` if the blocks are structurally equal.\n   * @since 0.1.0\n   */\n  (self: RuleSet<string>, that: RuleSet<string>): boolean\n} = internal.equals\n","import type { Selector } from '#selector/selector'\nimport type { Pipeable } from '#util'\nimport type { RenderOptions as RuleSetRenderOptions, RuleSet } from './ruleSet.ts'\nimport type { StyleRuleTypeId } from './styleRule.internal.ts'\nimport * as internal from './styleRule.internal.ts'\n\n/**\n * A style rule: a compound selector and the block it applies.\n *\n * The block is a full `RuleSet`, so a style rule holds declarations and\n * nested `@media` rules in one authored order. The `Refs` parameter is\n * the block's — a selector contributes no reference names.\n *\n * Construct via `make`.\n *\n * @since 0.1.0\n */\nexport interface StyleRule<out Refs extends string = string> extends Pipeable {\n  readonly [StyleRuleTypeId]: StyleRuleTypeId\n  /**\n   * The compound selector the block applies to.\n   */\n  readonly selector: Selector\n  /**\n   * The rule's block.\n   */\n  readonly block: RuleSet<Refs>\n}\n\n/**\n * Checks if a value is a `StyleRule`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `StyleRule`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isStyleRule: (u: unknown) => u is StyleRule<string> = internal.isStyleRule\n\n/**\n * Creates a style rule.\n *\n * @param selector - The compound selector the block applies to.\n * @param block - The rule's block.\n * @returns A `StyleRule` carrying the block's reference names.\n * @example\n * ```ts\n * StyleRule.make(\n *   Selector.root,\n *   RuleSet.make(Declaration.make('--depth', Calc.ref('depth'))),\n * ) // StyleRule<'depth'>\n * ```\n * @since 0.1.0\n */\nexport const make: <Refs extends string>(\n  selector: Selector,\n  block: RuleSet<Refs>,\n) => StyleRule<Refs> = internal.make\n\n/**\n * The rule's unbound reference names — the block's, since a selector\n * contributes none.\n *\n * @param rule - The rule to inspect.\n * @returns The set of unbound reference names.\n * @since 0.1.0\n */\nexport const refs: <Refs extends string>(rule: StyleRule<Refs>) => ReadonlySet<Refs> = internal.refs\n\n/**\n * Options for `render` — the block renderers' shared shape,\n * `RuleSet.RenderOptions`, unchanged.\n *\n * @since 0.1.0\n */\nexport type RenderOptions = RuleSetRenderOptions\n\n/**\n * Renders the rule in nested form: `selector { ... }`, the body as\n * `RuleSet.render` emits it, one level deeper. A rule whose block is\n * empty renders as the empty string.\n *\n * A fragment renderer: whole sheets render via `Stylesheet.render`,\n * which emits each rule in this same nested shape.\n *\n * @param rule - The rule to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @throws `Error` when the block nests a style rule — selector composition (`&`) is a later extension, not part of v1 rendering.\n * @example\n * ```ts\n * StyleRule.render(StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--depth', 4))))\n * // ':root {\\n\\t--depth: 4;\\n}'\n * ```\n * @since 0.1.0\n */\nexport const render: (rule: StyleRule<string>, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The rule to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: StyleRule<string>): (self: StyleRule<string>) => boolean\n  /**\n   * Structural equality: selectors compare as in `Selector.equals`\n   * (canonically ordered parts), blocks as in `RuleSet.equals` (members\n   * in order).\n   *\n   * @param self - The first rule.\n   * @param that - The second rule.\n   * @returns `true` if the rules are structurally equal.\n   * @since 0.1.0\n   */\n  (self: StyleRule<string>, that: StyleRule<string>): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,cAAsDA;;;;;;;;;;;;;;;;AAiBnE,MAAaC,SAGUC;;;;;;;;;AAUvB,MAAaC,SAA0EC;;;;;;;;;;;;;;;;;;;;;;;AAgCvF,MAAaC,WAAuEC;AAEpF,MAAaC,WAoBTC;;;;;;;;;;;;;;;;;;;;;;;;;;AChDJ,MAAa,YAAkDC;;;;;;AAO/D,MAAa,QAAwBC;;;;;;;;;;;;AAarC,MAAa,UAA6CC;;;;;;;;;;;;;;;AAgB1D,MAAaC,SAE+BC;AAE5C,MAAa,SAmGTC;AAEJ,MAAa,SAoBTC;AAEJ,MAAa,cA6BTC;AAEJ,MAAa,gBA6BTC;;;;;;;;;AAUJ,MAAaC,SAAuEC;;;;;;;;;;;;;;;;;;;;;AAsCpF,MAAaC,WAAoEC;AAEjF,MAAaC,WAoBTC;;;;;;;;;;;;;;;;;;;;AC3UJ,MAAa,cAAsDC;;;;;;;;;;;;;;;;AAiBnE,MAAa,OAGUC;;;;;;;;;AAUvB,MAAa,OAA0EC;;;;;;;;;;;;;;;;;;;;AA6BvF,MAAa,SAAuEC;AAEpF,MAAa,SAoBTC"}
+{"version":3,"file":"index.mjs","names":["internal.isMediaRule","make","internal.make","vars","internal.refs","render","internal.render","equals","internal.equals","internal.isRuleSet","internal.empty","internal.isEmpty","make","internal.make","internal.append","internal.concat","internal.forSelector","internal.forMediaQuery","vars","internal.refs","render","internal.render","equals","internal.equals","internal.isStyleRule","internal.make","internal.refs","internal.render","internal.equals"],"sources":["../../src/rule/mediaRule.ts","../../src/rule/ruleSet.ts","../../src/rule/styleRule.ts"],"sourcesContent":["import type { MediaQuery } from '#query/mediaQuery'\nimport type { Requirement } from '#selector/selector'\nimport type { Pipeable } from '#util'\nimport type { Var } from '#var'\nimport type { MediaRuleTypeId } from './mediaRule.internal.ts'\nimport * as internal from './mediaRule.internal.ts'\nimport type { RenderOptions as RuleSetRenderOptions, RuleSet } from './ruleSet.ts'\n\n/**\n * A `@media` rule: a media query and the block it gates.\n *\n * The usual position is nested — a member of an enclosing style rule's\n * block, holding declarations that apply to that rule's selector, per\n * the CSSNestedDeclarations grammar. A media rule whose block holds only\n * closed style rules may instead sit at a stylesheet's top level, the\n * authored `@media { selector { ... } }` grouping. The `Vars` parameter\n * is the block's.\n *\n * `Requires` is the block's too — a media rule has no selector of its\n * own, so it is transparent to the requirements channel. Bare\n * declarations put `Parent` in the block's requirements, which is what\n * confines a declaration-bearing media rule to nested position:\n * `Stylesheet`'s node union takes `MediaRule<Vars, never>`.\n *\n * Construct via `make`.\n *\n * @since 0.1.0\n */\nexport interface MediaRule<\n  out Vars extends Var.Any = Var.Any,\n  out Requires extends Requirement = Requirement,\n> extends Pipeable {\n  readonly [MediaRuleTypeId]: MediaRuleTypeId\n  /**\n   * The media query gating the block.\n   */\n  readonly query: MediaQuery\n  /**\n   * The rule's block.\n   */\n  readonly block: RuleSet<Vars, Requires>\n}\n\n/**\n * Checks if a value is a `MediaRule`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `MediaRule`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isMediaRule: (u: unknown) => u is MediaRule<Var.Any> = internal.isMediaRule\n\n/**\n * Creates a `@media` rule.\n *\n * @param query - The media query gating the block.\n * @param block - The rule's block. Declarations make the rule nested-only; a block of closed style rules makes it top-level-capable.\n * @returns A `MediaRule` carrying the block's variable names and requirements.\n * @example\n * ```ts\n * MediaRule.make(\n *   MediaQuery.prefersColorScheme('dark'),\n *   RuleSet.make(Declaration.make('--scheme', 'dark')),\n * )\n * ```\n * @since 0.1.0\n */\nexport const make: <Vars extends Var.Any, Requires extends Requirement>(\n  query: MediaQuery,\n  block: RuleSet<Vars, Requires>,\n) => MediaRule<Vars, Requires> = internal.make\n\n/**\n * The rule's unbound variable names — the block's, since a query\n * contributes none.\n *\n * @param rule - The rule to inspect.\n * @returns The set of unbound variable names.\n * @since 0.1.0\n */\nexport const vars: <Vars extends Var.Any>(rule: MediaRule<Vars>) => ReadonlySet<Var.Name<Vars>> =\n  internal.refs\n\n/**\n * Options for `render` — the block renderers' shared shape,\n * `RuleSet.RenderOptions`, unchanged.\n *\n * @since 0.1.0\n */\nexport type RenderOptions = RuleSetRenderOptions\n\n/**\n * Renders the rule in nested form: `@media query { ... }`, the body as\n * `RuleSet.render` emits it, one level deeper — declarations directly\n * inside the query block, the shape a media rule takes nested in a\n * style rule (CSSNestedDeclarations). A rule whose block is empty\n * renders as the empty string.\n *\n * Nested style rules render as indented sub-blocks with `&` kept\n * verbatim — native CSS nesting is the output shape.\n *\n * A fragment renderer: whole sheets render via `Stylesheet.render`,\n * which emits each rule's media in this same nested shape.\n *\n * @param rule - The rule to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @example\n * ```ts\n * MediaRule.render(\n *   MediaRule.make(MediaQuery.minWidth(768), RuleSet.make(Declaration.make('--gutter', 24))),\n * ) // '@media (min-width: 768px) {\\n\\t--gutter: 24;\\n}'\n * ```\n * @since 0.1.0\n */\nexport const render: (rule: MediaRule<Var.Any>, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The rule to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: MediaRule<Var.Any>): (self: MediaRule<Var.Any>) => boolean\n  /**\n   * Structural equality: queries compare as in `MediaQuery.equals`\n   * (canonically ordered features), blocks as in `RuleSet.equals`\n   * (members in order).\n   *\n   * @param self - The first rule.\n   * @param that - The second rule.\n   * @returns `true` if the rules are structurally equal.\n   * @since 0.1.0\n   */\n  (self: MediaRule<Var.Any>, that: MediaRule<Var.Any>): boolean\n} = internal.equals\n","import type {\n  Declaration,\n  RenderOptions as DeclarationRenderOptions,\n} from '#declaration/declaration'\nimport type { MediaQuery } from '#query/mediaQuery'\nimport type { Parent, Requirement, Selector } from '#selector/selector'\nimport type { Pipeable } from '#util'\nimport type { Var } from '#var'\nimport type { MediaRule } from './mediaRule.ts'\nimport type { RuleSetTypeId } from './ruleSet.internal.ts'\nimport * as internal from './ruleSet.internal.ts'\nimport type { StyleRule } from './styleRule.ts'\n\n/**\n * An ordered block of rule members — the nesting unit of the rule layer.\n *\n * Member order is preserved exactly as authored: never sorted, never\n * deduplicated. A block's order is cascade behavior, and since\n * CSSNestedDeclarations shipped (late 2024), declarations trailing a\n * nested rule keep their source position rather than hoisting above it —\n * so what you append is what renders.\n *\n * The `Vars` parameter unions the members' unbound variable names, as on\n * `Calc`; `vars` is the runtime set.\n *\n * The `Requires` parameter unions the members' context requirements\n * (`Selector.Requirement`, section 4.4 of `docs/design.md`): `Parent`\n * from every bare declaration and from every nested rule whose selector\n * references `&`. A style rule discharges its block's requirements\n * against its own selector; a block of closed style rules and nothing\n * else is `RuleSet<Vars, never>`, the only form a top-level `@media`\n * block may take.\n *\n * Construct via `make` (or `empty` and `append`).\n *\n * @since 0.1.0\n */\nexport interface RuleSet<\n  out Vars extends Var.Any = Var.Any,\n  out Requires extends Requirement = Requirement,\n> extends Pipeable {\n  readonly [RuleSetTypeId]: RuleSetTypeId\n  /**\n   * The block's members, in authored order.\n   */\n  readonly members: ReadonlyArray<Member<Vars, Requires>>\n}\n\n/**\n * The forms a rule block may contain: declarations, nested style rules,\n * and nested `@media` rules. `Requires` bounds the rule arms'\n * requirements; `MemberRequires` computes a member's contribution.\n *\n * Deliberately absent are the declaration-block at-rules (`@font-face`,\n * `@property`) — the CSS grammar keeps them at the top level, so this\n * union keeps them out of blocks at the type level.\n *\n * @since 0.1.0\n */\nexport type Member<Vars extends Var.Any = Var.Any, Requires extends Requirement = Requirement> =\n  | Declaration<Vars>\n  | StyleRule<Vars, Requires>\n  | MediaRule<Vars, Requires>\n\n/**\n * The unbound variable names of a `Member`, or the union of them for a\n * union of members — the type-level counterpart of `vars`, used by the\n * container constructors to thread their members' names into the result.\n *\n * @since 0.1.0\n */\nexport type MemberVars<M extends Member<Var.Any>> =\n  M extends Declaration<infer R>\n    ? R\n    : M extends StyleRule<infer R, Requirement>\n      ? R\n      : M extends MediaRule<infer R, Requirement>\n        ? R\n        : never\n\n/**\n * The requirement contribution of a `Member`, or the union of them for a\n * union of members — the type-level counterpart of the containers'\n * `Requires` parameter, used by the constructors to thread member\n * requirements into the result.\n *\n * A bare declaration contributes `Parent`: without a host selector it\n * has no subject. A style rule contributes its selector's requirements —\n * its block's are its own to discharge. A media rule is transparent and\n * contributes its block's.\n *\n * @since 0.4.0\n */\nexport type MemberRequires<M extends Member<Var.Any>> =\n  M extends Declaration<Var.Any>\n    ? Parent\n    : M extends StyleRule<Var.Any, infer R>\n      ? R\n      : M extends MediaRule<Var.Any, infer R>\n        ? R\n        : never\n\n/**\n * Checks if a value is a `RuleSet`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `RuleSet`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isRuleSet: (u: unknown) => u is RuleSet<Var.Any> = internal.isRuleSet\n\n/**\n * The empty block — the identity for `concat`.\n *\n * @since 0.1.0\n */\nexport const empty: RuleSet<never, never> = internal.empty\n\n/**\n * Checks if the block has no members.\n *\n * Structural emptiness only: a non-empty block can still *render* as the\n * empty string, when every member is a nested rule whose block renders\n * empty.\n *\n * @param set - The block to inspect.\n * @returns `true` if the block has no members.\n * @since 0.2.0\n */\nexport const isEmpty: (set: RuleSet<Var.Any>) => boolean = internal.isEmpty\n\n/**\n * Creates a rule set holding the given members, in the given order.\n *\n * @param members - Declarations and nested rules, in authored order.\n * @returns A `RuleSet` whose `Vars` unions the members' variable names and whose `Requires` unions their requirement contributions.\n * @example\n * ```ts\n * const block = RuleSet.make(\n *   Declaration.make('--depth', Calc.var('depth')),\n *   Declaration.make('color', 'oklch(0.7 0.1 250)'),\n * ) // RuleSet<'depth'>\n * ```\n * @since 0.1.0\n */\nexport const make: <Members extends ReadonlyArray<Member<Var.Any>>>(\n  ...members: Members\n) => RuleSet<MemberVars<Members[number]>, MemberRequires<Members[number]>> = internal.make\n\nexport const append: {\n  /**\n   * Returns a function that appends `member` to its argument's block.\n   *\n   * @param member - The member to append.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <M extends Member<Var.Any>>(\n    member: M,\n  ): <Vars extends Var.Any, Requires extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n  ) => RuleSet<Vars | MemberVars<M>, Requires | MemberRequires<M>>\n  /**\n   * Returns a function that appends the style rule `selector { block }`\n   * to its argument's block.\n   *\n   * @param selector - The nested rule's selector. Must reference `&` by the time an enclosing rule binds the block.\n   * @param block - The nested rule's block.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <B extends Var.Any, S extends Requirement>(\n    selector: Selector<S>,\n    block: RuleSet<B>,\n  ): <Vars extends Var.Any, Requires extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n  ) => RuleSet<Vars | B, Requires | S>\n  /**\n   * Returns a function that appends the media rule `@media query { block }`\n   * to its argument's block.\n   *\n   * @param query - The nested rule's media query.\n   * @param block - The nested rule's block.\n   * @returns A function producing the extended block.\n   * @since 0.1.0\n   */\n  <B extends Var.Any, BR extends Requirement>(\n    query: MediaQuery,\n    block: RuleSet<B, BR>,\n  ): <Vars extends Var.Any, Requires extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n  ) => RuleSet<Vars | B, Requires | BR>\n  /**\n   * Appends a member at the end of the block. The result is a new set;\n   * the original is untouched.\n   *\n   * @param self - The block to extend.\n   * @param member - The member to append.\n   * @returns The extended block, with the member's variable names joined in.\n   * @example\n   * ```ts\n   * RuleSet.empty.pipe(\n   *   RuleSet.append(Declaration.make('color', 'red')),\n   *   RuleSet.append(Declaration.make('--depth', Calc.var('depth'))),\n   * ) // RuleSet<'depth'>\n   * ```\n   * @since 0.1.0\n   */\n  <Vars extends Var.Any, Requires extends Requirement, M extends Member<Var.Any>>(\n    self: RuleSet<Vars, Requires>,\n    member: M,\n  ): RuleSet<Vars | MemberVars<M>, Requires | MemberRequires<M>>\n  /**\n   * Appends a nested style rule from its parts — sugar for\n   * `append(self, StyleRule.make(selector, block))`, so blocks compose\n   * without naming `StyleRule` at the call site.\n   *\n   * The nested rule's selector must reference `&` (`Selector.nest`) by\n   * the time an enclosing rule binds this block — `StyleRule.make`\n   * enforces it there, as the binder.\n   *\n   * @param self - The block to extend.\n   * @param selector - The nested rule's selector.\n   * @param block - The nested rule's block.\n   * @returns The extended block, with the nested block's variable names joined in.\n   * @throws `Error` when a style rule nested in `block` has a selector that does not reference `&`.\n   * @example\n   * ```ts\n   * RuleSet.empty.pipe(\n   *   RuleSet.append(\n   *     Selector.and(Selector.nest, Selector.pseudoClass('hover')),\n   *     RuleSet.make(Declaration.make('color', 'red')),\n   *   ),\n   * )\n   * ```\n   * @since 0.1.0\n   */\n  <Vars extends Var.Any, Requires extends Requirement, B extends Var.Any, S extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n    selector: Selector<S>,\n    block: RuleSet<B>,\n  ): RuleSet<Vars | B, Requires | S>\n  /**\n   * Appends a nested media rule from its parts — sugar for\n   * `append(self, MediaRule.make(query, block))`, so blocks compose\n   * without naming `MediaRule` at the call site.\n   *\n   * @param self - The block to extend.\n   * @param query - The nested rule's media query.\n   * @param block - The nested rule's block.\n   * @returns The extended block, with the nested block's variable names joined in.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--gutter', 16)).pipe(\n   *   RuleSet.append(MediaQuery.minWidth(768), RuleSet.make(Declaration.make('--gutter', 24))),\n   * )\n   * ```\n   * @since 0.1.0\n   */\n  <Vars extends Var.Any, Requires extends Requirement, B extends Var.Any, BR extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n    query: MediaQuery,\n    block: RuleSet<B, BR>,\n  ): RuleSet<Vars | B, Requires | BR>\n} = internal.append\n\nexport const concat: {\n  /**\n   * Returns a function that appends `that`'s members after its argument's.\n   *\n   * @param that - The block whose members come second.\n   * @returns A function producing the concatenated block.\n   * @since 0.1.0\n   */\n  <B extends Var.Any, BR extends Requirement>(\n    that: RuleSet<B, BR>,\n  ): <A extends Var.Any, AR extends Requirement>(self: RuleSet<A, AR>) => RuleSet<A | B, AR | BR>\n  /**\n   * Concatenates two blocks: `self`'s members followed by `that`'s, order\n   * preserved on both sides. No deduplication happens here — repeated\n   * declarations are legal CSS and their repetition is cascade behavior.\n   *\n   * @param self - The block whose members come first.\n   * @param that - The block whose members come second.\n   * @returns The concatenated block, with both sides' variable names and requirements unioned.\n   * @since 0.1.0\n   */\n  <A extends Var.Any, AR extends Requirement, B extends Var.Any, BR extends Requirement>(\n    self: RuleSet<A, AR>,\n    that: RuleSet<B, BR>,\n  ): RuleSet<A | B, AR | BR>\n} = internal.concat\n\nexport const forSelector: {\n  /**\n   * Returns a function that wraps its argument as the block of a style\n   * rule applying to `selector`.\n   *\n   * @param selector - The selector the resulting rule's block applies to.\n   * @returns A function that takes a block and returns the style rule applying it to `selector`.\n   * @since 0.2.0\n   */\n  <S extends Requirement>(\n    selector: Selector<S>,\n  ): <Vars extends Var.Any>(self: RuleSet<Vars>) => StyleRule<Vars, S>\n  /**\n   * Lifts a block into a style rule applying to `selector` — sugar for\n   * `StyleRule.make(selector, self)` with the arguments flipped, so a\n   * block built up through `pipe` caps off as a rule without naming\n   * `StyleRule` at the call site. The rule carries the block's variable\n   * names unchanged; its requirements are the selector's, the block's\n   * discharged. The binder check runs here, as in `StyleRule.make`.\n   *\n   * @param self - The block the rule applies.\n   * @param selector - The selector the block applies to.\n   * @returns The style rule pairing `selector` with the block.\n   * @throws `Error` when a style rule nested in `self` has a selector that does not reference `&`.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--depth', Calc.var('depth'))).pipe(\n   *   RuleSet.forSelector(Selector.root),\n   * ) // StyleRule<'depth'>\n   * ```\n   * @since 0.2.0\n   */\n  <Vars extends Var.Any, S extends Requirement>(\n    self: RuleSet<Vars>,\n    selector: Selector<S>,\n  ): StyleRule<Vars, S>\n} = internal.forSelector\n\nexport const forMediaQuery: {\n  /**\n   * Returns a function that wraps its argument as the block of a nested\n   * `@media` rule gated by `query`.\n   *\n   * @param query - The media query gating the resulting rule's block.\n   * @returns A function that takes a block and returns the media rule gating it by `query`.\n   * @since 0.2.0\n   */\n  (\n    query: MediaQuery,\n  ): <Vars extends Var.Any, Requires extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n  ) => MediaRule<Vars, Requires>\n  /**\n   * Lifts a block into a `@media` rule gated by `query` — sugar for\n   * `MediaRule.make(query, self)` with the arguments flipped, so a block\n   * built up through `pipe` caps off as a rule without naming\n   * `MediaRule` at the call site. The rule carries the block's variable\n   * names and requirements unchanged; a query contributes neither.\n   *\n   * @param self - The block the rule gates.\n   * @param query - The media query gating the block.\n   * @returns The media rule pairing `query` with the block.\n   * @example\n   * ```ts\n   * RuleSet.make(Declaration.make('--gutter', Calc.var('gutter'))).pipe(\n   *   RuleSet.forMediaQuery(MediaQuery.minWidth(768)),\n   * ) // MediaRule<'gutter'>\n   * ```\n   * @since 0.2.0\n   */\n  <Vars extends Var.Any, Requires extends Requirement>(\n    self: RuleSet<Vars, Requires>,\n    query: MediaQuery,\n  ): MediaRule<Vars, Requires>\n} = internal.forMediaQuery\n\n/**\n * The block's unbound variable names, unioned across members —\n * including everything nested rules contribute.\n *\n * @param set - The block to inspect.\n * @returns The set of unbound variable names.\n * @since 0.1.0\n */\nexport const vars: <Vars extends Var.Any>(set: RuleSet<Vars>) => ReadonlySet<Var.Name<Vars>> =\n  internal.refs\n\n/**\n * Options for `render`, extending `Declaration.RenderOptions` (and\n * through it the family base, `MediaQuery.RenderOptions`) with the\n * indentation unit — the block renderers' shared shape, which\n * `StyleRule.render` and `MediaRule.render` take unchanged.\n *\n * @since 0.1.0\n */\nexport interface RenderOptions extends DeclarationRenderOptions {\n  /**\n   * The indentation unit, applied once per nesting level. Defaults to a\n   * tab.\n   */\n  readonly indent?: string\n}\n\n/**\n * Renders the block's body — the text between a rule's braces, without\n * the braces: one line per declaration, nested `@media` and style rules\n * as indented sub-blocks (`&` kept verbatim), in member order. Empty\n * blocks (and nested rules whose blocks are empty) render as the empty\n * string.\n *\n * A fragment renderer: use it to compose blocks the model does not\n * represent. Whole sheets render via `Stylesheet.render`, and the binder\n * invariant on nested selectors is `StyleRule.make`'s — a free-standing\n * block renders without it.\n *\n * @param set - The block to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @example\n * ```ts\n * RuleSet.render(RuleSet.make(Declaration.make('--depth', 4), Declaration.make('color', 'red')))\n * // '--depth: 4;\\ncolor: red;'\n * ```\n * @since 0.1.0\n */\nexport const render: (set: RuleSet<Var.Any>, options?: RenderOptions) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The block to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: RuleSet<Var.Any>): (self: RuleSet<Var.Any>) => boolean\n  /**\n   * Structural equality over members, in order. Order participates —\n   * `make(a, b)` and `make(b, a)` are different blocks, because they\n   * cascade differently.\n   *\n   * @param self - The first block.\n   * @param that - The second block.\n   * @returns `true` if the blocks are structurally equal.\n   * @since 0.1.0\n   */\n  (self: RuleSet<Var.Any>, that: RuleSet<Var.Any>): boolean\n} = internal.equals\n","import type { Requirement, Selector } from '#selector/selector'\nimport type { Pipeable } from '#util'\nimport type { Var } from '#var'\nimport type { RenderOptions as RuleSetRenderOptions, RuleSet } from './ruleSet.ts'\nimport type { StyleRuleTypeId } from './styleRule.internal.ts'\nimport * as internal from './styleRule.internal.ts'\n\n/**\n * A style rule: a selector and the block it applies.\n *\n * The block is a full `RuleSet`, so a style rule holds declarations,\n * nested style rules, and nested `@media` rules in one authored order.\n * The rule is selector nesting's binder: `&` in a nested rule's selector\n * reads this rule's selector. The `Vars` parameter is the block's — a\n * selector contributes no variable names.\n *\n * `Requires` is the *selector's* requirements, not the block's: the\n * binder discharges everything its block needs, so the rule needs a\n * parent exactly when its own selector references `&`. It defaults to\n * `never` — the closed, top-level form — because that is the form\n * consumer annotations usually name.\n *\n * Construct via `make`.\n *\n * @since 0.1.0\n */\nexport interface StyleRule<\n  out Vars extends Var.Any = Var.Any,\n  out Requires extends Requirement = never,\n> extends Pipeable {\n  readonly [StyleRuleTypeId]: StyleRuleTypeId\n  /**\n   * The selector the block applies to. References `&` exactly when the\n   * rule nests inside another rule's block.\n   */\n  readonly selector: Selector<Requires>\n  /**\n   * The rule's block.\n   */\n  readonly block: RuleSet<Vars>\n}\n\n/**\n * Checks if a value is a `StyleRule`.\n *\n * True only for values built by this module's constructors, which carry\n * the brand.\n *\n * @param u - The value to check.\n * @returns `true` if the value is a `StyleRule`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isStyleRule: (u: unknown) => u is StyleRule<Var.Any, Requirement> =\n  internal.isStyleRule\n\n/**\n * Creates a style rule.\n *\n * The binder check runs here: every style rule nested in `block` —\n * directly, or inside its `@media` blocks — must reference `&` in its\n * selector, because this rule's selector is what that `&` reads. CSS\n * would silently prepend a descendant `&` instead; the model rejects\n * the shape rather than rewriting the authored selector.\n *\n * @param selector - The selector the block applies to. References `&` exactly when this rule itself nests.\n * @param block - The rule's block.\n * @returns A `StyleRule` carrying the block's variable names and the selector's requirements.\n * @throws `Error` when a style rule nested in `block` has a selector that does not reference `&`.\n * @example\n * ```ts\n * StyleRule.make(\n *   Selector.root,\n *   RuleSet.make(Declaration.make('--depth', Calc.var('depth'))),\n * ) // StyleRule<'depth'>\n * ```\n * @since 0.1.0\n */\nexport const make: <Vars extends Var.Any, S extends Requirement>(\n  selector: Selector<S>,\n  block: RuleSet<Vars>,\n) => StyleRule<Vars, S> = internal.make\n\n/**\n * The rule's unbound variable names — the block's, since a selector\n * contributes none.\n *\n * @param rule - The rule to inspect.\n * @returns The set of unbound variable names.\n * @since 0.1.0\n */\nexport const vars: <Vars extends Var.Any>(\n  rule: StyleRule<Vars, Requirement>,\n) => ReadonlySet<Var.Name<Vars>> = internal.refs\n\n/**\n * Options for `render` — the block renderers' shared shape,\n * `RuleSet.RenderOptions`, unchanged.\n *\n * @since 0.1.0\n */\nexport type RenderOptions = RuleSetRenderOptions\n\n/**\n * Renders the rule in nested form: `selector { ... }`, the body as\n * `RuleSet.render` emits it, one level deeper. Nested style rules render\n * as indented sub-blocks with `&` kept verbatim — native CSS nesting is\n * the output shape. A rule whose block is empty renders as the empty\n * string.\n *\n * A fragment renderer: whole sheets render via `Stylesheet.render`,\n * which emits each rule in this same nested shape.\n *\n * @param rule - The rule to render.\n * @param options - Optional indentation unit, precision context, and media syntax.\n * @returns Deterministic CSS text.\n * @example\n * ```ts\n * StyleRule.render(StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--depth', 4))))\n * // ':root {\\n\\t--depth: 4;\\n}'\n * ```\n * @since 0.1.0\n */\nexport const render: (rule: StyleRule<Var.Any, Requirement>, options?: RenderOptions) => string =\n  internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The rule to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: StyleRule<Var.Any, Requirement>): (self: StyleRule<Var.Any, Requirement>) => boolean\n  /**\n   * Structural equality: selectors compare as in `Selector.equals`\n   * (canonically ordered parts), blocks as in `RuleSet.equals` (members\n   * in order).\n   *\n   * @param self - The first rule.\n   * @param that - The second rule.\n   * @returns `true` if the rules are structurally equal.\n   * @since 0.1.0\n   */\n  (self: StyleRule<Var.Any, Requirement>, that: StyleRule<Var.Any, Requirement>): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqDA,MAAa,cAAuDA;;;;;;;;;;;;;;;;AAiBpE,MAAaC,SAGoBC;;;;;;;;;AAUjC,MAAaC,SACXC;;;;;;;;;;;;;;;;;;;;;;;;;AAkCF,MAAaC,WAAwEC;AAErF,MAAaC,WAoBTC;;;;;;;;;;;;;;;;;;;;;;;;;;AC5BJ,MAAa,YAAmDC;;;;;;AAOhE,MAAa,QAA+BC;;;;;;;;;;;;AAa5C,MAAa,UAA8CC;;;;;;;;;;;;;;;AAgB3D,MAAaC,SAEgEC;AAE7E,MAAa,SAmHTC;AAEJ,MAAa,SAyBTC;AAEJ,MAAa,cAoCTC;AAEJ,MAAa,gBAoCTC;;;;;;;;;AAUJ,MAAaC,SACXC;;;;;;;;;;;;;;;;;;;;;;;AAwCF,MAAaC,WAAqEC;AAElF,MAAaC,WAoBTC;;;;;;;;;;;;;;;;;;;;ACvYJ,MAAa,cACXC;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,OAGaC;;;;;;;;;AAU1B,MAAa,OAEsBC;;;;;;;;;;;;;;;;;;;;;AA8BnC,MAAa,SACXC;AAEF,MAAa,SAoBTC"}

package/dist/selector/index.d.mts

@@ -1,2 +1,2 @@
-import { n as selector_d_exports, r as specificity_d_exports } from "../shared/selector-HZY-W6l6.mjs";
+import { a as specificity_d_exports, i as selector_d_exports } from "../shared/selector-BkxnzX_6.mjs";
 export { selector_d_exports as Selector, specificity_d_exports as Specificity };