fashionable 0.3.0 → 0.4.0

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-a5m40W9E.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 };

package/dist/selector/index.mjs

@@ -1,27 +1,37 @@
 import { t as __exportAll } from "../shared/rolldown-runtime-D7D4PA-g.mjs";
-import { _ as isSpecificity$1, a as id$1, c as pseudoClass$1, d as root$1, f as specificity$1, g as equals$3, h as compare$1, i as equals$2, l as pseudoElement$1, m as universal$1, n as and$1, o as isSelector$1, p as type$1, r as attribute$1, s as not$1, t as _class$1, u as render$1, v as make$1 } from "../shared/selector.internal-ESe9s0IH.mjs";
+import { C as universal$1, D as isSpecificity$1, E as equals$3, O as make$1, S as under$1, T as compare$1, _ as render$1, a as descendant$1, b as subsequentSibling$1, c as id$1, f as nest$1, g as pseudoElement$1, h as pseudoClass$1, i as child$1, l as is$1, m as not$1, n as and$1, o as equals$2, p as nextSibling$1, r as attribute$1, s as has$1, t as _class$1, u as isSelector$1, v as root$1, w as where$1, x as type$1, y as specificity$1 } from "../shared/selector.internal-B3iu_RpX.mjs";
 //#region src/selector/selector.ts
 var selector_exports = /* @__PURE__ */ __exportAll({
 	and: () => and,
 	attribute: () => attribute,
+	child: () => child,
 	class: () => _class,
+	descendant: () => descendant,
 	equals: () => equals$1,
+	has: () => has,
 	id: () => id,
+	is: () => is,
 	isSelector: () => isSelector,
+	nest: () => nest,
+	nextSibling: () => nextSibling,
 	not: () => not,
 	pseudoClass: () => pseudoClass,
 	pseudoElement: () => pseudoElement,
 	render: () => render,
 	root: () => root,
 	specificity: () => specificity,
+	subsequentSibling: () => subsequentSibling,
 	type: () => type,
-	universal: () => universal
+	under: () => under,
+	universal: () => universal,
+	where: () => where
 });
 /**
 * Checks if a value is a `Selector`.
 *
 * True only for values built by this module's constructors, which carry
-* the brand.
+* the brand. The guard widens to `Selector<Requirement>` — it proves the
+* brand, not closedness.
 *
 * @param u - The value to check.
 * @returns `true` if the value is a `Selector`, `false` otherwise.
@@ -35,6 +45,23 @@ const isSelector = isSelector$1;
 */
 const universal = universal$1;
 /**
+* The nesting selector, `&` — a reference to the enclosing rule's
+* selector, usable anywhere a simple selector is: merged into a compound
+* (`&.active`), under a combinator (`& *`), or inside a selector list
+* (`:is(&, & *)`).
+*
+* Carrying it marks the selector `Parent`-requiring: nested style rules
+* must reference it, and top-level positions reject it. Its specificity
+* is the parent selector's, so `specificity` refuses it unresolved —
+* substitute the parent with `under` first.
+*
+* In a compound it sorts just after the type slot: a type selector must
+* come first even beside `&` (`div&`, never `&div`).
+*
+* @since 0.4.0
+*/
+const nest = nest$1;
+/**
 * Creates a type (element) selector, such as `div`.
 *
 * A compound may contain at most one type or universal selector; `and`
@@ -69,8 +96,8 @@ const _class = _class$1;
 /**
 * Creates a pseudo-class selector, rendered `:name`.
 *
-* For the functional negation pseudo-class, use `not`, which takes a
-* typed selector argument.
+* For the functional pseudo-classes over selector lists, use `is`,
+* `where`, `has`, or `not`, which take typed selector arguments.
 *
 * @param name - The pseudo-class name, without the `:` prefix. Must be non-empty.
 * @returns A one-part `Selector`.
@@ -80,19 +107,76 @@ const _class = _class$1;
 const pseudoClass = pseudoClass$1;
 const attribute = attribute$1;
 /**
-* Creates a functional negation, rendered `:not(argument)`. The argument
-* is a full compound selector, and contributes its own specificity to the
-* enclosing selector (`:not` itself contributes none).
+* Creates a matches-any pseudo-class, rendered `:is(a, b, ...)`. The
+* arguments form a selector list — compound or complex alike — and the
+* part matches an element matching any of them.
 *
-* @param argument - The selector to negate.
-* @returns A one-part `Selector`.
+* The list canonically sorts (matching is order-independent), so
+* `is(a, b)` equals `is(b, a)`. The part's specificity is its most
+* specific argument's. Requirements union across arguments — an `&`
+* inside the list marks the whole selector `Parent`-requiring.
+*
+* @param selectors - The selector list. At least one.
+* @returns A one-part `Selector` carrying the arguments' requirements.
+* @throws `Error` when called with no arguments.
+* @example
+* ```ts
+* Selector.render(Selector.is(Selector.nest, Selector.descendant(Selector.nest, Selector.universal)))
+* // ':is(&, & *)'
+* ```
+* @since 0.4.0
+*/
+const is = is$1;
+/**
+* Creates a zero-specificity matches-any pseudo-class, rendered
+* `:where(a, b, ...)`. Matching is identical to `is`; the part
+* contributes nothing to specificity regardless of its arguments.
+*
+* The list canonically sorts, and requirements union across arguments.
+*
+* @param selectors - The selector list. At least one.
+* @returns A one-part `Selector` carrying the arguments' requirements.
+* @throws `Error` when called with no arguments.
+* @since 0.4.0
+*/
+const where = where$1;
+/**
+* Creates a relational pseudo-class, rendered `:has(a, b, ...)`: the
+* part matches an element whose subtree contains a match for any
+* argument.
+*
+* Arguments are ordinary selectors — the relative forms with a leading
+* combinator (`:has(> .x)`) are not modeled. The list canonically
+* sorts, the part's specificity is its most specific argument's, and
+* requirements union across arguments.
+*
+* @param selectors - The selector list. At least one.
+* @returns A one-part `Selector` carrying the arguments' requirements.
+* @throws `Error` when called with no arguments.
+* @since 0.4.0
+*/
+const has = has$1;
+/**
+* Creates a functional negation, rendered `:not(a, b, ...)`. The
+* arguments form a selector list; the part matches an element matching
+* none of them.
+*
+* The list canonically sorts, the part's specificity is its most
+* specific argument's (`:not` itself contributes none), and
+* requirements union across arguments.
+*
+* @param selectors - The selector list to negate. At least one.
+* @returns A one-part `Selector` carrying the arguments' requirements.
+* @throws `Error` when called with no arguments.
 * @since 0.1.0
 */
 const not = not$1;
 /**
 * Creates a pseudo-element selector, rendered `::name`.
 *
-* A compound may contain at most one pseudo-element; `and` enforces this.
+* A compound may contain at most one pseudo-element; `and` enforces
+* this. No combinator may follow one — the combinator constructors
+* enforce that.
 *
 * @param name - The pseudo-element name, without the `::` prefix. Must be non-empty.
 * @returns A one-part `Selector`.
@@ -108,26 +192,38 @@ const pseudoElement = pseudoElement$1;
 */
 const root = root$1;
 const and = and$1;
+const descendant = descendant$1;
+const child = child$1;
+const nextSibling = nextSibling$1;
+const subsequentSibling = subsequentSibling$1;
+const under = under$1;
 /**
-* Computes the selector's specificity: ids into `a`;
-* classes, attributes, and pseudo-classes into `b`; types and
-* pseudo-elements into `c`. `:not(...)` adds its argument's specificity;
-* the universal selector adds nothing; duplicate parts count each time.
+* Computes the selector's specificity: ids into `a`; classes,
+* attributes, and pseudo-classes into `b`; types and pseudo-elements
+* into `c`. Compounds in a complex selector sum. `:is()`, `:has()`, and
+* `:not()` add their most specific argument; `:where()` and the
+* universal selector add nothing; duplicate parts count each time.
+*
+* Closed selectors only: an `&`-bearing selector takes its specificity
+* from the parent rule, so the parameter rejects `Parent`-requiring
+* selectors at compile time — resolve them with `under` first.
 *
 * This is what lets a consumer turn "these rules tie, so their order
 * encodes the override direction" into something checkable.
 *
-* @param selector - The selector to measure.
+* @param selector - The selector to measure. Must be closed (no `&`).
 * @returns The computed `Specificity`.
 * @since 0.1.0
 */
 const specificity = specificity$1;
 /**
-* Renders the selector as CSS text: parts concatenated in canonical
-* order — type first, then ids, classes, pseudo-classes, attributes,
-* negations, and the pseudo-element last, alphabetically within each
-* kind. Any fixed order matches identically; this one keeps root-scoped
-* shapes in their conventional spelling.
+* Renders the selector as CSS text: each compound's parts concatenated
+* in canonical order — type first, then `&`, ids, classes,
+* pseudo-classes, attributes, functional pseudo-classes, and the
+* pseudo-element last, alphabetically within each kind — and compounds
+* joined by their combinators in authored order. Any fixed part order
+* matches identically; this one keeps root-scoped shapes in their
+* conventional spelling.
 *
 * @param selector - The selector to render.
 * @returns Deterministic CSS text.