fashionable 0.0.0 → 0.2.0

package/dist/property/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["internal.isPropertyRule","internal.make","internal.inheritable","render","internal.render","equals","internal.equals","internal.isPropertySyntax","internal.universal","internal.angle","internal.color","internal.customIdent","internal.image","internal.integer","internal.length","internal.lengthPercentage","internal.number","internal.percentage","internal.resolution","internal.string","internal.time","internal.transformFunction","internal.transformList","internal.url","internal.keyword","internal.keywords","internal.oneOf","internal.listOf","internal.commaListOf","internal.render","internal.equals"],"sources":["../../src/property/propertyRule.ts","../../src/property/propertySyntax.ts"],"sourcesContent":["import type { Calc, Kind } from '#calc/calc'\nimport type { Color } from '#data/color'\nimport type { RenderOptions as DeclarationRenderOptions } from '#declaration/declaration'\nimport type { Pipeable } from '#util'\nimport type { PropertyRuleTypeId } from './propertyRule.internal.ts'\nimport * as internal from './propertyRule.internal.ts'\nimport type { PropertySyntax, Universal } from './propertySyntax.ts'\n\n/**\n * An `@property` rule: the registration that gives a custom property a\n * syntax, an inheritance behavior, and an initial value.\n *\n * A declaration-block at-rule lives at the top level of a stylesheet —\n * it is deliberately not a rule-block member, so it cannot nest.\n *\n * The registration is what turns a custom property into a typed,\n * animatable channel; a computed-property chain pairs one of these with\n * a `Declaration` writing the property and `Calc.ref` reads downstream.\n *\n * Construct via `make`.\n *\n * @since 0.1.0\n */\nexport interface PropertyRule extends Pipeable {\n  readonly [PropertyRuleTypeId]: PropertyRuleTypeId\n  /**\n   * The registered custom property name, `--` prefix included.\n   */\n  readonly name: `--${string}`\n  /**\n   * The modeled `syntax` descriptor; `render` emits it single-quoted.\n   */\n  readonly syntax: PropertySyntax\n  /**\n   * The `inherits` descriptor. `make` registers `false`; `inheritable`\n   * flips it.\n   */\n  readonly inherits: boolean\n  /**\n   * The `initial-value` descriptor: literal text or a closed expression.\n   * Absent only under the universal syntax.\n   */\n  readonly initialValue: Value | undefined\n}\n\n/**\n * The value forms an `initial-value` descriptor can hold once\n * constructed. The closed (`never`-ref) parameter is the spec rule in the\n * types: `@property` initial values must be computationally independent, so\n * only closed expressions — no unbound references — are accepted. A `Calc`\n * of any dimension is admitted here; `make` narrows to the forms the declared\n * syntax accepts (the syntax's `V` parameter), where a `<length>` is limited\n * to absolute units.\n *\n * @since 0.1.0\n */\nexport type Value = string | Calc<never, Kind, unknown> | Color<never>\n\n/**\n * Options for `render`, in the render-options family rooted at\n * `MediaQuery.RenderOptions` (via `Declaration.RenderOptions`). This\n * renderer consumes `indent` and the inherited `precision` (for an\n * expression-valued `initial-value`); `mediaSyntax` is accepted and\n * ignored.\n *\n * @since 0.1.0\n */\nexport interface RenderOptions extends DeclarationRenderOptions {\n  /**\n   * The indentation unit for the block's declarations. Defaults to a tab.\n   */\n  readonly indent?: string\n}\n\n/**\n * Checks if a value is a `PropertyRule`.\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 `PropertyRule`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isPropertyRule: (u: unknown) => u is PropertyRule = internal.isPropertyRule\n\nexport const make: {\n  /**\n   * Registers under the universal syntax — the default when `syntax` is\n   * omitted — where the initial value is optional.\n   *\n   * @param name - The custom property name to register, `--` prefix included.\n   * @param syntax - The universal syntax; omit for the same effect.\n   * @param initialValue - Optional under the universal syntax: any value form.\n   * @returns A `PropertyRule` with `inherits: false`.\n   * @throws `Error` when `name` is not a `--`-prefixed custom property name (bare `--` included), or an expression value has unbound references.\n   * @since 0.1.0\n   */\n  (name: `--${string}`, syntax?: Universal, initialValue?: Value | number): PropertyRule\n  /**\n   * Creates an `@property` rule.\n   *\n   * The syntax value types the initial value: only forms the syntax\n   * accepts are admitted — numbers and closed `Calc` expressions under\n   * `PropertySyntax.number`, exactly the declared literals under a\n   * keyword set, and so on — and the computational-independence rule\n   * rides along, since an expression with unbound references is not a\n   * `Calc<never>` (backed by a runtime check for untyped callers). Bare\n   * numbers coerce to unannotated constants. That literal-text values\n   * parse under the syntax is not checked — this library does not parse\n   * CSS.\n   *\n   * Rules register with `inherits: false`; pipe through `inheritable` to\n   * opt in.\n   *\n   * @param name - The custom property name to register, `--` prefix included.\n   * @param syntax - The modeled `syntax` descriptor; see `PropertySyntax`.\n   * @param initialValue - The `initial-value` descriptor, required for every non-universal syntax and typed by it.\n   * @returns A `PropertyRule` with `inherits: false`.\n   * @throws `Error` when `name` is not a `--`-prefixed custom property name (bare `--` included), `initialValue` is missing under a non-universal syntax, or an expression value has unbound references.\n   * @example\n   * ```ts\n   * PropertyRule.make('--depth', PropertySyntax.number, 0)\n   * ```\n   * @since 0.1.0\n   */\n  <V extends Value | number>(\n    name: `--${string}`,\n    syntax: PropertySyntax<V>,\n    initialValue: NoInfer<V>,\n  ): PropertyRule\n} = internal.make\n\n/**\n * Registers the rule as inheriting. `make` constructs every rule with\n * `inherits: false` — the safe default for computed channels, where\n * inheritance would leak intermediate values down the tree — so\n * inheritance is an explicit opt-in.\n *\n * @param rule - The rule to opt in.\n * @returns The inheriting rule; the same rule when it already inherits.\n * @example\n * ```ts\n * PropertyRule.make('--fill', PropertySyntax.color, 'red').pipe(PropertyRule.inheritable)\n * ```\n * @since 0.1.0\n */\nexport const inheritable: (rule: PropertyRule) => PropertyRule = internal.inheritable\n\n/**\n * Renders the rule as a complete `@property --name { ... }` block, the\n * descriptors in fixed order: `syntax`, `inherits`, `initial-value`.\n *\n * @param rule - The rule to render.\n * @param options - Optional indentation unit and precision context.\n * @returns Deterministic CSS text.\n * @example\n * ```ts\n * PropertyRule.render(PropertyRule.make('--depth', PropertySyntax.number, 0))\n * // \"@property --depth {\\n\\tsyntax: '<number>';\\n\\tinherits: false;\\n\\tinitial-value: 0;\\n}\"\n * ```\n * @since 0.1.0\n */\nexport const render: (rule: PropertyRule, 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: PropertyRule): (self: PropertyRule) => boolean\n  /**\n   * Structural equality: `name` and `inherits` compare as data, the\n   * syntax as its modeled grammar (`PropertySyntax.equals` semantics),\n   * and expression initial values as expression trees (`Calc.equals`\n   * semantics). Literal text never equals an expression.\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: PropertyRule, that: PropertyRule): boolean\n} = internal.equals\n","import type { Calc, Kind } from '#calc/calc'\nimport type { Color } from '#data/color'\nimport type { AbsoluteLength, Angle, Percentage } from '#data/units'\nimport type { Pipeable } from '#util'\nimport type { PropertySyntaxTypeId } from './propertySyntax.internal.ts'\nimport * as internal from './propertySyntax.internal.ts'\n\ndeclare const AcceptedValue: unique symbol\ndeclare const UniversalMarker: unique symbol\n\n/**\n * A modeled `@property` syntax descriptor: the universal syntax, a data\n * type, a keyword, a multiplied list, or a `|` combination of these.\n *\n * The point of modeling the descriptor as a value is twofold. The\n * supported grammar becomes discoverable — the data types are constants\n * (`number`, `color`, `lengthPercentage`, ...), and the combinators\n * (`keyword`, `oneOf`, `listOf`, `commaListOf`) enforce the grammar's\n * constraints at construction. And the `V` parameter tracks the\n * initial-value forms the syntax accepts, so `PropertyRule.make` can\n * type its `initialValue` from the syntax it is registered under.\n *\n * Construct via the data type constants, `universal`, `keyword`,\n * `keywords`, `oneOf`, `listOf`, and `commaListOf`.\n *\n * @since 0.1.0\n */\nexport interface PropertySyntax<out V = Value> extends Pipeable {\n  readonly [PropertySyntaxTypeId]: PropertySyntaxTypeId\n  readonly [AcceptedValue]?: V\n}\n\n/**\n * The full initial-value domain — what the universal syntax accepts.\n * Individual syntaxes narrow this: number-land syntaxes take numbers and\n * closed `Calc` expressions, dimensioned syntaxes take a closed `Calc` of\n * their kind (a `<length>` initial value must be computationally independent,\n * so only absolute units), `color` takes closed `Color` expressions or text,\n * keyword sets take exactly their literals, and the rest take literal text.\n *\n * @since 0.1.0\n */\nexport type Value = string | number | Calc<never, Kind, unknown> | Color<never>\n\n/**\n * The initial-value forms a syntax accepts — the type-level counterpart\n * of the `V` parameter, extracted from a syntax (or union of syntaxes).\n *\n * @since 0.1.0\n */\nexport type ValueOf<S extends PropertySyntax<unknown>> =\n  S extends PropertySyntax<infer V> ? V : never\n\n/**\n * Checks if a value is a `PropertySyntax`.\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 `PropertySyntax`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isPropertySyntax: (u: unknown) => u is PropertySyntax = internal.isPropertySyntax\n\n/**\n * The type of `universal` alone. Naming it lets `PropertyRule.make`\n * recognize the universal syntax in overload resolution — the one syntax\n * under which the initial value is optional.\n *\n * @since 0.1.0\n */\nexport interface Universal extends PropertySyntax<Value> {\n  readonly [UniversalMarker]: true\n}\n\n/**\n * The universal syntax, `*` — any value at all. The one syntax under\n * which `@property` may omit its initial value.\n *\n * @since 0.1.0\n */\nexport const universal: Universal = internal.universal\n\n/**\n * The `<angle>` data type. Initial values are a closed angle-kind `Calc`\n * (`Angle.rad(...)`) or literal text carrying an angle unit (`'90deg'`).\n *\n * @since 0.1.0\n */\nexport const angle: PropertySyntax<string | Calc<never, 'angle', Angle>> = internal.angle\n\n/**\n * The `<color>` data type. Initial values are closed `Color` expressions\n * or literal text (`'transparent'`, `'#fff'`).\n *\n * @since 0.1.0\n */\nexport const color: PropertySyntax<string | Color<never>> = internal.color\n\n/**\n * The `<custom-ident>` data type — any custom identifier. To accept a\n * fixed set of identifiers instead, combine `keyword` values with\n * `oneOf`.\n *\n * @since 0.1.0\n */\nexport const customIdent: PropertySyntax<string> = internal.customIdent\n\n/**\n * The `<image>` data type. Initial values are literal text.\n *\n * @since 0.1.0\n */\nexport const image: PropertySyntax<string> = internal.image\n\n/**\n * The `<integer>` data type. Initial values are numbers or closed `Calc`\n * expressions; that the value is a whole number is the browser's parse\n * check, not this library's.\n *\n * @since 0.1.0\n */\nexport const integer: PropertySyntax<number | Calc<never>> = internal.integer\n\n/**\n * The `<length>` data type. Initial values are a closed length-kind `Calc`\n * (`Length.px(8)`) or literal text carrying a length unit (`'8px'` — a bare\n * `0` is not a valid registered length). An `@property` initial value must be\n * computationally independent, so an expression may carry only absolute units\n * (`px`) — a viewport- or font-relative length (`Length.vw(8)`) is rejected.\n *\n * @since 0.1.0\n */\nexport const length: PropertySyntax<string | Calc<never, 'length', AbsoluteLength>> =\n  internal.length\n\n/**\n * The `<length-percentage>` data type. Initial values are a closed\n * absolute-length or percentage `Calc`, or literal text.\n *\n * @since 0.1.0\n */\nexport const lengthPercentage: PropertySyntax<\n  string | Calc<never, 'length', AbsoluteLength> | Calc<never, 'percentage', Percentage>\n> = internal.lengthPercentage\n\n/**\n * The `<number>` data type. Initial values are numbers or closed `Calc`\n * expressions — the typed channel this library models; text is not\n * accepted where the number form exists.\n *\n * @since 0.1.0\n */\nexport const number: PropertySyntax<number | Calc<never>> = internal.number\n\n/**\n * The `<percentage>` data type. Initial values are a closed percentage-kind\n * `Calc` (`Percentage.of(50)`) or literal text carrying the `%` unit (`'50%'`).\n *\n * @since 0.1.0\n */\nexport const percentage: PropertySyntax<string | Calc<never, 'percentage', Percentage>> =\n  internal.percentage\n\n/**\n * The `<resolution>` data type. Initial values are literal text.\n *\n * @since 0.1.0\n */\nexport const resolution: PropertySyntax<string> = internal.resolution\n\n/**\n * The `<string>` data type. Initial values are literal text including\n * their own quotes (`'\"hello\"'`).\n *\n * @since 0.1.0\n */\nexport const string: PropertySyntax<string> = internal.string\n\n/**\n * The `<time>` data type. Initial values are literal text carrying a\n * time unit (`'200ms'`).\n *\n * @since 0.1.0\n */\nexport const time: PropertySyntax<string> = internal.time\n\n/**\n * The `<transform-function>` data type. Initial values are literal text.\n *\n * @since 0.1.0\n */\nexport const transformFunction: PropertySyntax<string> = internal.transformFunction\n\n/**\n * The `<transform-list>` data type — a list of transform functions. It\n * is pre-multiplied, so `listOf`/`commaListOf` reject it. Initial values\n * are literal text.\n *\n * @since 0.1.0\n */\nexport const transformList: PropertySyntax<string> = internal.transformList\n\n/**\n * The `<url>` data type. Initial values are literal text.\n *\n * @since 0.1.0\n */\nexport const url: PropertySyntax<string> = internal.url\n\n/**\n * A keyword component: one specific custom identifier, rendered bare.\n * Combined under `oneOf`, keywords give the registered property an\n * enum-like domain — and the `V` parameter carries the literal, so\n * `initialValue` autocompletes and checks against exactly the declared\n * set.\n *\n * @param name - The identifier. Must be non-empty and not a CSS-wide keyword (`inherit`, `initial`, `unset`, `revert`, `revert-layer`, `default`), which the specification excludes.\n * @returns A `PropertySyntax` accepting exactly `name`.\n * @throws `Error` when `name` is empty or a CSS-wide keyword.\n * @since 0.1.0\n */\nexport const keyword: <const K extends string>(name: K) => PropertySyntax<K> = internal.keyword\n\n/**\n * A keyword set: shorthand for `oneOf` over `keyword` values, accepting\n * — and narrowing `initialValue` to — exactly the given identifiers. A\n * single name is just that `keyword`.\n *\n * @param names - One or more identifiers, each under `keyword`'s constraints.\n * @returns A `PropertySyntax` accepting exactly the given names.\n * @throws `Error` when a name is empty or a CSS-wide keyword.\n * @example\n * ```ts\n * const size = PropertySyntax.keywords('small', 'medium', 'large')\n * PropertySyntax.render(size) // 'small | medium | large'\n * PropertyRule.make('--size', size, 'medium') // initialValue checks against the three names\n * ```\n * @since 0.1.0\n */\nexport const keywords: <const Names extends readonly [string, ...ReadonlyArray<string>]>(\n  ...names: Names\n) => PropertySyntax<Names[number]> = internal.keywords\n\n/**\n * A `|` combination: the value may satisfy any one of the components,\n * tried in order — authored order is preserved (it is parse order, so\n * `'<length> | auto'` and `'auto | <length>'` are different syntaxes).\n * Nested combinations flatten into the enclosing one.\n *\n * @param components - Two or more components. The universal syntax stands alone and may not join a combination.\n * @returns A `PropertySyntax` accepting any component's values, unioned in `V`.\n * @throws `Error` when a component is the universal syntax.\n * @example\n * ```ts\n * const size = PropertySyntax.oneOf(PropertySyntax.keyword('small'), PropertySyntax.keyword('large'))\n * PropertySyntax.render(size) // 'small | large'\n * PropertyRule.make('--size', size, 'small') // initialValue is 'small' | 'large' only\n * ```\n * @since 0.1.0\n */\nexport const oneOf: <\n  const Components extends readonly [\n    PropertySyntax<unknown>,\n    PropertySyntax<unknown>,\n    ...ReadonlyArray<PropertySyntax<unknown>>,\n  ],\n>(\n  ...components: Components\n) => PropertySyntax<ValueOf<Components[number]>> = internal.oneOf\n\n/**\n * A space-separated list of one component, rendered with the `+`\n * multiplier (`'<length>+'`).\n *\n * A one-item list is valid, so the component's own value forms stay\n * accepted; longer lists are literal text.\n *\n * @param component - The repeated component. Must be a single unmultiplied component — not the universal syntax, a combination, a list, or the pre-multiplied `transformList`.\n * @returns A `PropertySyntax` accepting the component's values or list text.\n * @throws `Error` when the component cannot take a multiplier.\n * @since 0.1.0\n */\nexport const listOf: <V>(component: PropertySyntax<V>) => PropertySyntax<V | (string & {})> =\n  internal.listOf\n\n/**\n * A comma-separated list of one component, rendered with the `#`\n * multiplier (`'<color>#'`). Constraints match `listOf`.\n *\n * @param component - The repeated component. Must be a single unmultiplied component — not the universal syntax, a combination, a list, or the pre-multiplied `transformList`.\n * @returns A `PropertySyntax` accepting the component's values or list text.\n * @throws `Error` when the component cannot take a multiplier.\n * @since 0.1.0\n */\nexport const commaListOf: <V>(component: PropertySyntax<V>) => PropertySyntax<V | (string & {})> =\n  internal.commaListOf\n\n/**\n * Renders the syntax as its descriptor string, unquoted: `'*'`,\n * `'<number>'`, `'<length>+'`, `'small | large'`. `PropertyRule.render`\n * wraps this in the quotes the descriptor requires.\n *\n * @param syntax - The syntax to render.\n * @returns Deterministic descriptor text.\n * @since 0.1.0\n */\nexport const render: (syntax: PropertySyntax) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The syntax to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: PropertySyntax): (self: PropertySyntax) => boolean\n  /**\n   * Structural equality over the modeled grammar. Combination order\n   * participates — it is parse order.\n   *\n   * @param self - The first syntax.\n   * @param that - The second syntax.\n   * @returns `true` if the syntaxes are structurally equal.\n   * @since 0.1.0\n   */\n  (self: PropertySyntax, that: PropertySyntax): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoFA,MAAa,iBAAoDA;AAEjE,MAAa,OA6CTC;;;;;;;;;;;;;;;AAgBJ,MAAa,cAAoDC;;;;;;;;;;;;;;;AAgBjE,MAAaC,WAAkEC;AAE/E,MAAaC,WAqBTC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3HJ,MAAa,mBAAwDC;;;;;;;AAmBrE,MAAa,YAAuBC;;;;;;;AAQpC,MAAa,QAA8DC;;;;;;;AAQ3E,MAAa,QAA+CC;;;;;;;;AAS5D,MAAa,cAAsCC;;;;;;AAOnD,MAAa,QAAgCC;;;;;;;;AAS7C,MAAa,UAAgDC;;;;;;;;;;AAW7D,MAAa,SACXC;;;;;;;AAQF,MAAa,mBAETC;;;;;;;;AASJ,MAAa,SAA+CC;;;;;;;AAQ5D,MAAa,aACXC;;;;;;AAOF,MAAa,aAAqCC;;;;;;;AAQlD,MAAa,SAAiCC;;;;;;;AAQ9C,MAAa,OAA+BC;;;;;;AAO5C,MAAa,oBAA4CC;;;;;;;;AASzD,MAAa,gBAAwCC;;;;;;AAOrD,MAAa,MAA8BC;;;;;;;;;;;;;AAc3C,MAAa,UAAkEC;;;;;;;;;;;;;;;;;AAkB/E,MAAa,WAEwBC;;;;;;;;;;;;;;;;;;AAmBrC,MAAa,QAQsCC;;;;;;;;;;;;;AAcnD,MAAa,SACXC;;;;;;;;;;AAWF,MAAa,cACXC;;;;;;;;;;AAWF,MAAa,SAA6CC;AAE1D,MAAa,SAmBTC"}

package/dist/query/index.d.mts

@@ -0,0 +1,2 @@
+import { r as mediaQuery_d_exports } from "../shared/mediaQuery-BYR1z-iD.mjs";
+export { mediaQuery_d_exports as MediaQuery };

package/dist/query/index.mjs

@@ -0,0 +1,62 @@
+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";
+//#region src/query/mediaQuery.ts
+var mediaQuery_exports = /* @__PURE__ */ __exportAll({
+	and: () => and,
+	equals: () => equals,
+	isMediaQuery: () => isMediaQuery,
+	minWidth: () => minWidth,
+	prefersColorScheme: () => prefersColorScheme,
+	render: () => render
+});
+/**
+* Checks if a value is a `MediaQuery`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `MediaQuery`, `false` otherwise.
+* @since 0.1.0
+*/
+const isMediaQuery = isMediaQuery$1;
+/**
+* Creates a viewport-width lower bound.
+*
+* @param px - The threshold in CSS pixels. Must be a non-negative finite number.
+* @returns A one-feature `MediaQuery`.
+* @throws `Error` when `px` is negative or not finite.
+* @example
+* ```ts
+* MediaQuery.render(MediaQuery.minWidth(768)) // '(min-width: 768px)'
+* MediaQuery.render(MediaQuery.minWidth(768), { mediaSyntax: 'range' }) // '(width >= 768px)'
+* ```
+* @since 0.1.0
+*/
+const minWidth = minWidth$1;
+/**
+* Creates a `prefers-color-scheme` condition.
+*
+* @param scheme - The scheme to match, `'dark'` or `'light'`.
+* @returns A one-feature `MediaQuery`.
+* @since 0.1.0
+*/
+const prefersColorScheme = prefersColorScheme$1;
+const and = and$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
+* (default `'prefix'`).
+*
+* @param query - The query to render.
+* @param options - Optional syntax selection.
+* @returns Deterministic CSS text, without the `@media ` prefix.
+* @since 0.1.0
+*/
+const render = render$1;
+const equals = equals$1;
+//#endregion
+export { mediaQuery_exports as MediaQuery };
+
+//# sourceMappingURL=index.mjs.map

package/dist/query/index.mjs.map

@@ -0,0 +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"}

package/dist/rule/index.d.mts

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

package/dist/rule/index.mjs

@@ -0,0 +1,234 @@
+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";
+//#region src/rule/mediaRule.ts
+var mediaRule_exports = /* @__PURE__ */ __exportAll({
+	equals: () => equals$2,
+	isMediaRule: () => isMediaRule,
+	make: () => make$2,
+	refs: () => refs$2,
+	render: () => render$2
+});
+/**
+* Checks if a value is a `MediaRule`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `MediaRule`, `false` otherwise.
+* @since 0.1.0
+*/
+const isMediaRule = isMediaRule$1;
+/**
+* Creates a nested `@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.
+* @example
+* ```ts
+* MediaRule.make(
+*   MediaQuery.prefersColorScheme('dark'),
+*   RuleSet.make(Declaration.make('--scheme', 'dark')),
+* )
+* ```
+* @since 0.1.0
+*/
+const make$2 = make$3;
+/**
+* The rule's unbound reference names — the block's, since a query
+* contributes none.
+*
+* @param rule - The rule to inspect.
+* @returns The set of unbound reference names.
+* @since 0.1.0
+*/
+const refs$2 = refs$3;
+/**
+* Renders the rule in nested form: `@media query { ... }`, the body as
+* `RuleSet.render` emits it, one level deeper — declarations directly
+* inside the query block, the shape a media rule takes nested in a
+* style rule (CSSNestedDeclarations). A rule whose block is empty
+* renders as the empty string.
+*
+* 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(
+*   MediaRule.make(MediaQuery.minWidth(768), RuleSet.make(Declaration.make('--gutter', 24))),
+* ) // '@media (min-width: 768px) {\n\t--gutter: 24;\n}'
+* ```
+* @since 0.1.0
+*/
+const render$2 = render$3;
+const equals$2 = equals$3;
+//#endregion
+//#region src/rule/ruleSet.ts
+var ruleSet_exports = /* @__PURE__ */ __exportAll({
+	append: () => append,
+	concat: () => concat,
+	empty: () => empty,
+	equals: () => equals$1,
+	forMediaQuery: () => forMediaQuery,
+	forSelector: () => forSelector,
+	isEmpty: () => isEmpty,
+	isRuleSet: () => isRuleSet,
+	make: () => make$1,
+	refs: () => refs$1,
+	render: () => render$1
+});
+/**
+* Checks if a value is a `RuleSet`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `RuleSet`, `false` otherwise.
+* @since 0.1.0
+*/
+const isRuleSet = isRuleSet$1;
+/**
+* The empty block — the identity for `concat`.
+*
+* @since 0.1.0
+*/
+const empty = empty$1;
+/**
+* Checks if the block has no members.
+*
+* Structural emptiness only: a non-empty block can still *render* as the
+* empty string, when every member is a nested rule whose block renders
+* empty.
+*
+* @param set - The block to inspect.
+* @returns `true` if the block has no members.
+* @since 0.2.0
+*/
+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.
+* @example
+* ```ts
+* const block = RuleSet.make(
+*   Declaration.make('--depth', Calc.ref('depth')),
+*   Declaration.make('color', 'oklch(0.7 0.1 250)'),
+* ) // RuleSet<'depth'>
+* ```
+* @since 0.1.0
+*/
+const make$1 = make$4;
+const append = append$1;
+const concat = concat$1;
+const forSelector = forSelector$1;
+const forMediaQuery = forMediaQuery$1;
+/**
+* The block's unbound reference names, unioned across members —
+* including everything nested rules contribute.
+*
+* @param set - The block to inspect.
+* @returns The set of unbound reference names.
+* @since 0.1.0
+*/
+const refs$1 = refs$4;
+/**
+* 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.
+*
+* A fragment renderer: use it to compose blocks the model does not
+* represent. Whole sheets render via `Stylesheet.render`.
+*
+* @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')))
+* // '--depth: 4;\ncolor: red;'
+* ```
+* @since 0.1.0
+*/
+const render$1 = render$4;
+const equals$1 = equals$4;
+//#endregion
+//#region src/rule/styleRule.ts
+var styleRule_exports = /* @__PURE__ */ __exportAll({
+	equals: () => equals,
+	isStyleRule: () => isStyleRule,
+	make: () => make,
+	refs: () => refs,
+	render: () => render
+});
+/**
+* Checks if a value is a `StyleRule`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `StyleRule`, `false` otherwise.
+* @since 0.1.0
+*/
+const isStyleRule = isStyleRule$1;
+/**
+* Creates a style rule.
+*
+* @param selector - The compound selector the block applies to.
+* @param block - The rule's block.
+* @returns A `StyleRule` carrying the block's reference names.
+* @example
+* ```ts
+* StyleRule.make(
+*   Selector.root,
+*   RuleSet.make(Declaration.make('--depth', Calc.ref('depth'))),
+* ) // StyleRule<'depth'>
+* ```
+* @since 0.1.0
+*/
+const make = make$5;
+/**
+* The rule's unbound reference names — the block's, since a selector
+* contributes none.
+*
+* @param rule - The rule to inspect.
+* @returns The set of unbound reference names.
+* @since 0.1.0
+*/
+const refs = refs$5;
+/**
+* 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.
+*
+* A fragment renderer: whole sheets render via `Stylesheet.render`,
+* which emits each rule 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
+* StyleRule.render(StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--depth', 4))))
+* // ':root {\n\t--depth: 4;\n}'
+* ```
+* @since 0.1.0
+*/
+const render = render$5;
+const equals = equals$5;
+//#endregion
+export { mediaRule_exports as MediaRule, ruleSet_exports as RuleSet, styleRule_exports as StyleRule };
+
+//# sourceMappingURL=index.mjs.map

package/dist/rule/index.mjs.map

@@ -0,0 +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"}

package/dist/selector/index.d.mts

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

package/dist/selector/index.mjs

@@ -0,0 +1,178 @@
+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";
+//#region src/selector/selector.ts
+var selector_exports = /* @__PURE__ */ __exportAll({
+	and: () => and,
+	attribute: () => attribute,
+	class: () => _class,
+	equals: () => equals$1,
+	id: () => id,
+	isSelector: () => isSelector,
+	not: () => not,
+	pseudoClass: () => pseudoClass,
+	pseudoElement: () => pseudoElement,
+	render: () => render,
+	root: () => root,
+	specificity: () => specificity,
+	type: () => type,
+	universal: () => universal
+});
+/**
+* Checks if a value is a `Selector`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `Selector`, `false` otherwise.
+* @since 0.1.0
+*/
+const isSelector = isSelector$1;
+/**
+* The universal selector, `*`. Contributes nothing to specificity.
+*
+* @since 0.1.0
+*/
+const universal = universal$1;
+/**
+* Creates a type (element) selector, such as `div`.
+*
+* A compound may contain at most one type or universal selector; `and`
+* enforces this.
+*
+* @param name - The element name. Must be non-empty; passed through unescaped.
+* @returns A one-part `Selector`.
+* @throws `Error` when `name` is empty.
+* @since 0.1.0
+*/
+const type = type$1;
+/**
+* Creates an id selector, rendered `#name`.
+*
+* @param name - The id, without the `#` prefix. Must be non-empty; passed through unescaped.
+* @returns A one-part `Selector`.
+* @throws `Error` when `name` is empty.
+* @since 0.1.0
+*/
+const id = id$1;
+/**
+* Creates a class selector, rendered `.name`. Exported as `class`
+* (`Selector.class('btn')`) because `class` is reserved in declaration
+* position.
+*
+* @param name - The class name, without the `.` prefix. Must be non-empty; passed through unescaped.
+* @returns A one-part `Selector`.
+* @throws `Error` when `name` is empty.
+* @since 0.1.0
+*/
+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.
+*
+* @param name - The pseudo-class name, without the `:` prefix. Must be non-empty.
+* @returns A one-part `Selector`.
+* @throws `Error` when `name` is empty.
+* @since 0.1.0
+*/
+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).
+*
+* @param argument - The selector to negate.
+* @returns A one-part `Selector`.
+* @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.
+*
+* @param name - The pseudo-element name, without the `::` prefix. Must be non-empty.
+* @returns A one-part `Selector`.
+* @throws `Error` when `name` is empty.
+* @since 0.1.0
+*/
+const pseudoElement = pseudoElement$1;
+/**
+* The `:root` pseudo-class selector — sugar for `pseudoClass('root')`,
+* the usual anchor for custom-property rules.
+*
+* @since 0.1.0
+*/
+const root = root$1;
+const and = and$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.
+*
+* 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.
+* @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.
+*
+* @param selector - The selector to render.
+* @returns Deterministic CSS text.
+* @example
+* ```ts
+* Selector.render(Selector.and(Selector.pseudoClass('hover'), Selector.class('btn')))
+* // '.btn:hover'
+* ```
+* @since 0.1.0
+*/
+const render = render$1;
+const equals$1 = equals$2;
+//#endregion
+//#region src/selector/specificity.ts
+var specificity_exports = /* @__PURE__ */ __exportAll({
+	compare: () => compare,
+	equals: () => equals,
+	isSpecificity: () => isSpecificity,
+	make: () => make
+});
+/**
+* Checks if a value is a `Specificity`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `Specificity`, `false` otherwise.
+* @since 0.1.0
+*/
+const isSpecificity = isSpecificity$1;
+/**
+* Creates a `Specificity` from its three components.
+*
+* @param a - The id-selector count. Must be a non-negative integer.
+* @param b - The class/attribute/pseudo-class count. Must be a non-negative integer.
+* @param c - The type/pseudo-element count. Must be a non-negative integer.
+* @returns A new `Specificity`.
+* @throws `Error` when any component is not a non-negative integer.
+* @since 0.1.0
+*/
+const make = make$1;
+const compare = compare$1;
+const equals = equals$3;
+//#endregion
+export { selector_exports as Selector, specificity_exports as Specificity };
+
+//# sourceMappingURL=index.mjs.map

package/dist/selector/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["internal.isSelector","internal.universal","internal.type","internal.id","internal._class","internal.pseudoClass","internal.attribute","internal.not","internal.pseudoElement","internal.root","internal.and","internal.specificity","internal.render","equals","internal.equals","internal.isSpecificity","internal.make","internal.compare","internal.equals"],"sources":["../../src/selector/selector.ts","../../src/selector/specificity.ts"],"sourcesContent":["import type { Pipeable } from '#util'\nimport type { SelectorTypeId } from './selector.internal.ts'\nimport * as internal from './selector.internal.ts'\nimport type { Specificity } from './specificity.ts'\n\n/**\n * A compound selector: a canonically ordered, non-empty collection of\n * simple-selector parts, all constraining the same element.\n *\n * Part constructors (`type`, `id`, `class`, `attribute`,\n * `pseudoClass`, `not`, `pseudoElement`, `universal`) return one-part\n * selectors; `and` merges compounds. Construction canonically orders the\n * parts, so structurally equal selectors compare equal however they were\n * built, and rendering is deterministic. Duplicate parts are kept —\n * `.a.a` legally has specificity `(0, 2, 0)`.\n *\n * Combinators (descendant, child) are a later extension layered above\n * this type; a `Selector` always describes one compound.\n *\n * @since 0.1.0\n */\nexport interface Selector extends Pipeable {\n  readonly [SelectorTypeId]: SelectorTypeId\n}\n\n/**\n * CSS's six attribute-match operators: exact (`=`), word (`~=`),\n * hyphen-prefix (`|=`), prefix (`^=`), suffix (`$=`), and substring\n * (`*=`).\n *\n * @since 0.1.0\n */\nexport type AttributeOperator = '=' | '~=' | '|=' | '^=' | '$=' | '*='\n\n/**\n * Checks if a value is a `Selector`.\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 `Selector`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isSelector: (u: unknown) => u is Selector = internal.isSelector\n\n/**\n * The universal selector, `*`. Contributes nothing to specificity.\n *\n * @since 0.1.0\n */\nexport const universal: Selector = internal.universal\n\n/**\n * Creates a type (element) selector, such as `div`.\n *\n * A compound may contain at most one type or universal selector; `and`\n * enforces this.\n *\n * @param name - The element name. Must be non-empty; passed through unescaped.\n * @returns A one-part `Selector`.\n * @throws `Error` when `name` is empty.\n * @since 0.1.0\n */\nexport const type: (name: string) => Selector = internal.type\n\n/**\n * Creates an id selector, rendered `#name`.\n *\n * @param name - The id, without the `#` prefix. Must be non-empty; passed through unescaped.\n * @returns A one-part `Selector`.\n * @throws `Error` when `name` is empty.\n * @since 0.1.0\n */\nexport const id: (name: string) => Selector = internal.id\n\n/**\n * Creates a class selector, rendered `.name`. Exported as `class`\n * (`Selector.class('btn')`) because `class` is reserved in declaration\n * position.\n *\n * @param name - The class name, without the `.` prefix. Must be non-empty; passed through unescaped.\n * @returns A one-part `Selector`.\n * @throws `Error` when `name` is empty.\n * @since 0.1.0\n */\nconst _class: (name: string) => Selector = internal._class\nexport { _class as class }\n\n/**\n * Creates a pseudo-class selector, rendered `:name`.\n *\n * For the functional negation pseudo-class, use `not`, which takes a\n * typed selector argument.\n *\n * @param name - The pseudo-class name, without the `:` prefix. Must be non-empty.\n * @returns A one-part `Selector`.\n * @throws `Error` when `name` is empty.\n * @since 0.1.0\n */\nexport const pseudoClass: (name: string) => Selector = internal.pseudoClass\n\nexport const attribute: {\n  /**\n   * Creates a presence-only attribute selector, rendered `[name]`.\n   *\n   * @param name - The attribute name. Must be non-empty; passed through unescaped.\n   * @returns A one-part `Selector`.\n   * @throws `Error` when `name` is empty.\n   * @since 0.1.0\n   */\n  (name: string): Selector\n  /**\n   * Creates an exact-match attribute selector, rendered `[name='value']`.\n   * The two-argument form assumes the `=` operator.\n   *\n   * @param name - The attribute name. Must be non-empty; passed through unescaped.\n   * @param value - The value to match. Renders single-quoted with embedded quotes and backslashes escaped.\n   * @returns A one-part `Selector`.\n   * @throws `Error` when `name` is empty.\n   * @example\n   * ```ts\n   * Selector.render(Selector.attribute('data-scheme', 'dark')) // \"[data-scheme='dark']\"\n   * ```\n   * @since 0.1.0\n   */\n  (name: string, value: string): Selector\n  /**\n   * Creates an attribute selector with an explicit operator, rendered\n   * `[name<operator>'value']`.\n   *\n   * @param name - The attribute name. Must be non-empty; passed through unescaped.\n   * @param operator - One of the six `AttributeOperator` spellings.\n   * @param value - The value to match. Renders single-quoted with embedded quotes and backslashes escaped.\n   * @returns A one-part `Selector`.\n   * @throws `Error` when `name` is empty or `operator` is not an attribute operator.\n   * @example\n   * ```ts\n   * Selector.render(Selector.attribute('href', '^=', 'https:')) // \"[href^='https:']\"\n   * ```\n   * @since 0.1.0\n   */\n  (name: string, operator: AttributeOperator, value: string): Selector\n} = internal.attribute\n\n/**\n * Creates a functional negation, rendered `:not(argument)`. The argument\n * is a full compound selector, and contributes its own specificity to the\n * enclosing selector (`:not` itself contributes none).\n *\n * @param argument - The selector to negate.\n * @returns A one-part `Selector`.\n * @since 0.1.0\n */\nexport const not: (argument: Selector) => Selector = internal.not\n\n/**\n * Creates a pseudo-element selector, rendered `::name`.\n *\n * A compound may contain at most one pseudo-element; `and` enforces this.\n *\n * @param name - The pseudo-element name, without the `::` prefix. Must be non-empty.\n * @returns A one-part `Selector`.\n * @throws `Error` when `name` is empty.\n * @since 0.1.0\n */\nexport const pseudoElement: (name: string) => Selector = internal.pseudoElement\n\n/**\n * The `:root` pseudo-class selector — sugar for `pseudoClass('root')`,\n * the usual anchor for custom-property rules.\n *\n * @since 0.1.0\n */\nexport const root: Selector = internal.root\n\nexport const and: {\n  /**\n   * Returns a function that merges `that` into its argument.\n   *\n   * @param that - The selector to merge in.\n   * @returns A function producing the merged compound.\n   * @since 0.1.0\n   */\n  (that: Selector): (self: Selector) => Selector\n  /**\n   * Merges two compounds into one, constraining the same element with\n   * every part of both. Parts re-sort into canonical order, so `and` is\n   * commutative; duplicates are kept.\n   *\n   * @param self - The first compound.\n   * @param that - The second compound.\n   * @returns The merged compound.\n   * @throws `Error` when the merge would contain two type/universal selectors or two pseudo-elements.\n   * @example\n   * ```ts\n   * Selector.root.pipe(\n   *   Selector.and(Selector.attribute('data-scheme', 'dark')),\n   *   Selector.render,\n   * ) // \":root[data-scheme='dark']\"\n   * ```\n   * @since 0.1.0\n   */\n  (self: Selector, that: Selector): Selector\n} = internal.and\n\n/**\n * Computes the selector's specificity: ids into `a`;\n * classes, attributes, and pseudo-classes into `b`; types and\n * pseudo-elements into `c`. `:not(...)` adds its argument's specificity;\n * the universal selector adds nothing; duplicate parts count each time.\n *\n * This is what lets a consumer turn \"these rules tie, so their order\n * encodes the override direction\" into something checkable.\n *\n * @param selector - The selector to measure.\n * @returns The computed `Specificity`.\n * @since 0.1.0\n */\nexport const specificity: (selector: Selector) => Specificity = internal.specificity\n\n/**\n * Renders the selector as CSS text: parts concatenated in canonical\n * order — type first, then ids, classes, pseudo-classes, attributes,\n * negations, and the pseudo-element last, alphabetically within each\n * kind. Any fixed order matches identically; this one keeps root-scoped\n * shapes in their conventional spelling.\n *\n * @param selector - The selector to render.\n * @returns Deterministic CSS text.\n * @example\n * ```ts\n * Selector.render(Selector.and(Selector.pseudoClass('hover'), Selector.class('btn')))\n * // '.btn:hover'\n * ```\n * @since 0.1.0\n */\nexport const render: (selector: Selector) => string = internal.render\n\nexport const equals: {\n  /**\n   * Returns a function that checks structural equality against `that`.\n   *\n   * @param that - The selector to compare against.\n   * @returns A function testing its argument for structural equality with `that`.\n   * @since 0.1.0\n   */\n  (that: Selector): (self: Selector) => boolean\n  /**\n   * Structural equality over canonically ordered parts: two selectors\n   * built from the same parts compare equal regardless of construction\n   * order.\n   *\n   * @param self - The first selector.\n   * @param that - The second selector.\n   * @returns `true` if the selectors are structurally equal.\n   * @since 0.1.0\n   */\n  (self: Selector, that: Selector): boolean\n} = internal.equals\n","import type { Pipeable } from '#util'\nimport type { SpecificityTypeId } from './specificity.internal.ts'\nimport * as internal from './specificity.internal.ts'\n\n/**\n * A selector specificity: the `(a, b, c)` triple the cascade compares\n * lexicographically — id count, then class/attribute/pseudo-class count,\n * then type/pseudo-element count.\n *\n * Computed from selectors via `Selector.specificity`; construct directly\n * with `make` when asserting expectations.\n *\n * @since 0.1.0\n */\nexport interface Specificity extends Pipeable {\n  readonly [SpecificityTypeId]: SpecificityTypeId\n  /**\n   * The id-selector count.\n   */\n  readonly a: number\n  /**\n   * The class, attribute, and pseudo-class count.\n   */\n  readonly b: number\n  /**\n   * The type and pseudo-element count.\n   */\n  readonly c: number\n}\n\n/**\n * Checks if a value is a `Specificity`.\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 `Specificity`, `false` otherwise.\n * @since 0.1.0\n */\nexport const isSpecificity: (u: unknown) => u is Specificity = internal.isSpecificity\n\n/**\n * Creates a `Specificity` from its three components.\n *\n * @param a - The id-selector count. Must be a non-negative integer.\n * @param b - The class/attribute/pseudo-class count. Must be a non-negative integer.\n * @param c - The type/pseudo-element count. Must be a non-negative integer.\n * @returns A new `Specificity`.\n * @throws `Error` when any component is not a non-negative integer.\n * @since 0.1.0\n */\nexport const make: (a: number, b: number, c: number) => Specificity = internal.make\n\nexport const compare: {\n  /**\n   * Returns a function that compares its argument against `that`.\n   *\n   * @param that - The specificity to compare against.\n   * @returns A function returning the cascade ordering of its argument relative to `that`.\n   * @since 0.1.0\n   */\n  (that: Specificity): (self: Specificity) => -1 | 0 | 1\n  /**\n   * Compares two specificities the way the cascade does: lexicographically\n   * by `a`, then `b`, then `c`.\n   *\n   * @param self - The first specificity.\n   * @param that - The second specificity.\n   * @returns `-1` if `self` is less specific, `1` if more, `0` if equal.\n   * @example\n   * ```ts\n   * Specificity.compare(Specificity.make(1, 0, 0), Specificity.make(0, 9, 9)) // 1\n   * ```\n   * @since 0.1.0\n   */\n  (self: Specificity, that: Specificity): -1 | 0 | 1\n} = internal.compare\n\nexport const equals: {\n  /**\n   * Returns a function that checks equality against `that`.\n   *\n   * @param that - The specificity to compare against.\n   * @returns A function testing its argument for equality with `that`.\n   * @since 0.1.0\n   */\n  (that: Specificity): (self: Specificity) => boolean\n  /**\n   * Component-wise equality of two specificities.\n   *\n   * @param self - The first specificity.\n   * @param that - The second specificity.\n   * @returns `true` if all three components match.\n   * @since 0.1.0\n   */\n  (self: Specificity, that: Specificity): boolean\n} = internal.equals\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,aAA4CA;;;;;;AAOzD,MAAa,YAAsBC;;;;;;;;;;;;AAanC,MAAa,OAAmCC;;;;;;;;;AAUhD,MAAa,KAAiCC;;;;;;;;;;;AAY9C,MAAM,SAAqCC;;;;;;;;;;;;AAc3C,MAAa,cAA0CC;AAEvD,MAAa,YAyCTC;;;;;;;;;;AAWJ,MAAa,MAAwCC;;;;;;;;;;;AAYrD,MAAa,gBAA4CC;;;;;;;AAQzD,MAAa,OAAiBC;AAE9B,MAAa,MA4BTC;;;;;;;;;;;;;;AAeJ,MAAa,cAAmDC;;;;;;;;;;;;;;;;;AAkBhE,MAAa,SAAyCC;AAEtD,MAAaC,WAoBTC;;;;;;;;;;;;;;;;;;;AC3NJ,MAAa,gBAAkDC;;;;;;;;;;;AAY/D,MAAa,OAAyDC;AAEtE,MAAa,UAuBTC;AAEJ,MAAa,SAkBTC"}