fashionable 0.2.0 → 0.4.0

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.

package/dist/selector/index.mjs.map

@@ -1 +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"}
+{"version":3,"file":"index.mjs","names":["internal.isSelector","internal.universal","internal.nest","internal.type","internal.id","internal._class","internal.pseudoClass","internal.attribute","internal.is","internal.where","internal.has","internal.not","internal.pseudoElement","internal.root","internal.and","internal.descendant","internal.child","internal.nextSibling","internal.subsequentSibling","internal.under","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\ndeclare const ParentId: unique symbol\ndeclare const SelectorRequires: unique symbol\n\n/**\n * The requirement carried by a selector that references the nesting\n * selector (`&`): a parent rule must bind the reference before the\n * selector means anything on its own.\n *\n * Nesting the selector's rule inside another style rule discharges it —\n * the enclosing rule's selector is what `&` reads. Top-level positions\n * and `specificity` reject selectors that still carry it. The channel's\n * design is derived in `docs/selector-nesting.md`.\n *\n * @since 0.4.0\n */\nexport type Parent = { readonly [ParentId]: 'parent' }\n\n/**\n * The union of context requirements a selector can carry — `Parent`\n * today, joined by sibling brands if the model grows other\n * context-dependent selectors.\n *\n * A parameter typed `Selector<Requirement>` admits every selector; bare\n * `Selector` (`Requires = never`) admits only closed ones.\n *\n * @since 0.4.0\n */\nexport type Requirement = Parent\n\n/**\n * The requirements of a `Selector`, or the union of them for a union of\n * selectors — the type-level extractor the list and combinator\n * constructors use to thread their arguments' requirements into the\n * result.\n *\n * @since 0.4.0\n */\nexport type SelectorRequires<S extends Selector<Requirement>> =\n  S extends Selector<infer R> ? R : never\n\n/**\n * A CSS selector: one compound, or a sequence of compounds joined by\n * combinators, canonically ordered within each compound.\n *\n * Part constructors (`type`, `id`, `class`, `attribute`, `pseudoClass`,\n * `pseudoElement`, `universal`, `nest`) return one-part compounds; `and`\n * merges compounds; `descendant`, `child`, `nextSibling`, and\n * `subsequentSibling` join selectors into complex selectors; `is`,\n * `where`, `has`, and `not` wrap selector lists. Construction\n * canonically orders compound parts and list arguments, so structurally\n * equal selectors compare equal however they were built, and rendering\n * is deterministic. Combinator sequences are never reordered — their\n * order is their meaning. Duplicate parts are kept — `.a.a` legally has\n * specificity `(0, 2, 0)`.\n *\n * `Requires` is the requirements channel: `Parent` while the selector\n * references `&`, `never` once nothing outside the selector is needed.\n * Positions gate by covariance — a parameter typed `Selector` admits\n * only closed selectors, one typed `Selector<Requirement>` admits any.\n *\n * @since 0.1.0\n */\nexport interface Selector<out Requires extends Requirement = never> extends Pipeable {\n  readonly [SelectorTypeId]: SelectorTypeId\n  readonly [SelectorRequires]?: Requires\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. The guard widens to `Selector<Requirement>` — it proves the\n * brand, not closedness.\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<Requirement> = 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 * The nesting selector, `&` — a reference to the enclosing rule's\n * selector, usable anywhere a simple selector is: merged into a compound\n * (`&.active`), under a combinator (`& *`), or inside a selector list\n * (`:is(&, & *)`).\n *\n * Carrying it marks the selector `Parent`-requiring: nested style rules\n * must reference it, and top-level positions reject it. Its specificity\n * is the parent selector's, so `specificity` refuses it unresolved —\n * substitute the parent with `under` first.\n *\n * In a compound it sorts just after the type slot: a type selector must\n * come first even beside `&` (`div&`, never `&div`).\n *\n * @since 0.4.0\n */\nexport const nest: Selector<Parent> = internal.nest\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 pseudo-classes over selector lists, use `is`,\n * `where`, `has`, or `not`, which take typed selector arguments.\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 matches-any pseudo-class, rendered `:is(a, b, ...)`. The\n * arguments form a selector list — compound or complex alike — and the\n * part matches an element matching any of them.\n *\n * The list canonically sorts (matching is order-independent), so\n * `is(a, b)` equals `is(b, a)`. The part's specificity is its most\n * specific argument's. Requirements union across arguments — an `&`\n * inside the list marks the whole selector `Parent`-requiring.\n *\n * @param selectors - The selector list. At least one.\n * @returns A one-part `Selector` carrying the arguments' requirements.\n * @throws `Error` when called with no arguments.\n * @example\n * ```ts\n * Selector.render(Selector.is(Selector.nest, Selector.descendant(Selector.nest, Selector.universal)))\n * // ':is(&, & *)'\n * ```\n * @since 0.4.0\n */\nexport const is: <Args extends ReadonlyArray<Selector<Requirement>>>(\n  ...selectors: Args\n) => Selector<SelectorRequires<Args[number]>> = internal.is\n\n/**\n * Creates a zero-specificity matches-any pseudo-class, rendered\n * `:where(a, b, ...)`. Matching is identical to `is`; the part\n * contributes nothing to specificity regardless of its arguments.\n *\n * The list canonically sorts, and requirements union across arguments.\n *\n * @param selectors - The selector list. At least one.\n * @returns A one-part `Selector` carrying the arguments' requirements.\n * @throws `Error` when called with no arguments.\n * @since 0.4.0\n */\nexport const where: <Args extends ReadonlyArray<Selector<Requirement>>>(\n  ...selectors: Args\n) => Selector<SelectorRequires<Args[number]>> = internal.where\n\n/**\n * Creates a relational pseudo-class, rendered `:has(a, b, ...)`: the\n * part matches an element whose subtree contains a match for any\n * argument.\n *\n * Arguments are ordinary selectors — the relative forms with a leading\n * combinator (`:has(> .x)`) are not modeled. The list canonically\n * sorts, the part's specificity is its most specific argument's, and\n * requirements union across arguments.\n *\n * @param selectors - The selector list. At least one.\n * @returns A one-part `Selector` carrying the arguments' requirements.\n * @throws `Error` when called with no arguments.\n * @since 0.4.0\n */\nexport const has: <Args extends ReadonlyArray<Selector<Requirement>>>(\n  ...selectors: Args\n) => Selector<SelectorRequires<Args[number]>> = internal.has\n\n/**\n * Creates a functional negation, rendered `:not(a, b, ...)`. The\n * arguments form a selector list; the part matches an element matching\n * none of them.\n *\n * The list canonically sorts, the part's specificity is its most\n * specific argument's (`:not` itself contributes none), and\n * requirements union across arguments.\n *\n * @param selectors - The selector list to negate. At least one.\n * @returns A one-part `Selector` carrying the arguments' requirements.\n * @throws `Error` when called with no arguments.\n * @since 0.1.0\n */\nexport const not: <Args extends ReadonlyArray<Selector<Requirement>>>(\n  ...selectors: Args\n) => Selector<SelectorRequires<Args[number]>> = 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\n * this. No combinator may follow one — the combinator constructors\n * enforce that.\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 compound to merge in.\n   * @returns A function that takes a compound and returns the merged compound.\n   * @since 0.1.0\n   */\n  <B extends Requirement>(\n    that: Selector<B>,\n  ): <A extends Requirement>(self: Selector<A>) => Selector<A | B>\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. Requirements union across the two\n   * sides.\n   *\n   * Compounds only: a complex selector has no single element to\n   * constrain. Join complex selectors with a combinator, or wrap them\n   * in a selector list.\n   *\n   * @param self - The first compound.\n   * @param that - The second compound.\n   * @returns The merged compound, carrying both sides' requirements.\n   * @throws `Error` when either operand is a complex selector, or 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  <A extends Requirement, B extends Requirement>(\n    self: Selector<A>,\n    that: Selector<B>,\n  ): Selector<A | B>\n} = internal.and\n\nexport const descendant: {\n  /**\n   * Returns a function that joins its argument to `that` with the\n   * descendant combinator.\n   *\n   * @param that - The right (descendant) side.\n   * @returns A function that takes a selector and returns the complex selector `self that`.\n   * @since 0.4.0\n   */\n  <B extends Requirement>(\n    that: Selector<B>,\n  ): <A extends Requirement>(self: Selector<A>) => Selector<A | B>\n  /**\n   * Joins two selectors with the descendant combinator, rendered\n   * `self that`: the right side matches anywhere inside the left side's\n   * subtree.\n   *\n   * Either side may itself be complex; the compound sequence\n   * concatenates in order, and nothing re-sorts across a combinator.\n   * Requirements union across the two sides.\n   *\n   * @param self - The left (ancestor) side. Must not end in a compound containing a pseudo-element.\n   * @param that - The right (descendant) side.\n   * @returns The complex selector `self that`, carrying both sides' requirements.\n   * @throws `Error` when `self` ends in a compound containing a pseudo-element — no combinator may follow one.\n   * @example\n   * ```ts\n   * Selector.render(Selector.descendant(Selector.class('sidebar'), Selector.type('a')))\n   * // '.sidebar a'\n   * ```\n   * @since 0.4.0\n   */\n  <A extends Requirement, B extends Requirement>(\n    self: Selector<A>,\n    that: Selector<B>,\n  ): Selector<A | B>\n} = internal.descendant\n\nexport const child: {\n  /**\n   * Returns a function that joins its argument to `that` with the child\n   * combinator.\n   *\n   * @param that - The right (child) side.\n   * @returns A function that takes a selector and returns the complex selector `self > that`.\n   * @since 0.4.0\n   */\n  <B extends Requirement>(\n    that: Selector<B>,\n  ): <A extends Requirement>(self: Selector<A>) => Selector<A | B>\n  /**\n   * Joins two selectors with the child combinator, rendered\n   * `self > that`: the right side matches direct children of the left\n   * side's matches. Composition rules are `descendant`'s.\n   *\n   * @param self - The left (parent) side. Must not end in a compound containing a pseudo-element.\n   * @param that - The right (child) side.\n   * @returns The complex selector `self > that`, carrying both sides' requirements.\n   * @throws `Error` when `self` ends in a compound containing a pseudo-element — no combinator may follow one.\n   * @since 0.4.0\n   */\n  <A extends Requirement, B extends Requirement>(\n    self: Selector<A>,\n    that: Selector<B>,\n  ): Selector<A | B>\n} = internal.child\n\nexport const nextSibling: {\n  /**\n   * Returns a function that joins its argument to `that` with the\n   * next-sibling combinator.\n   *\n   * @param that - The right (following sibling) side.\n   * @returns A function that takes a selector and returns the complex selector `self + that`.\n   * @since 0.4.0\n   */\n  <B extends Requirement>(\n    that: Selector<B>,\n  ): <A extends Requirement>(self: Selector<A>) => Selector<A | B>\n  /**\n   * Joins two selectors with the next-sibling combinator, rendered\n   * `self + that`: the right side matches the element immediately\n   * following a left-side match. Composition rules are `descendant`'s.\n   *\n   * @param self - The left side. Must not end in a compound containing a pseudo-element.\n   * @param that - The right (following sibling) side.\n   * @returns The complex selector `self + that`, carrying both sides' requirements.\n   * @throws `Error` when `self` ends in a compound containing a pseudo-element — no combinator may follow one.\n   * @since 0.4.0\n   */\n  <A extends Requirement, B extends Requirement>(\n    self: Selector<A>,\n    that: Selector<B>,\n  ): Selector<A | B>\n} = internal.nextSibling\n\nexport const subsequentSibling: {\n  /**\n   * Returns a function that joins its argument to `that` with the\n   * subsequent-sibling combinator.\n   *\n   * @param that - The right (later sibling) side.\n   * @returns A function that takes a selector and returns the complex selector `self ~ that`.\n   * @since 0.4.0\n   */\n  <B extends Requirement>(\n    that: Selector<B>,\n  ): <A extends Requirement>(self: Selector<A>) => Selector<A | B>\n  /**\n   * Joins two selectors with the subsequent-sibling combinator, rendered\n   * `self ~ that`: the right side matches any later sibling of a\n   * left-side match. Composition rules are `descendant`'s.\n   *\n   * @param self - The left side. Must not end in a compound containing a pseudo-element.\n   * @param that - The right (later sibling) side.\n   * @returns The complex selector `self ~ that`, carrying both sides' requirements.\n   * @throws `Error` when `self` ends in a compound containing a pseudo-element — no combinator may follow one.\n   * @since 0.4.0\n   */\n  <A extends Requirement, B extends Requirement>(\n    self: Selector<A>,\n    that: Selector<B>,\n  ): Selector<A | B>\n} = internal.subsequentSibling\n\nexport const under: {\n  /**\n   * Returns a function that resolves its argument against `parent`.\n   *\n   * @param parent - The parent selector to substitute for `&`.\n   * @returns A function that takes a nested selector and returns it resolved against `parent`.\n   * @since 0.4.0\n   */\n  <P extends Requirement>(\n    parent: Selector<P>,\n  ): <C extends Requirement>(child: Selector<C>) => Selector<Exclude<C, Parent> | P>\n  /**\n   * Resolves a nested selector against its parent: every `&` in `child`,\n   * including inside `is`/`where`/`has`/`not` argument lists, is\n   * replaced by `parent`, discharging the `Parent` requirement.\n   *\n   * A compound parent merges in place (`&.active` under `.btn` is\n   * `.btn.active`); a complex parent substitutes as `:is(parent)`, which\n   * matches and scores identically. The result's specificity is\n   * therefore the spec's — `&` counts as the parent selector. A child\n   * without `&` returns unchanged. Chained nesting resolves innermost\n   * binder first: resolve the grandchild against its parent, then the\n   * result against the grandparent.\n   *\n   * @param child - The nested selector to resolve.\n   * @param parent - The parent selector to substitute for `&`. May itself reference `&`; the result then still carries `Parent`.\n   * @returns The resolved selector, carrying `child`'s requirements minus `Parent`, plus `parent`'s.\n   * @throws `Error` when a substitution produces an invalid compound — merging a typed parent into a compound that already has a type selector, say.\n   * @example\n   * ```ts\n   * const nested = Selector.is(Selector.nest, Selector.descendant(Selector.nest, Selector.universal))\n   * Selector.render(Selector.under(nested, Selector.class('red')))\n   * // ':is(.red, .red *)'\n   * ```\n   * @since 0.4.0\n   */\n  <C extends Requirement, P extends Requirement>(\n    child: Selector<C>,\n    parent: Selector<P>,\n  ): Selector<Exclude<C, Parent> | P>\n} = internal.under\n\n/**\n * Computes the selector's specificity: ids into `a`; classes,\n * attributes, and pseudo-classes into `b`; types and pseudo-elements\n * into `c`. Compounds in a complex selector sum. `:is()`, `:has()`, and\n * `:not()` add their most specific argument; `:where()` and the\n * universal selector add nothing; duplicate parts count each time.\n *\n * Closed selectors only: an `&`-bearing selector takes its specificity\n * from the parent rule, so the parameter rejects `Parent`-requiring\n * selectors at compile time — resolve them with `under` first.\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. Must be closed (no `&`).\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: each compound's parts concatenated\n * in canonical order — type first, then `&`, ids, classes,\n * pseudo-classes, attributes, functional pseudo-classes, and the\n * pseudo-element last, alphabetically within each kind — and compounds\n * joined by their combinators in authored order. Any fixed part order\n * matches identically; this one keeps root-scoped shapes in their\n * 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<Requirement>) => 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<Requirement>): (self: Selector<Requirement>) => boolean\n  /**\n   * Structural equality over canonically ordered parts: two selectors\n   * built from the same parts compare equal regardless of construction\n   * order. Combinator sequences compare in order — `a b` and `b a` are\n   * different selectors.\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<Requirement>, that: Selector<Requirement>): 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,MAAa,aAAyDA;;;;;;AAOtE,MAAa,YAAsBC;;;;;;;;;;;;;;;;;AAkBnC,MAAa,OAAyBC;;;;;;;;;;;;AAatC,MAAa,OAAmCC;;;;;;;;;AAUhD,MAAa,KAAiCC;;;;;;;;;;;AAY9C,MAAM,SAAqCC;;;;;;;;;;;;AAc3C,MAAa,cAA0CC;AAEvD,MAAa,YAyCTC;;;;;;;;;;;;;;;;;;;;;AAsBJ,MAAa,KAEmCC;;;;;;;;;;;;;AAchD,MAAa,QAEmCC;;;;;;;;;;;;;;;;AAiBhD,MAAa,MAEmCC;;;;;;;;;;;;;;;AAgBhD,MAAa,MAEmCC;;;;;;;;;;;;;AAchD,MAAa,gBAA4CC;;;;;;;AAQzD,MAAa,OAAiBC;AAE9B,MAAa,MAsCTC;AAEJ,MAAa,aAoCTC;AAEJ,MAAa,QA2BTC;AAEJ,MAAa,cA2BTC;AAEJ,MAAa,oBA2BTC;AAEJ,MAAa,QAwCTC;;;;;;;;;;;;;;;;;;;AAoBJ,MAAa,cAAmDC;;;;;;;;;;;;;;;;;;;AAoBhE,MAAa,SAAsDC;AAEnE,MAAaC,WAqBTC;;;;;;;;;;;;;;;;;;;AC1hBJ,MAAa,gBAAkDC;;;;;;;;;;;AAY/D,MAAa,OAAyDC;AAEtE,MAAa,UAuBTC;AAEJ,MAAa,SAkBTC"}