@navecss/core 0.4.0 → 0.5.0

package/dist/chunk-MWHZ26S4.js

@@ -0,0 +1,4059 @@
+import { positionWarnings, reportDiagnostics, matchBrackets, createPositionFinder, isNaveAtKeyword, readItem, atKeywordName, OPENERS } from './chunk-UVHGEVMV.js';
+import { decodeIncomingMap, MappingsBuilder } from './chunk-SYNQJNVB.js';
+import { atoms } from './chunk-CUL5PLPI.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
+
+// src/directive/expand-text-output.ts
+function toOriginal(position, incoming) {
+  if (!incoming) return position;
+  const original = incoming.originalPositionFor(position);
+  return original ? { line: original.line, column: original.column, sourceIndex: original.sourceIndex } : void 0;
+}
+function appendMappedRange(ctx, range, sourceForToken) {
+  const { builder, output, incoming } = ctx;
+  const { text, rangeStart, rangeEnd, tokensInRange } = range;
+  let cursor = rangeStart;
+  for (const token of tokensInRange) {
+    const before = text.slice(cursor, token.startIndex);
+    output.push(before);
+    builder.advance(before);
+    const source = toOriginal(sourceForToken(token), incoming);
+    if (source) builder.mark(source);
+    const end = Math.min(token.endIndex, rangeEnd);
+    const body = text.slice(token.startIndex, end);
+    output.push(body);
+    builder.advance(body);
+    cursor = end;
+  }
+  const rest = text.slice(cursor, rangeEnd);
+  output.push(rest);
+  builder.advance(rest);
+}
+function tokensBetween(tokens, cursor, start, end) {
+  let i = cursor.index;
+  while (i < tokens.length && tokens[i].startIndex < start) i++;
+  const result = [];
+  while (i < tokens.length && tokens[i].startIndex < end) {
+    result.push(tokens[i]);
+    i++;
+  }
+  cursor.index = i;
+  return result;
+}
+function appendGap(ctx, gap) {
+  appendMappedRange(
+    ctx,
+    {
+      text: gap.css,
+      rangeStart: gap.start,
+      rangeEnd: gap.end,
+      tokensInRange: tokensBetween(gap.tokens, ctx.gapTokenCursor, gap.start, gap.end)
+    },
+    (t) => gap.positionAt(t.startIndex)
+  );
+}
+function appendEditParts(ctx, edit) {
+  for (const part of edit.parts) {
+    const partTokens = tokenize(part.text);
+    appendMappedRange(
+      ctx,
+      { text: part.text, rangeStart: 0, rangeEnd: part.text.length, tokensInRange: partTokens },
+      () => part.source
+    );
+  }
+}
+function buildOutput(input) {
+  const incoming = input.inputSourceMap ? decodeIncomingMap(input.inputSourceMap) : void 0;
+  const sorted = [...input.edits].toSorted((a, b) => a.start - b.start || a.end - b.end);
+  const ctx = {
+    builder: new MappingsBuilder(),
+    output: [],
+    incoming,
+    gapTokenCursor: { index: 0 }
+  };
+  let cursor = 0;
+  for (const edit of sorted) {
+    appendGap(ctx, {
+      css: input.css,
+      tokens: input.tokens,
+      start: cursor,
+      end: edit.start,
+      positionAt: input.positionAt
+    });
+    appendEditParts(ctx, edit);
+    cursor = Math.max(cursor, edit.end);
+  }
+  appendGap(ctx, {
+    css: input.css,
+    tokens: input.tokens,
+    start: cursor,
+    end: input.css.length,
+    positionAt: input.positionAt
+  });
+  const sources = incoming ? [...incoming.sources] : [input.from ?? "<input>"];
+  const map = {
+    version: 3,
+    sources,
+    names: [],
+    mappings: ctx.builder.toMappings(),
+    // Kept as authored, not re-derived: the incoming map's own sourceRoot
+    // and sourcesContent describe ITS sources, unrelated to anything this
+    // pass computes, and dropping them silently would strand a devtools
+    // "view source" that only ever worked because they were there.
+    ...incoming?.sourceRoot !== void 0 && { sourceRoot: incoming.sourceRoot },
+    ...incoming?.sourcesContent !== void 0 && { sourcesContent: incoming.sourcesContent }
+  };
+  return { css: ctx.output.join(""), map: JSON.stringify(map) };
+}
+
+// src/directive/expand-text-render.ts
+function withoutLineTerminators(value) {
+  return value.replaceAll(/\r\n|[\r\n\f]/g, " ");
+}
+function renderDeclarations(decls) {
+  return decls.map((d) => `${d.prop}: ${withoutLineTerminators(d.value)}`).join("; ");
+}
+function renderRule(selector, decls) {
+  return `${selector} { ${renderDeclarations(decls)} }`;
+}
+function renderBlock(block) {
+  if (block.kind === "pseudo") return renderRule(block.selector, block.declarations);
+  const inner = [];
+  if (block.declarations.length > 0) inner.push(renderRule("&", block.declarations));
+  for (const pseudo of block.pseudos) inner.push(renderRule(pseudo.selector, pseudo.declarations));
+  return `@${block.kind} ${block.condition} { ${inner.join(" ")} }`;
+}
+function renderEmissions(emissions) {
+  return emissions.map((emission) => {
+    if (emission.kind === "block") return renderBlock(emission.block);
+    if (emission.isWrapped) return renderRule("&", emission.declarations);
+    return `${renderDeclarations(emission.declarations)};`;
+  }).join(" ");
+}
+
+// src/directive/condition-overlap.ts
+var LENGTH = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?[a-z]+`;
+var OPERATOR = "(<=|>=|<|>|=)";
+var AXIS = "(width|height)";
+var RANGE_FEATURE = new RegExp(
+  String.raw`^(?:(${LENGTH})\s*${OPERATOR}\s*)?${AXIS}(?:\s*${OPERATOR}\s*(${LENGTH}))?$`
+);
+var LEGACY_FEATURE = new RegExp(String.raw`^(min-|max-)?${AXIS}\s*:\s*(${LENGTH})$`);
+var FEATURE_GROUP = /\(([^()]*)\)/g;
+var FEATURE_CHAIN = /^G(?:\s+and\s+G)*$/;
+var FLIPPED = { "<": ">", "<=": ">=", "=": "=", ">": "<", ">=": "<=" };
+var LEGACY_OPERATORS = { "max-": "<=", "min-": ">=" };
+var LENGTH_PARTS = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)([a-z]+)$/;
+function boundsOf(axis, operator, length) {
+  const parts = LENGTH_PARTS.exec(length);
+  if (!parts) return void 0;
+  const value = Number(parts[1]);
+  const unit = parts[2];
+  const isStrict = operator === "<" || operator === ">";
+  const lower = { axis, side: "lower", value, unit, isStrict };
+  const upper = { axis, side: "upper", value, unit, isStrict };
+  if (operator === "=") return [lower, upper];
+  return operator === ">" || operator === ">=" ? [lower] : [upper];
+}
+function legacyBounds(content) {
+  const match = LEGACY_FEATURE.exec(content);
+  if (!match) return void 0;
+  return boundsOf(match[2], LEGACY_OPERATORS[match[1] ?? ""] ?? "=", match[3]);
+}
+function isUp(operator) {
+  return operator === "<" || operator === "<=";
+}
+function isDown(operator) {
+  return operator === ">" || operator === ">=";
+}
+function isLegalRelation(left, right) {
+  if (!left && !right) return false;
+  if (!left || !right) return true;
+  return isUp(left) && isUp(right) || isDown(left) && isDown(right);
+}
+function rangeBounds(content) {
+  const match = RANGE_FEATURE.exec(content);
+  if (!match) return void 0;
+  const [, leftLength, leftOperator, axis, rightOperator, rightLength] = match;
+  if (!isLegalRelation(leftOperator, rightOperator)) return void 0;
+  const left = leftOperator ? boundsOf(axis, FLIPPED[leftOperator], leftLength) : [];
+  const right = rightOperator ? boundsOf(axis, rightOperator, rightLength) : [];
+  return left && right ? [...left, ...right] : void 0;
+}
+function featureBounds(content) {
+  const text = content.trim();
+  return text.includes(":") ? legacyBounds(text) : rangeBounds(text);
+}
+function mediaBounds(prelude) {
+  const text = prelude.replaceAll(/\/\*[\s\S]*?\*\//g, " ").toLowerCase().trim();
+  const contents = text.matchAll(FEATURE_GROUP).map((match) => match[1]).toArray();
+  if (!FEATURE_CHAIN.test(text.replaceAll(FEATURE_GROUP, "G"))) return void 0;
+  const bounds = [];
+  for (const content of contents) {
+    const found = featureBounds(content);
+    if (!found) return void 0;
+    bounds.push(...found);
+  }
+  return bounds;
+}
+var BOUNDS_OF = /* @__PURE__ */ new WeakMap();
+function collectBounds(rules) {
+  const known = BOUNDS_OF.get(rules);
+  if (known !== void 0) return known;
+  const bounds = rules.flatMap(
+    (rule) => rule.name === "media" ? mediaBounds(rule.prelude) ?? [] : []
+  );
+  BOUNDS_OF.set(rules, bounds);
+  return bounds;
+}
+function isTighter(candidate, current) {
+  if (!current) return true;
+  if (candidate.value === current.value) return candidate.isStrict && !current.isStrict;
+  return candidate.side === "lower" ? candidate.value > current.value : candidate.value < current.value;
+}
+function tightest(bounds) {
+  let lower;
+  let upper;
+  for (const bound of bounds) {
+    if (bound.side === "lower" && isTighter(bound, lower)) lower = bound;
+    if (bound.side === "upper" && isTighter(bound, upper)) upper = bound;
+  }
+  return { lower, upper };
+}
+function isEmptyAxis(bounds) {
+  if (new Set(bounds.map((bound) => bound.unit)).size > 1) return false;
+  const { lower, upper } = tightest(bounds);
+  if (!lower || !upper) return false;
+  if (lower.value !== upper.value) return lower.value > upper.value;
+  return lower.isStrict || upper.isStrict;
+}
+function conditionsMayOverlap(a, b) {
+  const bounds = [...collectBounds(a), ...collectBounds(b)];
+  const axes = ["width", "height"];
+  return axes.every((axis) => !isEmptyAxis(bounds.filter((bound) => bound.axis === axis)));
+}
+
+// src/directive/property-table.generated.ts
+var PROPERTY_LONGHANDS = {
+  "accent-color": ["accent-color"],
+  "align-content": ["align-content"],
+  "align-items": ["align-items"],
+  "align-self": ["align-self"],
+  "align-tracks": ["align-tracks"],
+  "alignment-baseline": ["alignment-baseline"],
+  "all": ["accent-color", "align-content", "align-items", "align-self", "align-tracks", "alignment-baseline", "anchor-name", "anchor-scope", "animation-composition", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-range-end", "animation-range-start", "animation-timeline", "animation-timing-function", "animation-trigger", "appearance", "aspect-ratio", "backdrop-filter", "backface-visibility", "background-attachment", "background-blend-mode", "background-clip", "background-color", "background-image", "background-origin", "background-position-x", "background-position-y", "background-repeat", "background-size", "baseline-shift", "baseline-source", "block-size", "border-block-end-color", "border-block-end-style", "border-block-end-width", "border-block-start-color", "border-block-start-style", "border-block-start-width", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-end-end-radius", "border-end-start-radius", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width", "border-inline-end-color", "border-inline-end-style", "border-inline-end-width", "border-inline-start-color", "border-inline-start-style", "border-inline-start-width", "border-left-color", "border-left-style", "border-left-width", "border-right-color", "border-right-style", "border-right-width", "border-shape", "border-spacing", "border-start-end-radius", "border-start-start-radius", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "bottom", "box-align", "box-decoration-break", "box-direction", "box-flex", "box-flex-group", "box-lines", "box-ordinal-group", "box-orient", "box-pack", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "caret-animation", "caret-color", "caret-shape", "clear", "clip", "clip-path", "clip-rule", "color", "color-interpolation-filters", "color-scheme", "column-count", "column-fill", "column-gap", "column-height", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "column-wrap", "contain", "contain-intrinsic-block-size", "contain-intrinsic-height", "contain-intrinsic-inline-size", "contain-intrinsic-width", "container-name", "container-type", "content", "content-visibility", "corner-bottom-left-shape", "corner-bottom-right-shape", "corner-end-end-shape", "corner-end-start-shape", "corner-start-end-shape", "corner-start-start-shape", "corner-top-left-shape", "corner-top-right-shape", "counter-increment", "counter-reset", "counter-set", "cursor", "cx", "cy", "d", "display", "dominant-baseline", "dynamic-range-limit", "empty-cells", "field-sizing", "fill", "fill-opacity", "fill-rule", "filter", "flex-basis", "flex-direction", "flex-grow", "flex-line-count", "flex-shrink", "flex-wrap", "float", "flood-color", "flood-opacity", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-optical-sizing", "font-palette", "font-size", "font-size-adjust", "font-smooth", "font-stretch", "font-style", "font-synthesis-position", "font-synthesis-small-caps", "font-synthesis-style", "font-synthesis-weight", "font-variant-alternates", "font-variant-caps", "font-variant-east-asian", "font-variant-emoji", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "font-width", "forced-color-adjust", "frame-sizing", "grid-auto-columns", "grid-auto-flow", "grid-auto-rows", "grid-column-end", "grid-column-gap", "grid-column-start", "grid-row-end", "grid-row-gap", "grid-row-start", "grid-template-areas", "grid-template-columns", "grid-template-rows", "hanging-punctuation", "height", "hyphenate-character", "hyphenate-limit-chars", "hyphens", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "initial-letter", "initial-letter-align", "inline-size", "inset-block-end", "inset-block-start", "inset-inline-end", "inset-inline-start", "interactivity", "interest-delay-end", "interest-delay-start", "interpolate-size", "isolation", "justify-content", "justify-items", "justify-self", "justify-tracks", "left", "letter-spacing", "lighting-color", "line-break", "line-clamp", "line-height", "line-height-step", "link-parameters", "list-style-image", "list-style-position", "list-style-type", "margin-block-end", "margin-block-start", "margin-bottom", "margin-inline-end", "margin-inline-start", "margin-left", "margin-right", "margin-top", "margin-trim", "marker", "marker-end", "marker-mid", "marker-start", "mask-border-mode", "mask-border-outset", "mask-border-repeat", "mask-border-slice", "mask-border-source", "mask-border-width", "mask-clip", "mask-composite", "mask-image", "mask-mode", "mask-origin", "mask-position", "mask-repeat", "mask-size", "mask-type", "masonry-auto-flow", "math-depth", "math-shift", "math-style", "max-block-size", "max-height", "max-inline-size", "max-lines", "max-width", "min-block-size", "min-height", "min-inline-size", "min-width", "mix-blend-mode", "object-fit", "object-position", "object-view-box", "offset-anchor", "offset-distance", "offset-path", "offset-position", "offset-rotate", "opacity", "order", "orphans", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow-anchor", "overflow-block", "overflow-clip-box", "overflow-clip-margin", "overflow-inline", "overflow-wrap", "overflow-x", "overflow-y", "overlay", "overscroll-behavior-block", "overscroll-behavior-inline", "overscroll-behavior-x", "overscroll-behavior-y", "padding-block-end", "padding-block-start", "padding-bottom", "padding-inline-end", "padding-inline-start", "padding-left", "padding-right", "padding-top", "page", "paint-order", "path-length", "perspective", "perspective-origin", "pointer-events", "position", "position-anchor", "position-area", "position-try-fallbacks", "position-try-order", "position-visibility", "print-color-adjust", "quotes", "r", "reading-flow", "reading-order", "resize", "right", "rotate", "row-gap", "ruby-align", "ruby-merge", "ruby-overhang", "ruby-position", "rx", "ry", "scale", "scroll-axis-lock", "scroll-behavior", "scroll-initial-target", "scroll-margin-block-end", "scroll-margin-block-start", "scroll-margin-bottom", "scroll-margin-inline-end", "scroll-margin-inline-start", "scroll-margin-left", "scroll-margin-right", "scroll-margin-top", "scroll-marker-group", "scroll-padding-block-end", "scroll-padding-block-start", "scroll-padding-bottom", "scroll-padding-inline-end", "scroll-padding-inline-start", "scroll-padding-left", "scroll-padding-right", "scroll-padding-top", "scroll-snap-align", "scroll-snap-coordinate", "scroll-snap-destination", "scroll-snap-points-x", "scroll-snap-points-y", "scroll-snap-stop", "scroll-snap-type", "scroll-snap-type-x", "scroll-snap-type-y", "scroll-target-group", "scroll-timeline-axis", "scroll-timeline-name", "scrollbar-color", "scrollbar-gutter", "scrollbar-width", "shape-image-threshold", "shape-margin", "shape-outside", "shape-rendering", "speak-as", "stop-color", "stop-opacity", "stroke", "stroke-color", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke-width", "tab-size", "table-layout", "text-align", "text-align-last", "text-anchor", "text-autospace", "text-box", "text-box-edge", "text-box-trim", "text-combine-upright", "text-decoration-color", "text-decoration-inset", "text-decoration-line", "text-decoration-skip", "text-decoration-skip-ink", "text-decoration-style", "text-decoration-thickness", "text-emphasis-color", "text-emphasis-position", "text-emphasis-style", "text-fit", "text-indent", "text-justify", "text-orientation", "text-overflow", "text-rendering", "text-shadow", "text-size-adjust", "text-spacing-trim", "text-transform", "text-underline-offset", "text-underline-position", "text-wrap-mode", "text-wrap-style", "timeline-scope", "timeline-trigger-activation-range-end", "timeline-trigger-activation-range-start", "timeline-trigger-active-range-end", "timeline-trigger-active-range-start", "timeline-trigger-name", "timeline-trigger-source", "top", "touch-action", "transform", "transform-box", "transform-origin", "transform-style", "transition-behavior", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "translate", "trigger-scope", "user-select", "vector-effect", "vertical-align", "view-timeline-axis", "view-timeline-inset", "view-timeline-name", "view-transition-class", "view-transition-name", "view-transition-scope", "visibility", "white-space-collapse", "white-space-trim", "widows", "width", "will-change", "window-drag", "word-break", "word-spacing", "word-wrap", "writing-mode", "x", "y", "z-index", "zoom"],
+  "anchor-name": ["anchor-name"],
+  "anchor-scope": ["anchor-scope"],
+  "animation": ["animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timeline", "animation-timing-function"],
+  "animation-composition": ["animation-composition"],
+  "animation-delay": ["animation-delay"],
+  "animation-direction": ["animation-direction"],
+  "animation-duration": ["animation-duration"],
+  "animation-fill-mode": ["animation-fill-mode"],
+  "animation-iteration-count": ["animation-iteration-count"],
+  "animation-name": ["animation-name"],
+  "animation-play-state": ["animation-play-state"],
+  "animation-range": ["animation-range-end", "animation-range-start"],
+  "animation-range-end": ["animation-range-end"],
+  "animation-range-start": ["animation-range-start"],
+  "animation-timeline": ["animation-timeline"],
+  "animation-timing-function": ["animation-timing-function"],
+  "animation-trigger": ["animation-trigger"],
+  "appearance": ["appearance"],
+  "aspect-ratio": ["aspect-ratio"],
+  "backdrop-filter": ["backdrop-filter"],
+  "backface-visibility": ["backface-visibility"],
+  "background": ["background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position-x", "background-position-y", "background-repeat", "background-size"],
+  "background-attachment": ["background-attachment"],
+  "background-blend-mode": ["background-blend-mode"],
+  "background-clip": ["background-clip"],
+  "background-color": ["background-color"],
+  "background-image": ["background-image"],
+  "background-origin": ["background-origin"],
+  "background-position": ["background-position-x", "background-position-y"],
+  "background-position-x": ["background-position-x"],
+  "background-position-y": ["background-position-y"],
+  "background-repeat": ["background-repeat"],
+  "background-size": ["background-size"],
+  "baseline-shift": ["baseline-shift"],
+  "baseline-source": ["baseline-source"],
+  "block-size": ["block-size"],
+  "border": ["border-bottom-color", "border-bottom-style", "border-bottom-width", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width", "border-left-color", "border-left-style", "border-left-width", "border-right-color", "border-right-style", "border-right-width", "border-top-color", "border-top-style", "border-top-width"],
+  "border-block": ["border-block-end-color", "border-block-end-style", "border-block-end-width", "border-block-start-color", "border-block-start-style", "border-block-start-width"],
+  "border-block-color": ["border-block-end-color", "border-block-start-color"],
+  "border-block-end": ["border-block-end-color", "border-block-end-style", "border-block-end-width"],
+  "border-block-end-color": ["border-block-end-color"],
+  "border-block-end-style": ["border-block-end-style"],
+  "border-block-end-width": ["border-block-end-width"],
+  "border-block-start": ["border-block-start-color", "border-block-start-style", "border-block-start-width"],
+  "border-block-start-color": ["border-block-start-color"],
+  "border-block-start-style": ["border-block-start-style"],
+  "border-block-start-width": ["border-block-start-width"],
+  "border-block-style": ["border-block-end-style", "border-block-start-style"],
+  "border-block-width": ["border-block-end-width", "border-block-start-width"],
+  "border-bottom": ["border-bottom-color", "border-bottom-style", "border-bottom-width"],
+  "border-bottom-color": ["border-bottom-color"],
+  "border-bottom-left-radius": ["border-bottom-left-radius"],
+  "border-bottom-right-radius": ["border-bottom-right-radius"],
+  "border-bottom-style": ["border-bottom-style"],
+  "border-bottom-width": ["border-bottom-width"],
+  "border-collapse": ["border-collapse"],
+  "border-color": ["border-bottom-color", "border-left-color", "border-right-color", "border-top-color"],
+  "border-end-end-radius": ["border-end-end-radius"],
+  "border-end-start-radius": ["border-end-start-radius"],
+  "border-image": ["border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width"],
+  "border-image-outset": ["border-image-outset"],
+  "border-image-repeat": ["border-image-repeat"],
+  "border-image-slice": ["border-image-slice"],
+  "border-image-source": ["border-image-source"],
+  "border-image-width": ["border-image-width"],
+  "border-inline": ["border-inline-end-color", "border-inline-end-style", "border-inline-end-width", "border-inline-start-color", "border-inline-start-style", "border-inline-start-width"],
+  "border-inline-color": ["border-inline-end-color", "border-inline-start-color"],
+  "border-inline-end": ["border-inline-end-color", "border-inline-end-style", "border-inline-end-width"],
+  "border-inline-end-color": ["border-inline-end-color"],
+  "border-inline-end-style": ["border-inline-end-style"],
+  "border-inline-end-width": ["border-inline-end-width"],
+  "border-inline-start": ["border-inline-start-color", "border-inline-start-style", "border-inline-start-width"],
+  "border-inline-start-color": ["border-inline-start-color"],
+  "border-inline-start-style": ["border-inline-start-style"],
+  "border-inline-start-width": ["border-inline-start-width"],
+  "border-inline-style": ["border-inline-end-style", "border-inline-start-style"],
+  "border-inline-width": ["border-inline-end-width", "border-inline-start-width"],
+  "border-left": ["border-left-color", "border-left-style", "border-left-width"],
+  "border-left-color": ["border-left-color"],
+  "border-left-style": ["border-left-style"],
+  "border-left-width": ["border-left-width"],
+  "border-radius": ["border-bottom-left-radius", "border-bottom-right-radius", "border-top-left-radius", "border-top-right-radius"],
+  "border-right": ["border-right-color", "border-right-style", "border-right-width"],
+  "border-right-color": ["border-right-color"],
+  "border-right-style": ["border-right-style"],
+  "border-right-width": ["border-right-width"],
+  "border-shape": ["border-shape"],
+  "border-spacing": ["border-spacing"],
+  "border-start-end-radius": ["border-start-end-radius"],
+  "border-start-start-radius": ["border-start-start-radius"],
+  "border-style": ["border-bottom-style", "border-left-style", "border-right-style", "border-top-style"],
+  "border-top": ["border-top-color", "border-top-style", "border-top-width"],
+  "border-top-color": ["border-top-color"],
+  "border-top-left-radius": ["border-top-left-radius"],
+  "border-top-right-radius": ["border-top-right-radius"],
+  "border-top-style": ["border-top-style"],
+  "border-top-width": ["border-top-width"],
+  "border-width": ["border-bottom-width", "border-left-width", "border-right-width", "border-top-width"],
+  "bottom": ["bottom"],
+  "box-align": ["box-align"],
+  "box-decoration-break": ["box-decoration-break"],
+  "box-direction": ["box-direction"],
+  "box-flex": ["box-flex"],
+  "box-flex-group": ["box-flex-group"],
+  "box-lines": ["box-lines"],
+  "box-ordinal-group": ["box-ordinal-group"],
+  "box-orient": ["box-orient"],
+  "box-pack": ["box-pack"],
+  "box-shadow": ["box-shadow"],
+  "box-sizing": ["box-sizing"],
+  "break-after": ["break-after"],
+  "break-before": ["break-before"],
+  "break-inside": ["break-inside"],
+  "caption-side": ["caption-side"],
+  "caret": ["caret-animation", "caret-color", "caret-shape"],
+  "caret-animation": ["caret-animation"],
+  "caret-color": ["caret-color"],
+  "caret-shape": ["caret-shape"],
+  "clear": ["clear"],
+  "clip": ["clip"],
+  "clip-path": ["clip-path"],
+  "clip-rule": ["clip-rule"],
+  "color": ["color"],
+  "color-interpolation-filters": ["color-interpolation-filters"],
+  "color-scheme": ["color-scheme"],
+  "column-count": ["column-count"],
+  "column-fill": ["column-fill"],
+  "column-gap": ["column-gap"],
+  "column-height": ["column-height"],
+  "column-rule": ["column-rule-color", "column-rule-style", "column-rule-width"],
+  "column-rule-color": ["column-rule-color"],
+  "column-rule-style": ["column-rule-style"],
+  "column-rule-width": ["column-rule-width"],
+  "column-span": ["column-span"],
+  "column-width": ["column-width"],
+  "column-wrap": ["column-wrap"],
+  "columns": ["column-count", "column-height", "column-width"],
+  "contain": ["contain"],
+  "contain-intrinsic-block-size": ["contain-intrinsic-block-size"],
+  "contain-intrinsic-height": ["contain-intrinsic-height"],
+  "contain-intrinsic-inline-size": ["contain-intrinsic-inline-size"],
+  "contain-intrinsic-size": ["contain-intrinsic-height", "contain-intrinsic-width"],
+  "contain-intrinsic-width": ["contain-intrinsic-width"],
+  "container": ["container-name", "container-type"],
+  "container-name": ["container-name"],
+  "container-type": ["container-type"],
+  "content": ["content"],
+  "content-visibility": ["content-visibility"],
+  "corner-block-end-shape": ["corner-end-end-shape", "corner-end-start-shape"],
+  "corner-block-start-shape": ["corner-start-end-shape", "corner-start-start-shape"],
+  "corner-bottom-left-shape": ["corner-bottom-left-shape"],
+  "corner-bottom-right-shape": ["corner-bottom-right-shape"],
+  "corner-bottom-shape": ["corner-bottom-left-shape", "corner-bottom-right-shape"],
+  "corner-end-end-shape": ["corner-end-end-shape"],
+  "corner-end-start-shape": ["corner-end-start-shape"],
+  "corner-inline-end-shape": ["corner-end-end-shape", "corner-start-end-shape"],
+  "corner-inline-start-shape": ["corner-start-end-shape", "corner-start-start-shape"],
+  "corner-left-shape": ["corner-bottom-left-shape", "corner-top-left-shape"],
+  "corner-right-shape": ["corner-bottom-right-shape", "corner-top-right-shape"],
+  "corner-shape": ["corner-bottom-left-shape", "corner-bottom-right-shape", "corner-top-left-shape", "corner-top-right-shape"],
+  "corner-start-end-shape": ["corner-start-end-shape"],
+  "corner-start-start-shape": ["corner-start-start-shape"],
+  "corner-top-left-shape": ["corner-top-left-shape"],
+  "corner-top-right-shape": ["corner-top-right-shape"],
+  "corner-top-shape": ["corner-top-left-shape", "corner-top-right-shape"],
+  "counter-increment": ["counter-increment"],
+  "counter-reset": ["counter-reset"],
+  "counter-set": ["counter-set"],
+  "cursor": ["cursor"],
+  "cx": ["cx"],
+  "cy": ["cy"],
+  "d": ["d"],
+  "direction": ["direction"],
+  "display": ["display"],
+  "dominant-baseline": ["dominant-baseline"],
+  "dynamic-range-limit": ["dynamic-range-limit"],
+  "empty-cells": ["empty-cells"],
+  "field-sizing": ["field-sizing"],
+  "fill": ["fill"],
+  "fill-opacity": ["fill-opacity"],
+  "fill-rule": ["fill-rule"],
+  "filter": ["filter"],
+  "flex": ["flex-basis", "flex-grow", "flex-shrink"],
+  "flex-basis": ["flex-basis"],
+  "flex-direction": ["flex-direction"],
+  "flex-flow": ["flex-direction", "flex-wrap"],
+  "flex-grow": ["flex-grow"],
+  "flex-line-count": ["flex-line-count"],
+  "flex-shrink": ["flex-shrink"],
+  "flex-wrap": ["flex-wrap"],
+  "float": ["float"],
+  "flood-color": ["flood-color"],
+  "flood-opacity": ["flood-opacity"],
+  "font": ["font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-optical-sizing", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant-alternates", "font-variant-caps", "font-variant-east-asian", "font-variant-emoji", "font-variant-ligatures", "font-variant-numeric", "font-variant-position", "font-variation-settings", "font-weight", "font-width", "line-height"],
+  "font-family": ["font-family"],
+  "font-feature-settings": ["font-feature-settings"],
+  "font-kerning": ["font-kerning"],
+  "font-language-override": ["font-language-override"],
+  "font-optical-sizing": ["font-optical-sizing"],
+  "font-palette": ["font-palette"],
+  "font-size": ["font-size"],
+  "font-size-adjust": ["font-size-adjust"],
+  "font-smooth": ["font-smooth"],
+  "font-stretch": ["font-stretch"],
+  "font-style": ["font-style"],
+  "font-synthesis": ["font-synthesis-position", "font-synthesis-small-caps", "font-synthesis-style", "font-synthesis-weight"],
+  "font-synthesis-position": ["font-synthesis-position"],
+  "font-synthesis-small-caps": ["font-synthesis-small-caps"],
+  "font-synthesis-style": ["font-synthesis-style"],
+  "font-synthesis-weight": ["font-synthesis-weight"],
+  "font-variant": ["font-variant-alternates", "font-variant-caps", "font-variant-east-asian", "font-variant-emoji", "font-variant-ligatures", "font-variant-numeric", "font-variant-position"],
+  "font-variant-alternates": ["font-variant-alternates"],
+  "font-variant-caps": ["font-variant-caps"],
+  "font-variant-east-asian": ["font-variant-east-asian"],
+  "font-variant-emoji": ["font-variant-emoji"],
+  "font-variant-ligatures": ["font-variant-ligatures"],
+  "font-variant-numeric": ["font-variant-numeric"],
+  "font-variant-position": ["font-variant-position"],
+  "font-variation-settings": ["font-variation-settings"],
+  "font-weight": ["font-weight"],
+  "font-width": ["font-width"],
+  "forced-color-adjust": ["forced-color-adjust"],
+  "frame-sizing": ["frame-sizing"],
+  "gap": ["column-gap", "row-gap"],
+  "grid": ["column-gap", "grid-auto-columns", "grid-auto-flow", "grid-auto-rows", "grid-column-gap", "grid-row-gap", "grid-template-areas", "grid-template-columns", "grid-template-rows", "row-gap"],
+  "grid-area": ["grid-column-end", "grid-column-start", "grid-row-end", "grid-row-start"],
+  "grid-auto-columns": ["grid-auto-columns"],
+  "grid-auto-flow": ["grid-auto-flow"],
+  "grid-auto-rows": ["grid-auto-rows"],
+  "grid-column": ["grid-column-end", "grid-column-start"],
+  "grid-column-end": ["grid-column-end"],
+  "grid-column-gap": ["grid-column-gap"],
+  "grid-column-start": ["grid-column-start"],
+  "grid-gap": ["grid-column-gap", "grid-row-gap"],
+  "grid-row": ["grid-row-end", "grid-row-start"],
+  "grid-row-end": ["grid-row-end"],
+  "grid-row-gap": ["grid-row-gap"],
+  "grid-row-start": ["grid-row-start"],
+  "grid-template": ["grid-template-areas", "grid-template-columns", "grid-template-rows"],
+  "grid-template-areas": ["grid-template-areas"],
+  "grid-template-columns": ["grid-template-columns"],
+  "grid-template-rows": ["grid-template-rows"],
+  "hanging-punctuation": ["hanging-punctuation"],
+  "height": ["height"],
+  "hyphenate-character": ["hyphenate-character"],
+  "hyphenate-limit-chars": ["hyphenate-limit-chars"],
+  "hyphens": ["hyphens"],
+  "image-orientation": ["image-orientation"],
+  "image-rendering": ["image-rendering"],
+  "image-resolution": ["image-resolution"],
+  "ime-mode": ["ime-mode"],
+  "initial-letter": ["initial-letter"],
+  "initial-letter-align": ["initial-letter-align"],
+  "inline-size": ["inline-size"],
+  "inset": ["bottom", "left", "right", "top"],
+  "inset-block": ["inset-block-end", "inset-block-start"],
+  "inset-block-end": ["inset-block-end"],
+  "inset-block-start": ["inset-block-start"],
+  "inset-inline": ["inset-inline-end", "inset-inline-start"],
+  "inset-inline-end": ["inset-inline-end"],
+  "inset-inline-start": ["inset-inline-start"],
+  "interactivity": ["interactivity"],
+  "interest-delay": ["interest-delay-end", "interest-delay-start"],
+  "interest-delay-end": ["interest-delay-end"],
+  "interest-delay-start": ["interest-delay-start"],
+  "interpolate-size": ["interpolate-size"],
+  "isolation": ["isolation"],
+  "justify-content": ["justify-content"],
+  "justify-items": ["justify-items"],
+  "justify-self": ["justify-self"],
+  "justify-tracks": ["justify-tracks"],
+  "left": ["left"],
+  "letter-spacing": ["letter-spacing"],
+  "lighting-color": ["lighting-color"],
+  "line-break": ["line-break"],
+  "line-clamp": ["line-clamp"],
+  "line-height": ["line-height"],
+  "line-height-step": ["line-height-step"],
+  "link-parameters": ["link-parameters"],
+  "list-style": ["list-style-image", "list-style-position", "list-style-type"],
+  "list-style-image": ["list-style-image"],
+  "list-style-position": ["list-style-position"],
+  "list-style-type": ["list-style-type"],
+  "margin": ["margin-bottom", "margin-left", "margin-right", "margin-top"],
+  "margin-block": ["margin-block-end", "margin-block-start"],
+  "margin-block-end": ["margin-block-end"],
+  "margin-block-start": ["margin-block-start"],
+  "margin-bottom": ["margin-bottom"],
+  "margin-inline": ["margin-inline-end", "margin-inline-start"],
+  "margin-inline-end": ["margin-inline-end"],
+  "margin-inline-start": ["margin-inline-start"],
+  "margin-left": ["margin-left"],
+  "margin-right": ["margin-right"],
+  "margin-top": ["margin-top"],
+  "margin-trim": ["margin-trim"],
+  "marker": ["marker"],
+  "marker-end": ["marker-end"],
+  "marker-mid": ["marker-mid"],
+  "marker-start": ["marker-start"],
+  "mask": ["mask-clip", "mask-composite", "mask-image", "mask-mode", "mask-origin", "mask-position", "mask-repeat", "mask-size"],
+  "mask-border": ["mask-border-mode", "mask-border-outset", "mask-border-repeat", "mask-border-slice", "mask-border-source", "mask-border-width"],
+  "mask-border-mode": ["mask-border-mode"],
+  "mask-border-outset": ["mask-border-outset"],
+  "mask-border-repeat": ["mask-border-repeat"],
+  "mask-border-slice": ["mask-border-slice"],
+  "mask-border-source": ["mask-border-source"],
+  "mask-border-width": ["mask-border-width"],
+  "mask-clip": ["mask-clip"],
+  "mask-composite": ["mask-composite"],
+  "mask-image": ["mask-image"],
+  "mask-mode": ["mask-mode"],
+  "mask-origin": ["mask-origin"],
+  "mask-position": ["mask-position"],
+  "mask-repeat": ["mask-repeat"],
+  "mask-size": ["mask-size"],
+  "mask-type": ["mask-type"],
+  "masonry-auto-flow": ["masonry-auto-flow"],
+  "math-depth": ["math-depth"],
+  "math-shift": ["math-shift"],
+  "math-style": ["math-style"],
+  "max-block-size": ["max-block-size"],
+  "max-height": ["max-height"],
+  "max-inline-size": ["max-inline-size"],
+  "max-lines": ["max-lines"],
+  "max-width": ["max-width"],
+  "min-block-size": ["min-block-size"],
+  "min-height": ["min-height"],
+  "min-inline-size": ["min-inline-size"],
+  "min-width": ["min-width"],
+  "mix-blend-mode": ["mix-blend-mode"],
+  "object-fit": ["object-fit"],
+  "object-position": ["object-position"],
+  "object-view-box": ["object-view-box"],
+  "offset": ["offset-anchor", "offset-distance", "offset-path", "offset-position", "offset-rotate"],
+  "offset-anchor": ["offset-anchor"],
+  "offset-distance": ["offset-distance"],
+  "offset-path": ["offset-path"],
+  "offset-position": ["offset-position"],
+  "offset-rotate": ["offset-rotate"],
+  "opacity": ["opacity"],
+  "order": ["order"],
+  "orphans": ["orphans"],
+  "outline": ["outline-color", "outline-style", "outline-width"],
+  "outline-color": ["outline-color"],
+  "outline-offset": ["outline-offset"],
+  "outline-style": ["outline-style"],
+  "outline-width": ["outline-width"],
+  "overflow": ["overflow-x", "overflow-y"],
+  "overflow-anchor": ["overflow-anchor"],
+  "overflow-block": ["overflow-block"],
+  "overflow-clip-box": ["overflow-clip-box"],
+  "overflow-clip-margin": ["overflow-clip-margin"],
+  "overflow-inline": ["overflow-inline"],
+  "overflow-wrap": ["overflow-wrap"],
+  "overflow-x": ["overflow-x"],
+  "overflow-y": ["overflow-y"],
+  "overlay": ["overlay"],
+  "overscroll-behavior": ["overscroll-behavior-x", "overscroll-behavior-y"],
+  "overscroll-behavior-block": ["overscroll-behavior-block"],
+  "overscroll-behavior-inline": ["overscroll-behavior-inline"],
+  "overscroll-behavior-x": ["overscroll-behavior-x"],
+  "overscroll-behavior-y": ["overscroll-behavior-y"],
+  "padding": ["padding-bottom", "padding-left", "padding-right", "padding-top"],
+  "padding-block": ["padding-block-end", "padding-block-start"],
+  "padding-block-end": ["padding-block-end"],
+  "padding-block-start": ["padding-block-start"],
+  "padding-bottom": ["padding-bottom"],
+  "padding-inline": ["padding-inline-end", "padding-inline-start"],
+  "padding-inline-end": ["padding-inline-end"],
+  "padding-inline-start": ["padding-inline-start"],
+  "padding-left": ["padding-left"],
+  "padding-right": ["padding-right"],
+  "padding-top": ["padding-top"],
+  "page": ["page"],
+  "page-break-after": ["break-after"],
+  "page-break-before": ["break-before"],
+  "page-break-inside": ["break-inside"],
+  "paint-order": ["paint-order"],
+  "path-length": ["path-length"],
+  "perspective": ["perspective"],
+  "perspective-origin": ["perspective-origin"],
+  "place-content": ["align-content", "justify-content"],
+  "place-items": ["align-items", "justify-items"],
+  "place-self": ["align-self", "justify-self"],
+  "pointer-events": ["pointer-events"],
+  "position": ["position"],
+  "position-anchor": ["position-anchor"],
+  "position-area": ["position-area"],
+  "position-try": ["position-try-fallbacks", "position-try-order"],
+  "position-try-fallbacks": ["position-try-fallbacks"],
+  "position-try-order": ["position-try-order"],
+  "position-visibility": ["position-visibility"],
+  "print-color-adjust": ["print-color-adjust"],
+  "quotes": ["quotes"],
+  "r": ["r"],
+  "reading-flow": ["reading-flow"],
+  "reading-order": ["reading-order"],
+  "resize": ["resize"],
+  "right": ["right"],
+  "rotate": ["rotate"],
+  "row-gap": ["row-gap"],
+  "ruby-align": ["ruby-align"],
+  "ruby-merge": ["ruby-merge"],
+  "ruby-overhang": ["ruby-overhang"],
+  "ruby-position": ["ruby-position"],
+  "rx": ["rx"],
+  "ry": ["ry"],
+  "scale": ["scale"],
+  "scroll-axis-lock": ["scroll-axis-lock"],
+  "scroll-behavior": ["scroll-behavior"],
+  "scroll-initial-target": ["scroll-initial-target"],
+  "scroll-margin": ["scroll-margin-bottom", "scroll-margin-left", "scroll-margin-right", "scroll-margin-top"],
+  "scroll-margin-block": ["scroll-margin-block-end", "scroll-margin-block-start"],
+  "scroll-margin-block-end": ["scroll-margin-block-end"],
+  "scroll-margin-block-start": ["scroll-margin-block-start"],
+  "scroll-margin-bottom": ["scroll-margin-bottom"],
+  "scroll-margin-inline": ["scroll-margin-inline-end", "scroll-margin-inline-start"],
+  "scroll-margin-inline-end": ["scroll-margin-inline-end"],
+  "scroll-margin-inline-start": ["scroll-margin-inline-start"],
+  "scroll-margin-left": ["scroll-margin-left"],
+  "scroll-margin-right": ["scroll-margin-right"],
+  "scroll-margin-top": ["scroll-margin-top"],
+  "scroll-marker-group": ["scroll-marker-group"],
+  "scroll-padding": ["scroll-padding-bottom", "scroll-padding-left", "scroll-padding-right", "scroll-padding-top"],
+  "scroll-padding-block": ["scroll-padding-block-end", "scroll-padding-block-start"],
+  "scroll-padding-block-end": ["scroll-padding-block-end"],
+  "scroll-padding-block-start": ["scroll-padding-block-start"],
+  "scroll-padding-bottom": ["scroll-padding-bottom"],
+  "scroll-padding-inline": ["scroll-padding-inline-end", "scroll-padding-inline-start"],
+  "scroll-padding-inline-end": ["scroll-padding-inline-end"],
+  "scroll-padding-inline-start": ["scroll-padding-inline-start"],
+  "scroll-padding-left": ["scroll-padding-left"],
+  "scroll-padding-right": ["scroll-padding-right"],
+  "scroll-padding-top": ["scroll-padding-top"],
+  "scroll-snap-align": ["scroll-snap-align"],
+  "scroll-snap-coordinate": ["scroll-snap-coordinate"],
+  "scroll-snap-destination": ["scroll-snap-destination"],
+  "scroll-snap-points-x": ["scroll-snap-points-x"],
+  "scroll-snap-points-y": ["scroll-snap-points-y"],
+  "scroll-snap-stop": ["scroll-snap-stop"],
+  "scroll-snap-type": ["scroll-snap-type"],
+  "scroll-snap-type-x": ["scroll-snap-type-x"],
+  "scroll-snap-type-y": ["scroll-snap-type-y"],
+  "scroll-target-group": ["scroll-target-group"],
+  "scroll-timeline": ["scroll-timeline-axis", "scroll-timeline-name"],
+  "scroll-timeline-axis": ["scroll-timeline-axis"],
+  "scroll-timeline-name": ["scroll-timeline-name"],
+  "scrollbar-color": ["scrollbar-color"],
+  "scrollbar-gutter": ["scrollbar-gutter"],
+  "scrollbar-width": ["scrollbar-width"],
+  "shape-image-threshold": ["shape-image-threshold"],
+  "shape-margin": ["shape-margin"],
+  "shape-outside": ["shape-outside"],
+  "shape-rendering": ["shape-rendering"],
+  "speak-as": ["speak-as"],
+  "stop-color": ["stop-color"],
+  "stop-opacity": ["stop-opacity"],
+  "stroke": ["stroke"],
+  "stroke-color": ["stroke-color"],
+  "stroke-dasharray": ["stroke-dasharray"],
+  "stroke-dashoffset": ["stroke-dashoffset"],
+  "stroke-linecap": ["stroke-linecap"],
+  "stroke-linejoin": ["stroke-linejoin"],
+  "stroke-miterlimit": ["stroke-miterlimit"],
+  "stroke-opacity": ["stroke-opacity"],
+  "stroke-width": ["stroke-width"],
+  "tab-size": ["tab-size"],
+  "table-layout": ["table-layout"],
+  "text-align": ["text-align"],
+  "text-align-last": ["text-align-last"],
+  "text-anchor": ["text-anchor"],
+  "text-autospace": ["text-autospace"],
+  "text-box": ["text-box"],
+  "text-box-edge": ["text-box-edge"],
+  "text-box-trim": ["text-box-trim"],
+  "text-combine-upright": ["text-combine-upright"],
+  "text-decoration": ["text-decoration-color", "text-decoration-line", "text-decoration-style", "text-decoration-thickness"],
+  "text-decoration-color": ["text-decoration-color"],
+  "text-decoration-inset": ["text-decoration-inset"],
+  "text-decoration-line": ["text-decoration-line"],
+  "text-decoration-skip": ["text-decoration-skip"],
+  "text-decoration-skip-ink": ["text-decoration-skip-ink"],
+  "text-decoration-style": ["text-decoration-style"],
+  "text-decoration-thickness": ["text-decoration-thickness"],
+  "text-emphasis": ["text-emphasis-color", "text-emphasis-style"],
+  "text-emphasis-color": ["text-emphasis-color"],
+  "text-emphasis-position": ["text-emphasis-position"],
+  "text-emphasis-style": ["text-emphasis-style"],
+  "text-fit": ["text-fit"],
+  "text-indent": ["text-indent"],
+  "text-justify": ["text-justify"],
+  "text-orientation": ["text-orientation"],
+  "text-overflow": ["text-overflow"],
+  "text-rendering": ["text-rendering"],
+  "text-shadow": ["text-shadow"],
+  "text-size-adjust": ["text-size-adjust"],
+  "text-spacing-trim": ["text-spacing-trim"],
+  "text-transform": ["text-transform"],
+  "text-underline-offset": ["text-underline-offset"],
+  "text-underline-position": ["text-underline-position"],
+  "text-wrap": ["text-wrap-mode", "text-wrap-style"],
+  "text-wrap-mode": ["text-wrap-mode"],
+  "text-wrap-style": ["text-wrap-style"],
+  "timeline-scope": ["timeline-scope"],
+  "timeline-trigger": ["timeline-trigger-activation-range-end", "timeline-trigger-activation-range-start", "timeline-trigger-active-range-end", "timeline-trigger-active-range-start", "timeline-trigger-name", "timeline-trigger-source"],
+  "timeline-trigger-activation-range": ["timeline-trigger-activation-range-end", "timeline-trigger-activation-range-start"],
+  "timeline-trigger-activation-range-end": ["timeline-trigger-activation-range-end"],
+  "timeline-trigger-activation-range-start": ["timeline-trigger-activation-range-start"],
+  "timeline-trigger-active-range": ["timeline-trigger-active-range-end", "timeline-trigger-active-range-start"],
+  "timeline-trigger-active-range-end": ["timeline-trigger-active-range-end"],
+  "timeline-trigger-active-range-start": ["timeline-trigger-active-range-start"],
+  "timeline-trigger-name": ["timeline-trigger-name"],
+  "timeline-trigger-source": ["timeline-trigger-source"],
+  "top": ["top"],
+  "touch-action": ["touch-action"],
+  "transform": ["transform"],
+  "transform-box": ["transform-box"],
+  "transform-origin": ["transform-origin"],
+  "transform-style": ["transform-style"],
+  "transition": ["transition-behavior", "transition-delay", "transition-duration", "transition-property", "transition-timing-function"],
+  "transition-behavior": ["transition-behavior"],
+  "transition-delay": ["transition-delay"],
+  "transition-duration": ["transition-duration"],
+  "transition-property": ["transition-property"],
+  "transition-timing-function": ["transition-timing-function"],
+  "translate": ["translate"],
+  "trigger-scope": ["trigger-scope"],
+  "unicode-bidi": ["unicode-bidi"],
+  "user-select": ["user-select"],
+  "vector-effect": ["vector-effect"],
+  "vertical-align": ["vertical-align"],
+  "view-timeline": ["view-timeline-axis", "view-timeline-name"],
+  "view-timeline-axis": ["view-timeline-axis"],
+  "view-timeline-inset": ["view-timeline-inset"],
+  "view-timeline-name": ["view-timeline-name"],
+  "view-transition-class": ["view-transition-class"],
+  "view-transition-name": ["view-transition-name"],
+  "view-transition-scope": ["view-transition-scope"],
+  "visibility": ["visibility"],
+  "white-space": ["text-wrap-mode", "white-space-collapse", "white-space-trim"],
+  "white-space-collapse": ["white-space-collapse"],
+  "white-space-trim": ["white-space-trim"],
+  "widows": ["widows"],
+  "width": ["width"],
+  "will-change": ["will-change"],
+  "window-drag": ["window-drag"],
+  "word-break": ["word-break"],
+  "word-spacing": ["word-spacing"],
+  "word-wrap": ["word-wrap"],
+  "writing-mode": ["writing-mode"],
+  "x": ["x"],
+  "y": ["y"],
+  "z-index": ["z-index"],
+  "zoom": ["zoom"]
+};
+var LEGACY_ALIASES = {
+  "grid-column-gap": "column-gap",
+  "grid-gap": "gap",
+  "grid-row-gap": "row-gap",
+  "word-wrap": "overflow-wrap"
+};
+var LOGICAL_GROUPS = {
+  "size": { logical: ["block-size", "inline-size"], physical: ["height", "width"] },
+  "min-size": { logical: ["min-block-size", "min-inline-size"], physical: ["min-height", "min-width"] },
+  "max-size": { logical: ["max-block-size", "max-inline-size"], physical: ["max-height", "max-width"] },
+  "margin": { logical: ["margin-block-start", "margin-block-end", "margin-inline-start", "margin-inline-end"], physical: ["margin-top", "margin-right", "margin-bottom", "margin-left"] },
+  "padding": { logical: ["padding-block-start", "padding-block-end", "padding-inline-start", "padding-inline-end"], physical: ["padding-top", "padding-right", "padding-bottom", "padding-left"] },
+  "inset": { logical: ["inset-block-start", "inset-block-end", "inset-inline-start", "inset-inline-end"], physical: ["top", "right", "bottom", "left"] },
+  "border-width": { logical: ["border-block-start-width", "border-block-end-width", "border-inline-start-width", "border-inline-end-width"], physical: ["border-top-width", "border-right-width", "border-bottom-width", "border-left-width"] },
+  "border-style": { logical: ["border-block-start-style", "border-block-end-style", "border-inline-start-style", "border-inline-end-style"], physical: ["border-top-style", "border-right-style", "border-bottom-style", "border-left-style"] },
+  "border-color": { logical: ["border-block-start-color", "border-block-end-color", "border-inline-start-color", "border-inline-end-color"], physical: ["border-top-color", "border-right-color", "border-bottom-color", "border-left-color"] },
+  "border-radius": { logical: ["border-start-start-radius", "border-start-end-radius", "border-end-start-radius", "border-end-end-radius"], physical: ["border-top-left-radius", "border-top-right-radius", "border-bottom-left-radius", "border-bottom-right-radius"] },
+  "overflow": { logical: ["overflow-block", "overflow-inline"], physical: ["overflow-x", "overflow-y"] },
+  "overscroll-behavior": { logical: ["overscroll-behavior-block", "overscroll-behavior-inline"], physical: ["overscroll-behavior-x", "overscroll-behavior-y"] },
+  "scroll-padding": { logical: ["scroll-padding-block-start", "scroll-padding-block-end", "scroll-padding-inline-start", "scroll-padding-inline-end"], physical: ["scroll-padding-top", "scroll-padding-right", "scroll-padding-bottom", "scroll-padding-left"] },
+  "scroll-margin": { logical: ["scroll-margin-block-start", "scroll-margin-block-end", "scroll-margin-inline-start", "scroll-margin-inline-end"], physical: ["scroll-margin-top", "scroll-margin-right", "scroll-margin-bottom", "scroll-margin-left"] },
+  "contain-intrinsic-size": { logical: ["contain-intrinsic-block-size", "contain-intrinsic-inline-size"], physical: ["contain-intrinsic-height", "contain-intrinsic-width"] }
+};
+
+// src/directive/property-relations.ts
+var VENDOR_PREFIXED = /^-(?:webkit|moz|ms|o)-[a-z0-9-]+$/;
+var ALIASES = new Map(Object.entries(LEGACY_ALIASES));
+var LONGHAND_LISTS = new Map(Object.entries(PROPERTY_LONGHANDS));
+var LONGHAND_SETS = new Map(
+  Object.entries(PROPERTY_LONGHANDS).map(([name, longhands]) => [name, new Set(longhands)])
+);
+var GROUP_OF_LONGHAND = new Map(
+  Object.entries(LOGICAL_GROUPS).flatMap(([group, { logical, physical }]) => [
+    ...logical.map((name) => [
+      name,
+      { logical: true, group }
+    ]),
+    ...physical.map((name) => [
+      name,
+      { logical: false, group }
+    ])
+  ])
+);
+function isCustomProperty(name) {
+  return name.startsWith("--") && name.length > 2;
+}
+function foldAscii(name) {
+  return name.replaceAll(/[A-Z]+/g, (letters) => letters.toLowerCase());
+}
+function standardName(name) {
+  if (isCustomProperty(name)) return name;
+  const folded = foldAscii(name);
+  return ALIASES.get(folded) ?? folded;
+}
+function isSameProperty(a, b) {
+  return standardName(a) === standardName(b);
+}
+function knownLonghands(name) {
+  return LONGHAND_SETS.get(foldAscii(name));
+}
+function isCssProperty(name) {
+  return isCustomProperty(name) || VENDOR_PREFIXED.test(foldAscii(name)) || knownLonghands(name) !== void 0;
+}
+function longhandsOf(name) {
+  if (isCustomProperty(name)) return [name];
+  const folded = foldAscii(name);
+  if (VENDOR_PREFIXED.test(folded)) return [folded];
+  return LONGHAND_LISTS.get(folded) ?? [];
+}
+function haveCommonMember(a, b) {
+  const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
+  return [...smaller].some((member) => larger.has(member));
+}
+function sidesOf(longhands) {
+  const sides = /* @__PURE__ */ new Map();
+  for (const longhand of longhands) {
+    const member = GROUP_OF_LONGHAND.get(longhand);
+    if (member === void 0) continue;
+    const side = member.logical ? "logical" : "physical";
+    const known = sides.get(member.group);
+    sides.set(member.group, known === void 0 || known === side ? side : "both");
+  }
+  return sides;
+}
+function isLogicalPhysicalPair(a, b) {
+  const first = knownLonghands(a);
+  const second = knownLonghands(b);
+  if (first === void 0 || second === void 0 || foldAscii(a) === foldAscii(b)) return false;
+  const secondSides = sidesOf(second);
+  return [...sidesOf(first)].some(([group, side]) => {
+    const other = secondSides.get(group);
+    return other !== void 0 && side !== "both" && other !== "both" && side !== other;
+  });
+}
+function propertiesRelate(a, b) {
+  if (isCustomProperty(a) || isCustomProperty(b)) return a === b;
+  const first = standardName(a);
+  const second = standardName(b);
+  if (first === second) return true;
+  if (VENDOR_PREFIXED.test(first) || VENDOR_PREFIXED.test(second)) return false;
+  const firstLonghands = LONGHAND_SETS.get(first);
+  const secondLonghands = LONGHAND_SETS.get(second);
+  if (firstLonghands === void 0 || secondLonghands === void 0) return false;
+  return haveCommonMember(firstLonghands, secondLonghands) || isLogicalPhysicalPair(first, second);
+}
+
+// src/directive/selector-compounds.ts
+var OPENERS2 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+var COMBINATOR_DELIMS = /* @__PURE__ */ new Set(["+", ">", "~"]);
+var LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set(["after", "before", "first-letter", "first-line"]);
+function isDelim(token, value) {
+  return token?.type === "delim-token" && token.raw === value;
+}
+function isTypeName(token) {
+  return token?.type === "ident-token" || isDelim(token, "*");
+}
+function groupEnd(tokens, start) {
+  let depth = 1;
+  let index = start + 1;
+  while (index < tokens.length) {
+    const { type } = tokens[index];
+    if (OPENERS2.has(type)) depth += 1;
+    else if (CLOSERS.has(type)) depth -= 1;
+    if (depth === 0) return index;
+    index += 1;
+  }
+  return tokens.length;
+}
+function readTypeSelector(tokens, index) {
+  let nameIndex = index;
+  if (isTypeName(tokens[index]) && isDelim(tokens[index + 1], "|") && isTypeName(tokens[index + 2])) {
+    nameIndex = index + 2;
+  } else if (isDelim(tokens[index], "|") && isTypeName(tokens[index + 1])) {
+    nameIndex = index + 1;
+  }
+  const kind = isDelim(tokens[nameIndex], "*") ? "universal" : "type";
+  return { simple: { kind }, next: nameIndex + 1 };
+}
+function readIdentPseudo(name, nameIndex, isElement) {
+  const lowered = name.raw.toLowerCase();
+  const isPseudoElement = isElement || LEGACY_PSEUDO_ELEMENTS.has(lowered);
+  const simple = isPseudoElement ? { kind: "pseudo-element", args: [], name: lowered } : { kind: "class" };
+  return { simple, next: nameIndex + 1 };
+}
+function readFunctionPseudo(tokens, nameIndex, isElement) {
+  const end = groupEnd(tokens, nameIndex);
+  const name = tokens[nameIndex].structured.value.toLowerCase();
+  const args = tokens.slice(nameIndex + 1, end);
+  const kind = isElement ? "pseudo-element" : "function";
+  return { simple: { kind, args, name }, next: end + 1 };
+}
+function readPseudo(tokens, index) {
+  const isElement = tokens[index + 1]?.type === "colon-token";
+  const nameIndex = index + (isElement ? 2 : 1);
+  const name = tokens[nameIndex];
+  if (name?.type === "ident-token") return readIdentPseudo(name, nameIndex, isElement);
+  if (name?.type === "function-token") return readFunctionPseudo(tokens, nameIndex, isElement);
+  return { next: nameIndex };
+}
+function readSimple(tokens, index) {
+  const token = tokens[index];
+  if (isDelim(token, "&")) return { simple: { kind: "nesting" }, next: index + 1 };
+  if (isTypeName(token) || isDelim(token, "|")) return readTypeSelector(tokens, index);
+  if (isDelim(token, ".") && tokens[index + 1]?.type === "ident-token") {
+    return { simple: { kind: "class" }, next: index + 2 };
+  }
+  if (token.type === "hash-token") return { simple: { kind: "id" }, next: index + 1 };
+  if (token.type === "[-token")
+    return { simple: { kind: "class" }, next: groupEnd(tokens, index) + 1 };
+  if (token.type === "colon-token") return readPseudo(tokens, index);
+  return { next: index + 1 };
+}
+function isCombinator(token) {
+  return token.type === "whitespace-token" || token.type === "delim-token" && COMBINATOR_DELIMS.has(token.raw);
+}
+function parseComplex(tokens) {
+  const compounds = [];
+  let current = [];
+  let index = 0;
+  while (index < tokens.length) {
+    if (isCombinator(tokens[index])) {
+      if (current.length > 0) compounds.push(current);
+      current = [];
+      index += 1;
+      continue;
+    }
+    const read = readSimple(tokens, index);
+    if (read.simple) current.push(read.simple);
+    index = read.next;
+  }
+  if (current.length > 0) compounds.push(current);
+  return compounds;
+}
+function splitOnCommas(tokens) {
+  const parts = [[]];
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token.type === "comma-token") {
+      parts.push([]);
+      index += 1;
+      continue;
+    }
+    const end = OPENERS2.has(token.type) ? groupEnd(tokens, index) : index;
+    parts.at(-1).push(...tokens.slice(index, end + 1));
+    index = end + 1;
+  }
+  return parts;
+}
+function codeTokens(text) {
+  return tokenize(text).filter((token) => token.type !== "comment");
+}
+function parseSelectorTokens(tokens) {
+  return splitOnCommas(tokens).map((part) => parseComplex(part)).filter((complex) => complex.length > 0);
+}
+function parseSelectorList(selectorList) {
+  return parseSelectorTokens(codeTokens(selectorList));
+}
+function tokensAfterOf(args) {
+  const ofIndex = args.findIndex(
+    (token, index) => token.type === "ident-token" && token.raw.toLowerCase() === "of" && args[index - 1]?.type === "whitespace-token"
+  );
+  return ofIndex === -1 ? [] : args.slice(ofIndex + 1);
+}
+function subjectOf(complex) {
+  return complex.at(-1) ?? [];
+}
+function hasPseudoElement(compound) {
+  return compound.some((simple) => simple.kind === "pseudo-element");
+}
+
+// src/directive/selector-specificity.ts
+var ZERO = [0, 0, 0];
+var ONE_CLASS = [0, 1, 0];
+var ONE_TYPE = [0, 0, 1];
+var ONE_ID = [1, 0, 0];
+var FIXED_WEIGHTS = {
+  class: ONE_CLASS,
+  id: ONE_ID,
+  type: ONE_TYPE,
+  universal: ZERO
+};
+var ARGUMENT_MAX_PSEUDOS = /* @__PURE__ */ new Set(["has", "is", "not"]);
+var NTH_PSEUDOS = /* @__PURE__ */ new Set(["nth-child", "nth-last-child"]);
+var SUBJECT_TRANSPARENT_PSEUDOS = /* @__PURE__ */ new Set(["is", "where"]);
+var MAX_NESTING = 256;
+var UnreadableSelector = class extends Error {
+};
+function deeper(depth) {
+  if (depth >= MAX_NESTING) throw new UnreadableSelector("selector nests too deep to be read");
+  return depth + 1;
+}
+function compareSpecificity(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+function addSpecificity(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function maxSpecificity(specificities) {
+  return specificities.reduce(
+    (heaviest, next) => compareSpecificity(next, heaviest) > 0 ? next : heaviest,
+    ZERO
+  );
+}
+function pseudoElementSpecificity(name, args, weigh) {
+  if (name !== "slotted") return ONE_TYPE;
+  const argument = listSpecificity(parseSelectorTokens(args), {
+    ...weigh,
+    depth: deeper(weigh.depth)
+  });
+  return addSpecificity(ONE_TYPE, argument);
+}
+function functionSpecificity(name, args, weigh) {
+  if (name === "where") return ZERO;
+  const inner = { ...weigh, depth: deeper(weigh.depth) };
+  if (ARGUMENT_MAX_PSEUDOS.has(name)) return listSpecificity(parseSelectorTokens(args), inner);
+  if (!NTH_PSEUDOS.has(name)) return ONE_CLASS;
+  const argument = listSpecificity(parseSelectorTokens(tokensAfterOf(args)), inner);
+  return addSpecificity(ONE_CLASS, argument);
+}
+function simpleSpecificity(simple, weigh) {
+  if (simple.kind === "nesting") return weigh.amp;
+  if (simple.kind === "function") return functionSpecificity(simple.name, simple.args, weigh);
+  if (simple.kind === "pseudo-element")
+    return pseudoElementSpecificity(simple.name, simple.args, weigh);
+  return FIXED_WEIGHTS[simple.kind];
+}
+function complexSpecificity(complex, weigh) {
+  return complex.flat().reduce((sum, simple) => addSpecificity(sum, simpleSpecificity(simple, weigh)), ZERO);
+}
+function listSpecificity(list, weigh) {
+  return maxSpecificity(list.map((complex) => complexSpecificity(complex, weigh)));
+}
+function isSubjectOnAmpersandElement(compound, depth) {
+  return compound.some((simple) => {
+    if (simple.kind === "nesting") return true;
+    if (simple.kind !== "function" || !SUBJECT_TRANSPARENT_PSEUDOS.has(simple.name)) return false;
+    const inner = deeper(depth);
+    return parseSelectorTokens(simple.args).some(
+      (arm) => isSubjectOnAmpersandElement(subjectOf(arm), inner)
+    );
+  });
+}
+function isComplexEndingInPseudoElement(complex) {
+  return hasPseudoElement(subjectOf(complex));
+}
+function endsInPseudoElement(complexSelector) {
+  return parseSelectorList(complexSelector).some(
+    (complex) => isComplexEndingInPseudoElement(complex)
+  );
+}
+function isPseudoElementOnlyList(selectorList) {
+  const list = parseSelectorList(selectorList);
+  return list.length > 0 && list.every((complex) => isComplexEndingInPseudoElement(complex));
+}
+function ampersandSpecificity(parentSelectorList) {
+  const onElement = parseSelectorList(parentSelectorList).filter(
+    (complex) => !isComplexEndingInPseudoElement(complex)
+  );
+  try {
+    return listSpecificity(onElement, { amp: ONE_CLASS, depth: 0 });
+  } catch (error) {
+    if (error instanceof UnreadableSelector) return ZERO;
+    throw error;
+  }
+}
+function nestedSpecificities(selector, amp) {
+  try {
+    return parseSelectorList(selector).filter(
+      (complex) => !isComplexEndingInPseudoElement(complex) && isSubjectOnAmpersandElement(subjectOf(complex), 0)
+    ).map((complex) => complexSpecificity(complex, { amp, depth: 0 }));
+  } catch (error) {
+    if (error instanceof UnreadableSelector) return [];
+    throw error;
+  }
+}
+
+// src/directive/value-equality.ts
+function foldAscii2(name) {
+  return name.replaceAll(/[A-Z]+/g, (letters) => letters.toLowerCase());
+}
+function tokenKey(token) {
+  if (token.type === "whitespace-token") return "ws";
+  const isFoldable = token.type === "function-token" && !token.raw.startsWith("--");
+  return `${token.type}:${isFoldable ? foldAscii2(token.raw) : token.raw}`;
+}
+function normalizedKeys(value) {
+  const keys = [];
+  for (const token of tokenize(value)) {
+    if (token.type === "comment") continue;
+    const key = tokenKey(token);
+    if (key === "ws" && (keys.length === 0 || keys.at(-1) === "ws")) continue;
+    keys.push(key);
+  }
+  if (keys.at(-1) === "ws") keys.pop();
+  return keys;
+}
+function normalizeValueForCompare(value) {
+  return JSON.stringify(normalizedKeys(value));
+}
+
+// src/directive/order-compare.ts
+var VALUE_KEYS = /* @__PURE__ */ new WeakMap();
+function valueKey(declaration) {
+  let key = VALUE_KEYS.get(declaration);
+  if (key === void 0) {
+    key = normalizeValueForCompare(declaration.value);
+    VALUE_KEYS.set(declaration, key);
+  }
+  return key;
+}
+function relatedPairs(unit, candidate) {
+  const later = candidate.declaration;
+  if (later.important) return [];
+  return unit.declarations.filter((block) => !block.important && propertiesRelate(block.prop, later.prop)).filter(
+    (block) => !isSameProperty(block.prop, later.prop) || valueKey(block) !== valueKey(later)
+  ).map((block) => ({ block, later }));
+}
+function haveEqualSpecificity(a, b) {
+  return a.some((x) => b.some((y) => compareSpecificity(x, y) === 0));
+}
+function compare(unit, candidate) {
+  if (!haveEqualSpecificity(unit.specificities, candidate.specificities)) return void 0;
+  if (!conditionsMayOverlap(unit.conditions, candidate.conditions)) return void 0;
+  const pairs2 = relatedPairs(unit, candidate);
+  return pairs2.length === 0 ? void 0 : { unit, candidate, pairs: pairs2 };
+}
+
+// src/directive/order-moves.ts
+var MOVE_LIMIT = 50;
+function pairKey({ candidate, unit }) {
+  const { overrider } = candidate;
+  const who = overrider.kind === "atom" ? ["atom", overrider.directive.ref, overrider.atom.atomIndex, overrider.isBlock] : ["own", overrider.topRef];
+  return JSON.stringify([
+    unit.directive.ref,
+    unit.atom.atomIndex,
+    unit.selector,
+    unit.conditions,
+    unit.declarations,
+    who,
+    candidate.declaration,
+    candidate.holderSelector,
+    candidate.conditions
+  ]);
+}
+var ownNode = (ref) => (segment) => segment.kind === "own" && segment.node.ref === ref;
+var ofDirective = (ref) => (segment) => segment.kind !== "own" && segment.directive.ref === ref;
+var ofAtom = (ref, atomIndex) => (segment) => segment.kind !== "own" && segment.directive.ref === ref && segment.atom.atomIndex === atomIndex;
+var namedAtom = (ref, name) => (segment) => segment.kind !== "own" && segment.directive.ref === ref && segment.atom.name === name;
+function relocated(segments, isMoved, place) {
+  const moved = segments.filter((segment) => isMoved(segment));
+  const rest = segments.filter((segment) => !isMoved(segment));
+  const index = "before" in place ? rest.findIndex((segment) => place.before(segment)) : rest.findLastIndex((segment) => place.after(segment));
+  if (index === -1 || moved.length === 0) return void 0;
+  const at = "before" in place ? index : index + 1;
+  return {
+    arranged: [...rest.slice(0, at), ...moved, ...rest.slice(at)],
+    moved: new Set(moved)
+  };
+}
+function moveOf(relocation, key) {
+  return relocation && {
+    arranged: relocation.arranged,
+    key,
+    scope: { kind: "moved", segments: relocation.moved }
+  };
+}
+function lastOverriderIndex(finding, all) {
+  const { unit, candidate } = finding;
+  if (candidate.overrider.kind !== "atom" || candidate.overrider.directive.ref !== unit.directive.ref) {
+    return void 0;
+  }
+  const indexes = all.filter(
+    (other) => other.unit.directive.ref === unit.directive.ref && other.unit.atom.name === unit.atom.name
+  ).flatMap(
+    (other) => other.candidate.overrider.kind === "atom" && other.candidate.overrider.directive.ref === unit.directive.ref ? [other.candidate.overrider.atom.atomIndex] : []
+  );
+  return Math.max(...indexes);
+}
+function childrenMoved(children, moving, before) {
+  const node = children.find((child) => child.ref === moving);
+  const rest = children.filter((child) => child.ref !== moving);
+  const at = rest.findIndex((child) => child.ref === before);
+  if (node === void 0 || at === -1) return void 0;
+  return [...rest.slice(0, at), node, ...rest.slice(at)];
+}
+function groupWithChildMoved(root, at) {
+  if (root.kind !== "group") return void 0;
+  const stack = [{ node: root, next: 0 }];
+  while (stack.length > 0 && stack.at(-1).node.ref !== at.group) {
+    const frame = stack.at(-1);
+    const child = frame.node.nodes[frame.next++];
+    if (child === void 0) stack.pop();
+    else if (child.kind === "group") stack.push({ node: child, next: 0 });
+  }
+  const target = stack.at(-1);
+  const moved = target && childrenMoved(target.node.nodes, at.moving, at.before);
+  if (target === void 0 || moved === void 0) return void 0;
+  let rebuilt = { ...target.node, nodes: moved };
+  for (let i = stack.length - 2; i >= 0; i--) {
+    const replaced = stack[i + 1].node;
+    rebuilt = {
+      ...stack[i].node,
+      nodes: stack[i].node.nodes.map((child) => child === replaced ? rebuilt : child)
+    };
+  }
+  return rebuilt;
+}
+function outwardMove(finding, segments) {
+  const { outward, candidate } = finding;
+  const { overrider } = candidate;
+  if (outward === void 0) return void 0;
+  const { level, top } = outward;
+  const mover = overrider.kind === "own" ? `own:${overrider.topRef}` : `directive:${overrider.directive.ref}`;
+  const key = JSON.stringify(["outward", top, level, mover]);
+  if (level === void 0) {
+    const moving = overrider.kind === "own" ? ownNode(overrider.topRef) : ofDirective(overrider.directive.ref);
+    return moveOf(relocated(segments, moving, { before: ownNode(top) }), key);
+  }
+  const holder = segments.find(ownNode(top));
+  if (holder?.kind !== "own" || overrider.kind !== "own") return void 0;
+  const rebuilt = groupWithChildMoved(holder.node, {
+    before: level.container,
+    group: level.group,
+    moving: overrider.topRef
+  });
+  if (rebuilt === void 0) return void 0;
+  const regrouped = { ...holder, node: rebuilt };
+  const arranged = segments.map((segment) => segment === holder ? regrouped : segment);
+  return { arranged, key, scope: { child: overrider.topRef, kind: "child", top: regrouped } };
+}
+function ruleMove(finding, segments, all) {
+  const { candidate, unit } = finding;
+  const { overrider } = candidate;
+  if (overrider.kind === "own") {
+    const relocation2 = relocated(segments, ownNode(overrider.topRef), {
+      before: ofDirective(unit.directive.ref)
+    });
+    return moveOf(relocation2, `own:${overrider.topRef}:${unit.directive.ref}`);
+  }
+  const index = lastOverriderIndex(finding, all) ?? overrider.atom.atomIndex;
+  const relocation = relocated(segments, namedAtom(unit.directive.ref, unit.atom.name), {
+    after: ofAtom(overrider.directive.ref, index)
+  });
+  const key = `atom:${unit.directive.ref}:${unit.atom.name}:${overrider.directive.ref}:${index}`;
+  return moveOf(relocation, key);
+}
+function markMoves(findings, segments, recheck) {
+  if (findings.length > MOVE_LIMIT)
+    return findings.map((finding) => ({ ...finding, canMove: () => false }));
+  let before;
+  const after = /* @__PURE__ */ new Map();
+  const isClear = (finding) => {
+    const move = finding.outward ? outwardMove(finding, segments) : ruleMove(finding, segments, findings);
+    if (move === void 0) return false;
+    before ??= new Set(findings.map((found) => pairKey(found)));
+    if (!after.has(move.key)) {
+      const found = recheck(move.arranged, move.scope);
+      after.set(move.key, new Set(found.map((pair) => pairKey(pair))));
+    }
+    const pairs2 = after.get(move.key);
+    return !pairs2.has(pairKey(finding)) && [...pairs2].every((key) => before.has(key));
+  };
+  return findings.map((finding) => {
+    let known;
+    return { ...finding, canMove: () => known ??= isClear(finding) };
+  });
+}
+
+// src/directive/order-declaration.ts
+function lastSignificant(tokens, before) {
+  let i = before - 1;
+  while (i >= 0 && (tokens[i].type === "whitespace-token" || tokens[i].type === "comment")) i--;
+  return i;
+}
+function toOrderDeclaration(declaration) {
+  const tokens = tokenize(declaration.value);
+  const last = lastSignificant(tokens, tokens.length);
+  const ident = tokens[last];
+  if (ident?.type !== "ident-token" || String(ident.structured?.value).toLowerCase() !== "important") {
+    return { prop: declaration.prop, value: declaration.value, important: false };
+  }
+  const bang = lastSignificant(tokens, last);
+  if (tokens[bang]?.type !== "delim-token" || tokens[bang].structured?.value !== "!") {
+    return { prop: declaration.prop, value: declaration.value, important: false };
+  }
+  const value = declaration.value.slice(0, tokens[bang].startIndex).trim();
+  return { prop: declaration.prop, value, important: true };
+}
+
+// src/directive/order-marker.ts
+var MARKER_HEAD = "nave-allow-override";
+function parseMarker(body, start, end) {
+  const rest = body.slice(MARKER_HEAD.length + 1);
+  const separator = rest.search(/(?:^|\s)--(?:\s|$)/);
+  const namesText = separator === -1 ? rest : rest.slice(0, separator);
+  const reason = separator === -1 ? void 0 : rest.slice(separator).replace(/^\s*--/, "").trim();
+  return { start, end, names: namesText.split(/\s+/).filter(Boolean), reason };
+}
+function readMarkers(prelude) {
+  const markers = [];
+  const malformed = [];
+  for (const token of tokenize(prelude)) {
+    if (token.type !== "comment" || token.raw.length < 4 || !token.raw.endsWith("*/")) continue;
+    const body = token.raw.slice(2, -2).trim();
+    if (!body.startsWith(MARKER_HEAD)) continue;
+    if (body.startsWith(`${MARKER_HEAD}:`)) {
+      markers.push(parseMarker(body, token.startIndex, token.endIndex));
+    } else {
+      malformed.push({ start: token.startIndex, end: token.endIndex, text: token.raw });
+    }
+  }
+  return { markers, malformed };
+}
+function longhandsCoveredBy(name) {
+  return name.toLowerCase() === "all" ? [] : longhandsOf(name).map((longhand) => standardName(longhand));
+}
+function coveredLonghands(markers, laterProperty) {
+  const covered = /* @__PURE__ */ new Set();
+  const isAll = laterProperty.toLowerCase() === "all";
+  for (const marker of markers) {
+    for (const name of marker.names) {
+      if (isAll && name.toLowerCase() === "all") covered.add("*");
+      for (const longhand of longhandsCoveredBy(name)) covered.add(longhand);
+    }
+  }
+  return covered;
+}
+
+// src/directive/order-print.ts
+var MARKER_HEAD2 = "nave-allow-override";
+var WORD_LIKE = /* @__PURE__ */ new Set([
+  "dimension-token",
+  "function-token",
+  "hash-token",
+  "ident-token",
+  "number-token",
+  "percentage-token",
+  "url-token"
+]);
+var OPENING = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
+var CLOSING = /* @__PURE__ */ new Set([")-token", "]-token", "comma-token", "semicolon-token"]);
+function isSpaced(gap, previous, next) {
+  if (!gap.hasComment) return gap.hasWhitespace;
+  if (CLOSING.has(next.type) || OPENING.has(previous.type)) return false;
+  const isWordBeforeParenthesis = previous.type === "ident-token" && next.type === "(-token";
+  return gap.hasWhitespace || isWordBeforeParenthesis || WORD_LIKE.has(previous.type) && WORD_LIKE.has(next.type);
+}
+function printedValue(value) {
+  let printed = "";
+  let previous;
+  let gap = { hasComment: false, hasWhitespace: false };
+  for (const token of tokenize(value)) {
+    if (token.type === "whitespace-token") {
+      gap = { ...gap, hasWhitespace: true };
+    } else if (token.type === "comment") {
+      gap = { ...gap, hasComment: true };
+    } else {
+      if (previous !== void 0 && isSpaced(gap, previous, token)) printed += " ";
+      printed += token.raw;
+      previous = token;
+      gap = { hasComment: false, hasWhitespace: false };
+    }
+  }
+  return printed;
+}
+function directiveText(prelude) {
+  return `@nave ${prelude.trim()};`;
+}
+function withAtomsInOrder(prelude, atoms2, order) {
+  let result = "";
+  let cursor = 0;
+  for (const [slot, atom] of atoms2.entries()) {
+    result += prelude.slice(cursor, atom.offset) + atoms2[order[slot]].name;
+    cursor = atom.endOffset;
+  }
+  return result + prelude.slice(cursor);
+}
+function reorderedDirective(prelude, atoms2, placement) {
+  const rest = atoms2.map((_atom, index) => index).filter((index) => !placement.moving.includes(index));
+  const at = rest.indexOf(placement.after);
+  const order = [...rest.slice(0, at + 1), ...placement.moving, ...rest.slice(at + 1)];
+  return directiveText(withAtomsInOrder(prelude, atoms2, order));
+}
+function markerComment(names, reason) {
+  const suffix = reason === void 0 ? "" : ` -- ${reason}`;
+  return `/* ${MARKER_HEAD2}: ${names.join(" ")}${suffix} */`;
+}
+function withMarker(prelude, additions, found) {
+  const first = found.markers[0];
+  if (first) {
+    const names = [...first.names, ...additions.filter((name) => !first.names.includes(name))];
+    return prelude.slice(0, first.start) + markerComment(names, first.reason) + prelude.slice(first.end);
+  }
+  const bad = found.malformed[0];
+  if (bad) {
+    return prelude.slice(0, bad.start) + markerComment(additions, void 0) + prelude.slice(bad.end);
+  }
+  return `${markerComment(additions, void 0)} ${prelude.trim()}`;
+}
+function markedDirective(prelude, additions) {
+  return directiveText(withMarker(prelude, additions, readMarkers(prelude)));
+}
+function directiveWithAtomsBefore(prelude, atoms2, placement) {
+  const rest = atoms2.map((_atom, index) => index).filter((index) => !placement.moving.includes(index));
+  const at = rest.indexOf(placement.before);
+  const order = [...rest.slice(0, at), ...placement.moving, ...rest.slice(at)];
+  return directiveText(withAtomsInOrder(prelude, atoms2, order));
+}
+
+// src/directive/order-outward-names.ts
+function nestedText(node) {
+  if (node.kind === "rule") return `the ${printedValue(node.selector)} block`;
+  if (node.kind === "group" || node.kind === "opaque") {
+    return ["the", `@${node.name}`, printedValue(node.prelude), "block"].filter((part) => part !== "").join(" ");
+  }
+  return "";
+}
+var SMALL_ORDINALS = [
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "eighth",
+  "ninth",
+  "tenth"
+];
+function ordinal(place) {
+  if (place <= SMALL_ORDINALS.length) return SMALL_ORDINALS[place - 1];
+  const lastTwo = place % 100;
+  const last = place % 10;
+  if (lastTwo < 11 || lastTwo > 13) {
+    if (last === 1) return `${place}st`;
+    if (last === 2) return `${place}nd`;
+    if (last === 3) return `${place}rd`;
+  }
+  return `${place}th`;
+}
+function bareName(node) {
+  if (node.kind === "rule") return printedValue(node.selector);
+  if (node.kind === "group" || node.kind === "opaque") {
+    return [`@${node.name}`, printedValue(node.prelude)].filter((part) => part !== "@" && part !== "").join(" ");
+  }
+  return void 0;
+}
+function namesOf(nodes) {
+  const names = nodes.map((node) => bareName(node));
+  const places = /* @__PURE__ */ new Map();
+  const names2 = /* @__PURE__ */ new Map();
+  for (const [index, node] of nodes.entries()) {
+    const name = names[index];
+    if (name === void 0) continue;
+    const count = names.filter((other) => other === name).length;
+    const place = (places.get(name) ?? 0) + 1;
+    places.set(name, place);
+    names2.set(node.ref, count > 1 ? `the ${ordinal(place)} ${name} block` : `the ${name} block`);
+  }
+  return names2;
+}
+function foldInto(selector, place) {
+  const tokens = tokenize(selector);
+  let depth = 0;
+  let isList = false;
+  for (const token of tokenize(place)) {
+    if (token.type === "(-token" || token.type === "function-token") depth += 1;
+    else if (token.type === ")-token") depth -= 1;
+    else if (depth === 0 && token.type === "comma-token") isList = true;
+  }
+  const replacement = isList ? `:is(${place})` : place;
+  return tokens.map((token) => token.type === "delim-token" && token.raw === "&" ? replacement : token.raw).join("");
+}
+function placeOf(path, blockSelector) {
+  let place = "&";
+  for (const selector of [...path, blockSelector]) {
+    const printed = printedValue(selector);
+    if (printed !== "&") place = foldInto(printed, place);
+  }
+  return place;
+}
+
+// src/directive/order-units.ts
+var GROUP_NAMES = /* @__PURE__ */ new Set(["container", "media", "supports"]);
+function unitOf(context, selector, conditions, declarations) {
+  return {
+    atom: context.atom,
+    directive: context.directive,
+    selector,
+    conditions,
+    declarations: declarations.map((declaration) => toOrderDeclaration(declaration)),
+    specificities: nestedSpecificities(selector, context.amp)
+  };
+}
+function unitsOfBlock(context, block) {
+  if (block.kind === "pseudo") return [unitOf(context, block.selector, [], block.declarations)];
+  const conditions = [{ name: block.kind, prelude: block.condition }];
+  const units = block.pseudos.map(
+    (pseudo) => unitOf(context, pseudo.selector, conditions, pseudo.declarations)
+  );
+  if (block.declarations.length > 0) {
+    units.unshift(unitOf(context, "&", conditions, block.declarations));
+  }
+  return units;
+}
+function candidatesOfUnit(unit, overrider) {
+  return unit.declarations.map((declaration) => ({
+    declaration,
+    overrider,
+    conditions: unit.conditions,
+    specificities: unit.specificities,
+    holderSelector: unit.selector,
+    siblings: unit.declarations
+  }));
+}
+function candidatesOfAtomDeclarations(context, declarations) {
+  const unit = { ...unitOf(context, "&", [], declarations), specificities: [context.amp] };
+  const overrider = {
+    atom: context.atom,
+    directive: context.directive,
+    kind: "atom",
+    isBlock: false
+  };
+  return candidatesOfUnit(unit, overrider);
+}
+function candidatesOfAtomBlock(context, block) {
+  const overrider = {
+    atom: context.atom,
+    directive: context.directive,
+    kind: "atom",
+    isBlock: true
+  };
+  return unitsOfBlock(context, block).flatMap((unit) => candidatesOfUnit(unit, overrider));
+}
+var NO_CONDITIONS = [];
+function conditionsOf(chain) {
+  if (chain === void 0) return NO_CONDITIONS;
+  if (chain.array === void 0) {
+    const rules = [];
+    for (let link = chain; link; link = link.parent) {
+      rules.push(link.rule);
+    }
+    chain.array = rules.toReversed();
+  }
+  return chain.array;
+}
+function levelOf(nodes, walk, isRule) {
+  const read = isRule ? nodes.flatMap((node) => node.kind === "directive" ? walk.emitted(node).nodes : [node]) : nodes;
+  const siblings = read.flatMap(
+    (node) => node.kind === "decl" ? [{ prop: node.prop, value: node.value, important: node.important }] : []
+  );
+  return { next: 0, nodes: read, siblings, walk };
+}
+function enter(node, level, found) {
+  const { walk } = level;
+  if (node.kind === "decl") {
+    const { prop, value, important } = node;
+    found.push({
+      declaration: { prop, value, important },
+      overrider: walk.overrider,
+      conditions: conditionsOf(walk.chain),
+      specificities: walk.specificities,
+      holderSelector: walk.holderSelector,
+      siblings: level.siblings
+    });
+    return void 0;
+  }
+  if (node.kind === "rule") {
+    const specificities = walk.specificities.flatMap((s) => nestedSpecificities(node.selector, s));
+    if (specificities.length === 0) return void 0;
+    const holderSelector = node.selector.trim() === "&" ? walk.holderSelector : node.selector;
+    return levelOf(node.nodes, { ...walk, specificities, holderSelector }, true);
+  }
+  if (node.kind === "group" && GROUP_NAMES.has(node.name)) {
+    const chain = { rule: { name: node.name, prelude: node.prelude }, parent: walk.chain };
+    return levelOf(node.nodes, { ...walk, chain }, false);
+  }
+  return void 0;
+}
+function walkNodes(nodes, walk, isRule) {
+  const found = [];
+  const stack = [levelOf(nodes, walk, isRule)];
+  while (stack.length > 0) {
+    const level = stack.at(-1);
+    const node = level.nodes[level.next++];
+    if (node === void 0) {
+      stack.pop();
+      continue;
+    }
+    const inner = enter(node, level, found);
+    if (inner !== void 0) stack.push(inner);
+  }
+  return found;
+}
+function ownWalk(node, top, emitted, reach) {
+  return {
+    chain: reach.chain,
+    emitted,
+    holderSelector: "&",
+    overrider: { kind: "own", top, topRef: node.ref },
+    specificities: reach.specificities
+  };
+}
+function candidatesOfOwnNode(node, amp, emitted, reach) {
+  const from = reach ?? { chain: void 0, specificities: [amp] };
+  if (node.kind === "decl") {
+    return walkNodes([node], ownWalk(node, { kind: "declaration" }, emitted, from), false);
+  }
+  if (node.kind === "rule") {
+    const top = { kind: "rule", selector: node.selector };
+    const specificities = from.specificities.flatMap((s) => nestedSpecificities(node.selector, s));
+    if (specificities.length === 0) return [];
+    const walk = {
+      ...ownWalk(node, top, emitted, from),
+      specificities,
+      holderSelector: node.selector
+    };
+    return walkNodes(node.nodes, walk, true);
+  }
+  if (node.kind === "group" && GROUP_NAMES.has(node.name)) {
+    const top = { kind: "group", name: node.name, prelude: node.prelude };
+    const chain = { rule: { name: node.name, prelude: node.prelude }, parent: from.chain };
+    return walkNodes(node.nodes, { ...ownWalk(node, top, emitted, from), chain }, false);
+  }
+  return [];
+}
+
+// src/directive/order-outward-search.ts
+function enter2(node, level) {
+  if (node.kind === "rule") {
+    const specificities = level.specificities.flatMap((s) => nestedSpecificities(node.selector, s));
+    if (specificities.length === 0) return void 0;
+    const path = [...level.path, node.selector];
+    return {
+      ...level,
+      next: 0,
+      isGroupOnly: false,
+      isRule: true,
+      nodes: node.nodes,
+      path,
+      ref: node.ref,
+      specificities
+    };
+  }
+  if (node.kind === "group" && GROUP_NAMES.has(node.name)) {
+    const chain = { rule: { name: node.name, prelude: node.prelude }, parent: level.chain };
+    return { ...level, next: 0, chain, isRule: false, nodes: node.nodes, ref: node.ref };
+  }
+  return void 0;
+}
+function groupFacts(stack) {
+  return stack.flatMap((level) => {
+    const container = level.nodes[level.next - 1];
+    if (container === void 0 || level.isRule || !level.isGroupOnly) return [];
+    return [
+      {
+        above: namesOf(level.nodes).get(container.ref) ?? "",
+        chain: level.chain,
+        container: container.ref,
+        group: level.ref,
+        later: level.nodes.slice(level.next),
+        names: namesOf(level.nodes),
+        specificities: level.specificities
+      }
+    ];
+  });
+}
+function directivesBelow(top, amp) {
+  const start = {
+    next: 0,
+    chain: void 0,
+    isGroupOnly: true,
+    isRule: true,
+    nodes: [],
+    path: [],
+    ref: top.ref,
+    specificities: [amp]
+  };
+  const first = enter2(top, start);
+  if (first === void 0) return [];
+  const found = [];
+  const stack = [first];
+  while (stack.length > 0) {
+    const level = stack.at(-1);
+    const node = level.nodes[level.next++];
+    if (node === void 0) {
+      stack.pop();
+    } else if (node.kind === "directive") {
+      if (level.isRule) {
+        found.push({
+          chain: level.chain,
+          directive: node,
+          groups: groupFacts(stack),
+          path: level.path,
+          specificities: level.specificities
+        });
+      }
+    } else {
+      const inner = enter2(node, level);
+      if (inner !== void 0) stack.push(inner);
+    }
+  }
+  return found;
+}
+
+// src/directive/order-where.ts
+var IMPLIED_STATES = /* @__PURE__ */ new Map([
+  [":focus", [":focus-within"]],
+  [":focus-visible", [":focus", ":focus-within"]]
+]);
+var OPENING2 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
+var CLOSING2 = /* @__PURE__ */ new Set([")-token", "]-token"]);
+function isCodeChar(scan, text, i) {
+  const char = text[i];
+  if (scan.quote) {
+    if (char === scan.quote && text[i - 1] !== "\\") scan.quote = void 0;
+    return false;
+  }
+  if (char === '"' || char === "'") {
+    scan.quote = char;
+    return false;
+  }
+  if ("([".includes(char)) scan.depth++;
+  else if (")]".includes(char)) scan.depth--;
+  return true;
+}
+function isPartStart(text, i) {
+  return ".#[:".includes(text[i]) && text[i - 1] !== ":";
+}
+function compoundParts(selector) {
+  const text = selector.trim();
+  if (!text.startsWith("&")) return void 0;
+  const parts = [];
+  const scan = { depth: 0, quote: void 0 };
+  for (let i = 1; i < text.length; i++) {
+    const isTopLevel = scan.depth === 0 && scan.quote === void 0;
+    const isCode = isCodeChar(scan, text, i);
+    const isSeparator = isTopLevel && isCode && /[\s,>+~&]/.test(text[i]);
+    if (isSeparator || !isCharAppended(parts, text, i, isTopLevel && isCode)) return void 0;
+  }
+  return parts;
+}
+function isCharAppended(parts, text, i, isCodeAtTop) {
+  if (isCodeAtTop && isPartStart(text, i)) parts.push("");
+  const current = parts.pop();
+  if (current === void 0) return false;
+  parts.push(current + text[i]);
+  return true;
+}
+function isOr(token) {
+  return token.type === "ident-token" && String(token.structured?.value).toLowerCase() === "or";
+}
+function isListOrDisjunction(prelude) {
+  let depth = 0;
+  for (const token of tokenize(prelude)) {
+    if (OPENING2.has(token.type)) depth += 1;
+    else if (CLOSING2.has(token.type)) depth -= 1;
+    else if (depth === 0 && (token.type === "comma-token" || isOr(token))) return true;
+  }
+  return false;
+}
+function conditionText(condition) {
+  const text = `@${condition.name} ${printedValue(condition.prelude)}`;
+  return isListOrDisjunction(condition.prelude) ? `(${text})` : text;
+}
+function isTightAfter(token) {
+  return token.type === ")-token" || token.type === "colon-token" || token.type === "comma-token" || token.type === "delim-token" && "<>=".includes(token.raw);
+}
+function isTightBefore(token) {
+  return token.type === "(-token" || token.type === "function-token" || token.type === "colon-token" || token.type === "comma-token" || token.type === "delim-token" && "<>=".includes(token.raw);
+}
+function conditionKey(condition) {
+  let key = `${condition.name} `;
+  let previous;
+  let hasGap = false;
+  for (const token of tokenize(condition.prelude)) {
+    if (token.type === "whitespace-token" || token.type === "comment") {
+      hasGap = true;
+      continue;
+    }
+    const isSpaced2 = previous !== void 0 && hasGap && !isTightBefore(previous) && !isTightAfter(token);
+    key += isSpaced2 ? ` ${token.raw}` : token.raw;
+    previous = token;
+    hasGap = false;
+  }
+  return key;
+}
+function phrase(onText, conditions) {
+  const on = onText === void 0 || onText === "" ? [] : [`on ${onText}`];
+  const under = conditions.length === 0 ? [] : [`under ${conditions.map((c) => conditionText(c)).join(" and ")}`];
+  return [...on, ...under].join(" ");
+}
+function statesOf(selector) {
+  return compoundParts(selector) ?? [];
+}
+function whereOf(selector, conditions) {
+  const printed = printedValue(selector);
+  const parts = compoundParts(printed);
+  return phrase(parts === void 0 ? printed : parts.join(""), conditions);
+}
+function isSaid(part, said) {
+  const lower = part.toLowerCase();
+  return said.some(
+    (s) => s.toLowerCase() === lower || (IMPLIED_STATES.get(s.toLowerCase()) ?? []).includes(lower)
+  );
+}
+function alsoWhere(first, later) {
+  const firstParts = first.said ?? compoundParts(printedValue(first.selector)) ?? [];
+  const laterSelector = printedValue(later.selector);
+  const laterParts = compoundParts(laterSelector);
+  const seen = new Set(first.conditions.map((c) => conditionKey(c)));
+  const conditions = later.conditions.filter((c) => !seen.has(conditionKey(c)));
+  if (laterParts === void 0) return phrase(laterSelector, conditions);
+  return phrase(laterParts.filter((part) => !isSaid(part, firstParts)).join(""), conditions);
+}
+
+// src/directive/rule-emit.ts
+function directiveFacts(node, result) {
+  return {
+    ref: node.ref,
+    prelude: node.prelude,
+    atoms: result.atoms.map((atom, atomIndex) => ({
+      atomIndex,
+      name: atom.name,
+      offset: atom.offset,
+      endOffset: atom.endOffset
+    }))
+  };
+}
+function recordDropped(state, directive, atoms2) {
+  const named = atoms2.flatMap(
+    (planned, index) => planned.blocks.length === 0 ? [] : [
+      {
+        atom: directive.atoms[index],
+        declarations: planned.declarations,
+        wheres: planned.blocks.map((block) => blockWhere(block))
+      }
+    ]
+  );
+  if (named.length > 0) state.dropped.push({ directive, atoms: named });
+}
+function recordSegments(state, directive, atoms2) {
+  if (state.isPseudoElementRule) recordDropped(state, directive, atoms2);
+  for (const [atomIndex, planned] of atoms2.entries()) {
+    const atom = directive.atoms[atomIndex];
+    if (planned.declarations.length > 0) {
+      state.segments.push({
+        kind: "atom-declarations",
+        directive,
+        atom,
+        declarations: planned.declarations
+      });
+    }
+    if (state.isPseudoElementRule) continue;
+    for (const block of planned.blocks) {
+      state.segments.push({ kind: "atom-block", directive, atom, block });
+    }
+  }
+}
+function blockWhere(block) {
+  if (block.kind === "pseudo") return whereOf(block.selector, []);
+  return whereOf("&", [{ name: block.kind, prelude: block.condition }]);
+}
+function firstAtomWithBlock(walk) {
+  const index = walk.atoms.findIndex((atom) => atom.blocks.length > 0);
+  return index === -1 ? void 0 : walk.directive.atoms[index];
+}
+function recordRun(state, walk) {
+  const { directive, follows, pending } = walk;
+  const nested = state.lastNested ?? { text: "" };
+  const hasBlockOfOwn = pending.atoms.some((atom) => walk.atoms[atom.atomIndex].blocks.length > 0);
+  state.runs.push({
+    kind: "directive",
+    above: state.above ?? "",
+    atoms: [...pending.atoms],
+    canMoveDirective: !state.ownDeclarationSinceAbove,
+    canReorder: follows !== void 0 && !walk.isNestedBefore && firstAtomWithBlock(walk)?.atomIndex === follows.atom.atomIndex && !hasBlockOfOwn,
+    directive,
+    follows,
+    isWrappedBefore: state.hasOwnNested,
+    nested
+  });
+}
+function flushDeclarations(state, walk) {
+  const { declarations } = walk.pending;
+  if (declarations.length === 0) return;
+  const isWrapped = state.isNested && !state.isPseudoElementRule;
+  walk.emissions.push({ kind: "declarations", declarations: [...declarations], isWrapped });
+  if (isWrapped) recordRun(state, walk);
+  walk.pending.declarations = [];
+  walk.pending.atoms = [];
+}
+function noteAbove(state, walk) {
+  if (state.above !== void 0) return;
+  const first = firstAtomWithBlock(walk);
+  state.above = state.directiveTotal === 1 ? "the directive" : `the directive that names "${first.name}"`;
+}
+function emitAtom(state, walk, index) {
+  const planned = walk.atoms[index];
+  const atom = walk.directive.atoms[index];
+  if (planned.declarations.length > 0) {
+    walk.pending.declarations.push(...planned.declarations);
+    walk.pending.atoms.push(atom);
+  }
+  if (planned.blocks.length === 0 || state.isPseudoElementRule) return;
+  flushDeclarations(state, walk);
+  for (const block of planned.blocks) walk.emissions.push({ kind: "block", block });
+  noteAbove(state, walk);
+  const last = planned.blocks.at(-1);
+  walk.follows = { atom, where: blockWhere(last) };
+  state.lastNested = {
+    text: `the block of "${atom.name}" ${blockWhere(last)}`,
+    block: { atom, directive: walk.directive }
+  };
+  state.isNested = true;
+}
+function emitAtoms(state, directive, atoms2) {
+  const walk = {
+    atoms: atoms2,
+    directive,
+    emissions: [],
+    pending: { atoms: [], declarations: [] },
+    isNestedBefore: state.isNested,
+    follows: void 0
+  };
+  for (const index of atoms2.keys()) emitAtom(state, walk, index);
+  flushDeclarations(state, walk);
+  return walk.emissions;
+}
+
+// src/directive/order-outward.ts
+function isSameCondition(a, b) {
+  return conditionKey(a) === conditionKey(b);
+}
+function unitsOfBlock2(found, context, block) {
+  const make = (selector, conditions2, declarations) => ({
+    ...context,
+    selector,
+    placeSelector: placeOf(found.path, selector),
+    placeStates: [...found.path, selector].flatMap((part) => statesOf(printedValue(part))),
+    conditions: conditions2,
+    declarations: declarations.map((declaration) => toOrderDeclaration(declaration)),
+    specificities: found.specificities.flatMap((s) => nestedSpecificities(selector, s))
+  });
+  const path = conditionsOf(found.chain);
+  if (block.kind === "pseudo") return [make(block.selector, path, block.declarations)];
+  const own = { name: block.kind, prelude: block.condition };
+  const conditions = path.some((condition) => isSameCondition(condition, own)) ? path : [own, ...path];
+  const units = block.pseudos.map(
+    (pseudo) => make(pseudo.selector, conditions, pseudo.declarations)
+  );
+  if (block.declarations.length > 0) units.unshift(make("&", conditions, block.declarations));
+  return units;
+}
+function outwardOf(finding, how) {
+  const { overrider } = finding.candidate;
+  const name = overrider.kind === "own" ? how.names.get(overrider.topRef) : void 0;
+  const { above, level, top } = how;
+  return { ...finding, outward: { above, overrider: name, top, ...level && { level } } };
+}
+function pairs(units, candidates, how) {
+  return units.flatMap(
+    (unit) => candidates.flatMap((candidate) => {
+      const finding = compare(unit, candidate);
+      return finding === void 0 ? [] : [outwardOf(finding, how)];
+    })
+  );
+}
+function groupCandidates(group, enclosing) {
+  const reach = { chain: group.chain, specificities: group.specificities };
+  const { levels } = enclosing;
+  const nodes = typeof levels === "object" && group.container !== levels.child ? group.later.filter((node) => node.ref === levels.child) : group.later;
+  return nodes.flatMap((node) => candidatesOfOwnNode(node, enclosing.amp, enclosing.emitted, reach));
+}
+function findingsBelow(enclosing) {
+  const { amp, emitted, top } = enclosing;
+  const above = enclosing.names.get(top.ref) ?? nestedText(top);
+  return directivesBelow(top, amp).flatMap((found) => {
+    const { atoms: atoms2 } = emitted(found.directive);
+    const facts = directiveFacts(found.directive, { atoms: atoms2});
+    const own = {
+      candidates: enclosing.later,
+      how: { above, names: enclosing.names, top: top.ref }
+    };
+    const groupLevels = enclosing.levels === "enclosing" ? [] : found.groups;
+    const levels = [
+      ...typeof enclosing.levels === "object" ? [] : [own],
+      ...groupLevels.map((group) => ({
+        candidates: groupCandidates(group, enclosing),
+        how: {
+          above: group.above,
+          level: { container: group.container, group: group.group },
+          names: group.names,
+          top: top.ref
+        }
+      }))
+    ];
+    return atoms2.flatMap(
+      (atom, index) => atom.blocks.flatMap(
+        (block) => unitsOfBlock2(found, { atom: facts.atoms[index], directive: facts }, block)
+      ).flatMap((unit) => levels.flatMap((level) => pairs([unit], level.candidates, level.how)))
+    );
+  });
+}
+function readOf(segment, scope) {
+  if (scope === void 0) return { levels: "all" };
+  if (scope.kind === "child") {
+    return segment === scope.top ? { levels: { child: scope.child } } : void 0;
+  }
+  return scope.segments.has(segment) ? { levels: "all" } : { levels: "enclosing", only: scope.segments };
+}
+function outwardFindings(segments, rule, candidatesOfSegment) {
+  const { amp, emitted, scope } = rule;
+  const names = namesOf(
+    segments.flatMap((segment) => segment.kind === "own" ? [segment.node] : [])
+  );
+  return segments.flatMap((segment, index) => {
+    if (segment.kind !== "own") return [];
+    const top = segment.node;
+    if (top.kind !== "rule" && top.kind !== "group") return [];
+    const read = readOf(segment, scope);
+    if (read === void 0) return [];
+    const isCounted = (other) => read.only === void 0 || read.only.has(other);
+    const later = typeof read.levels === "object" ? [] : segments.flatMap(
+      (other, at) => at > index && isCounted(other) ? candidatesOfSegment(at) : []
+    );
+    if (later.length === 0 && (top.kind === "rule" || read.levels === "enclosing")) return [];
+    return findingsBelow({ amp, emitted, later, levels: read.levels, names, top });
+  });
+}
+
+// src/directive/order-check.ts
+function contextOf(segment, amp) {
+  return { amp, atom: segment.atom, directive: segment.directive };
+}
+function candidatesOf(segment, amp, emitted) {
+  if (segment.kind === "own") return candidatesOfOwnNode(segment.node, amp, emitted);
+  const context = contextOf(segment, amp);
+  if (segment.kind === "atom-declarations") {
+    return candidatesOfAtomDeclarations(context, segment.declarations);
+  }
+  return candidatesOfAtomBlock(context, segment.block);
+}
+function isSameAtom(a, b) {
+  return a.kind !== "own" && b.kind !== "own" && a.directive.ref === b.directive.ref && a.atom.atomIndex === b.atom.atomIndex;
+}
+function findingsOfBlock(index, segments, rule, candidatesOfSegment) {
+  const { amp, moved } = rule;
+  const segment = segments[index];
+  const isRead = (other) => moved === void 0 || moved.has(segment) || moved.has(other);
+  const candidates = segments.flatMap(
+    (other, at) => at > index && !isSameAtom(segment, other) && isRead(other) ? candidatesOfSegment(at) : []
+  );
+  if (candidates.length === 0) return [];
+  const units = unitsOfBlock(contextOf(segment, amp), segment.block);
+  return candidates.flatMap(
+    (candidate) => units.map((unit) => compare(unit, candidate)).filter((f) => f !== void 0)
+  );
+}
+function pairsIn(segments, rule, candidatesOfPart) {
+  const { amp, emitted, isPseudoElementRule, scope } = rule;
+  const candidatesOfSegment = (index) => candidatesOfPart(segments[index]);
+  const moved = scope?.kind === "moved" ? scope.segments : void 0;
+  const inner = scope?.kind === "child" ? [] : segments.flatMap(
+    (segment, index) => segment.kind === "atom-block" ? findingsOfBlock(index, segments, { amp, moved }, candidatesOfSegment) : []
+  );
+  if (isPseudoElementRule) return inner;
+  return [...inner, ...outwardFindings(segments, { amp, emitted, scope }, candidatesOfSegment)];
+}
+function canHoldPair(segments) {
+  return segments.some(
+    (segment) => segment.kind === "atom-block" || segment.kind === "own" && (segment.node.kind === "rule" || segment.node.kind === "group")
+  );
+}
+function checkOrder(segments, amp, emitted, isPseudoElementRule = false) {
+  const rule = { amp, emitted, isPseudoElementRule };
+  const known = /* @__PURE__ */ new WeakMap();
+  const candidatesOfPart = (segment) => {
+    let candidates = known.get(segment);
+    if (candidates === void 0) {
+      candidates = candidatesOf(segment, amp, emitted);
+      known.set(segment, candidates);
+    }
+    return candidates;
+  };
+  const findings = pairsIn(segments, rule, candidatesOfPart);
+  return markMoves(
+    findings,
+    segments,
+    (arranged, scope) => pairsIn(arranged, { ...rule, scope }, candidatesOfPart)
+  );
+}
+
+// src/selector-utils.ts
+function isCommentClose(text, index, commentStart) {
+  return text[index] === "/" && text[index - 1] === "*" && index - 1 >= commentStart + 2;
+}
+function isConsumedAsLiteral(state, text, index) {
+  if (state.commentStart !== void 0) {
+    if (isCommentClose(text, index, state.commentStart)) state.commentStart = void 0;
+    return true;
+  }
+  if (state.isEscaped) {
+    state.isEscaped = false;
+    return true;
+  }
+  if (text[index] === "\\") {
+    state.isEscaped = true;
+    return true;
+  }
+  if (!state.quote) return false;
+  if (text[index] === state.quote) state.quote = void 0;
+  return true;
+}
+function isCodeChar2(state, text, index) {
+  if (isConsumedAsLiteral(state, text, index)) return false;
+  const char = text[index];
+  if (char === '"' || char === "'") {
+    state.quote = char;
+    return false;
+  }
+  if (char === "/" && text[index + 1] === "*") {
+    state.commentStart = index;
+    return false;
+  }
+  return true;
+}
+function codeMask(text) {
+  const state = { quote: void 0, isEscaped: false, commentStart: void 0 };
+  return Array.from({ length: text.length }, (_, index) => isCodeChar2(state, text, index));
+}
+function splitTopLevel(selectorList) {
+  const mask = codeMask(selectorList);
+  const branches = [];
+  let depth = 0;
+  let start = 0;
+  for (const [index, isCode] of mask.entries()) {
+    if (!isCode) continue;
+    const char = selectorList[index];
+    if (char === "(" || char === "[") depth += 1;
+    else if (char === ")" || char === "]") depth -= 1;
+    else if (char === "," && depth === 0) {
+      branches.push(selectorList.slice(start, index));
+      start = index + 1;
+    }
+  }
+  return [...branches, selectorList.slice(start)];
+}
+function hasNestingSelector(branch) {
+  return codeMask(branch).some((isCode, index) => isCode && branch[index] === "&");
+}
+function anchorSelectorList(selectorList) {
+  return splitTopLevel(selectorList).map((branch) => {
+    const trimmed = branch.trim();
+    if (trimmed === "") {
+      throw new Error(
+        `anchorSelectorList: empty selector branch in pseudo key "${selectorList}". Remove the stray or trailing comma: an empty branch would otherwise compile to a bare "&", matching the atom unconditionally.`
+      );
+    }
+    return hasNestingSelector(trimmed) ? trimmed : `&${trimmed}`;
+  }).join(", ");
+}
+
+// src/directive/prelude-components.ts
+var OPENERS3 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS2 = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function findGroupEnd(tokens, start) {
+  let depth = 1;
+  let i = start + 1;
+  while (i < tokens.length && depth > 0) {
+    if (OPENERS3.has(tokens[i].type)) depth++;
+    else if (CLOSERS2.has(tokens[i].type)) depth--;
+    i++;
+  }
+  return i;
+}
+function readGroup(tokens, start, prelude) {
+  const end = findGroupEnd(tokens, start);
+  const last = tokens[end - 1] ?? tokens[start];
+  return {
+    kind: "bad-token",
+    text: prelude.slice(tokens[start].startIndex, last.endIndex),
+    offset: tokens[start].startIndex,
+    endOffset: last.endIndex
+  };
+}
+function isBangIdent(tokens, i) {
+  const t = tokens[i];
+  return t.type === "delim-token" && t.structured?.value === "!" && tokens[i + 1]?.type === "ident-token";
+}
+function readBangIdent(tokens, i) {
+  const bang = tokens[i];
+  const ident = tokens[i + 1];
+  return {
+    kind: "bad-token",
+    text: bang.raw + ident.raw,
+    offset: bang.startIndex,
+    endOffset: ident.endIndex
+  };
+}
+function readSingleToken(t) {
+  if (t.type === "ident-token") {
+    return {
+      kind: "ident",
+      name: t.structured?.value,
+      offset: t.startIndex,
+      endOffset: t.endIndex
+    };
+  }
+  return { kind: "bad-token", text: t.raw, offset: t.startIndex, endOffset: t.endIndex };
+}
+function readPreludeComponents(prelude) {
+  const tokens = tokenize(prelude).filter(
+    (t) => t.type !== "whitespace-token" && t.type !== "comment"
+  );
+  const components = [];
+  let i = 0;
+  while (i < tokens.length) {
+    if (OPENERS3.has(tokens[i].type)) {
+      components.push(readGroup(tokens, i, prelude));
+      i = findGroupEnd(tokens, i);
+      continue;
+    }
+    if (isBangIdent(tokens, i)) {
+      components.push(readBangIdent(tokens, i));
+      i += 2;
+      continue;
+    }
+    components.push(readSingleToken(tokens[i]));
+    i++;
+  }
+  return components;
+}
+
+// src/directive/plain-object.ts
+var BOXES = [
+  ["String", String.prototype],
+  ["Number", Number.prototype],
+  ["Boolean", Boolean.prototype],
+  ["BigInt", BigInt.prototype],
+  ["Symbol", Symbol.prototype]
+];
+var utilTypes = globalThis.process?.getBuiltinModule?.("node:util")?.types;
+function brandByTypes(types, value) {
+  if (types.isStringObject(value)) return "String";
+  if (types.isNumberObject(value)) return "Number";
+  if (types.isBooleanObject(value)) return "Boolean";
+  if (types.isBigIntObject(value)) return "BigInt";
+  return types.isSymbolObject(value) ? "Symbol" : void 0;
+}
+function brandByValueOf(value) {
+  for (const [name, prototype] of BOXES) {
+    try {
+      prototype.valueOf.call(value);
+      return name;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function brandOf(value) {
+  return utilTypes === void 0 ? brandByValueOf(value) : brandByTypes(utilTypes, value);
+}
+function boxedPrimitiveKind(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const brand = brandOf(value);
+  if (brand !== void 0) return brand;
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    return BOXES.find(([, box]) => box === prototype)?.[0];
+  } catch {
+    return void 0;
+  }
+}
+function unboxedPrimitive(value) {
+  for (const [, prototype] of BOXES) {
+    try {
+      return prototype.valueOf.call(value);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && boxedPrimitiveKind(value) === void 0;
+}
+
+// src/directive/resolve.ts
+function toDeclarations(decls) {
+  return Object.entries(decls).map(([prop, value]) => ({ prop, value }));
+}
+function isDeclarationsObject(value) {
+  return isPlainObject(value);
+}
+function resolveDeclarations(name, atom) {
+  if (!isDeclarationsObject(atom.declarations)) {
+    throw new Error(`@nave: atom "${name}" is registered without a declarations object`);
+  }
+  return toDeclarations(atom.declarations);
+}
+function resolvePseudoBlocks(pseudos) {
+  if (!pseudos) return [];
+  return Object.entries(pseudos).filter(([, decls]) => decls).map(([selector, decls]) => ({
+    kind: "pseudo",
+    selector,
+    declarations: toDeclarations(decls)
+  }));
+}
+function resolveConditionalBlocks(kind, blocks) {
+  if (!blocks) return [];
+  const result = [];
+  for (const [condition, block] of Object.entries(blocks)) {
+    if (!block) continue;
+    const declarations = block.declarations ? toDeclarations(block.declarations) : [];
+    const pseudos = resolvePseudoBlocks(block.pseudos);
+    if (declarations.length === 0 && pseudos.length === 0) continue;
+    result.push({ kind, condition, declarations, pseudos });
+  }
+  return result;
+}
+function resolveAtom(name, atom) {
+  return {
+    declarations: resolveDeclarations(name, atom),
+    blocks: [
+      ...resolvePseudoBlocks(atom.pseudos),
+      ...resolveConditionalBlocks("media", atom.media),
+      ...resolveConditionalBlocks("container", atom.container)
+    ]
+  };
+}
+function lookupAtom(name, extend) {
+  if (Object.hasOwn(extend, name)) return extend[name] ?? void 0;
+  if (Object.hasOwn(atoms, name)) return atoms[name];
+  return void 0;
+}
+function resolve(names, options = {}) {
+  const extend = options.extend ?? {};
+  const resolved = /* @__PURE__ */ Object.create(null);
+  const unresolved = [];
+  for (const name of names) {
+    const atom = lookupAtom(name, extend);
+    if (!atom) {
+      unresolved.push(name);
+      continue;
+    }
+    resolved[name] = resolveAtom(name, atom);
+  }
+  return { resolved, unresolved };
+}
+
+// src/directive/plan.ts
+function anchorBlock(block) {
+  if (block.kind === "pseudo") {
+    return {
+      kind: "pseudo",
+      selector: anchorSelectorList(block.selector),
+      declarations: block.declarations
+    };
+  }
+  return {
+    kind: block.kind,
+    condition: block.condition,
+    declarations: block.declarations,
+    pseudos: block.pseudos.map((p) => ({ ...p, selector: anchorSelectorList(p.selector) }))
+  };
+}
+function emptyResult(diagnostics) {
+  return { atoms: [], diagnostics };
+}
+function readNames(components) {
+  const idents = [];
+  const diagnostics = [];
+  for (const component of components) {
+    if (component.kind === "ident") {
+      idents.push(component);
+      continue;
+    }
+    diagnostics.push({
+      code: "bad-token",
+      text: component.text,
+      offset: component.offset,
+      endOffset: component.endOffset
+    });
+  }
+  return { idents, diagnostics };
+}
+function readUnknownAtomDiagnostics(components, resolved) {
+  const diagnostics = [];
+  for (const component of components) {
+    if (component.kind !== "ident" || Object.hasOwn(resolved, component.name)) continue;
+    diagnostics.push({
+      code: "unknown-atom",
+      name: component.name,
+      offset: component.offset,
+      endOffset: component.endOffset
+    });
+  }
+  return diagnostics;
+}
+function toPlannedAtoms(idents, resolved) {
+  const planned = [];
+  for (const ident of idents) {
+    const atom = Object.hasOwn(resolved, ident.name) ? resolved[ident.name] : void 0;
+    if (!atom) continue;
+    planned.push({
+      name: ident.name,
+      offset: ident.offset,
+      endOffset: ident.endOffset,
+      declarations: atom.declarations,
+      blocks: atom.blocks.map((block) => anchorBlock(block))
+    });
+  }
+  return planned;
+}
+function planNames(prelude, options) {
+  const components = readPreludeComponents(prelude);
+  if (components.length === 0) {
+    return emptyResult([{ code: "no-atom", offset: 0, endOffset: prelude.length }]);
+  }
+  const { idents, diagnostics } = readNames(components);
+  const { resolved } = resolve(
+    idents.map((ident) => ident.name),
+    { extend: options.extend }
+  );
+  diagnostics.push(...readUnknownAtomDiagnostics(components, resolved));
+  diagnostics.sort((a, b) => a.offset - b.offset);
+  return { atoms: toPlannedAtoms(idents, resolved), diagnostics };
+}
+function plan(prelude, context, options = {}) {
+  if (!context.isStyleRuleParent) {
+    return emptyResult([{ code: "bad-parent", offset: 0, endOffset: prelude.length }]);
+  }
+  if (context.isInsideKeyframes) {
+    return emptyResult([{ code: "in-keyframes", offset: 0, endOffset: prelude.length }]);
+  }
+  return planNames(prelude, options);
+}
+
+// src/directive/order-emitted.ts
+function declarationNode(ref, declaration) {
+  const { prop, value, important } = toOrderDeclaration(declaration);
+  return { kind: "decl", ref, prop, value, important };
+}
+function blockNode(ref, block) {
+  const rule = (selector, declarations) => ({
+    kind: "rule",
+    ref,
+    selector,
+    nodes: declarations.map((declaration) => declarationNode(ref, declaration))
+  });
+  if (block.kind === "pseudo") return rule(block.selector, block.declarations);
+  return {
+    kind: "group",
+    ref,
+    name: block.kind,
+    prelude: block.condition,
+    nodes: [
+      ...block.declarations.map((declaration) => declarationNode(ref, declaration)),
+      ...block.pseudos.map((pseudo) => rule(pseudo.selector, pseudo.declarations))
+    ]
+  };
+}
+function plannedDirective(directive, context, cache) {
+  if (cache === void 0) return planNow(directive, context);
+  const key = `${context.isInsideKeyframes ? "k" : "r"}${directive.prelude}`;
+  let planned = cache.get(key);
+  if (planned === void 0) {
+    planned = planNow(directive, context);
+    cache.set(key, planned);
+  }
+  return planned;
+}
+function planNow(directive, context) {
+  try {
+    const { atoms: atoms2 } = plan(
+      directive.prelude,
+      { isStyleRuleParent: true, isInsideKeyframes: context.isInsideKeyframes },
+      { extend: context.extend }
+    );
+    const nodes = atoms2.flatMap((atom) => [
+      ...atom.declarations.map((declaration) => declarationNode(directive.ref, declaration)),
+      ...atom.blocks.map((block) => blockNode(directive.ref, block))
+    ]);
+    return { atoms: atoms2, nodes };
+  } catch {
+    return { atoms: [], nodes: [] };
+  }
+}
+
+// src/directive/marker-names.ts
+var SHORTHANDS = Object.entries(
+  PROPERTY_LONGHANDS
+).filter(([name, longhands]) => longhands.length > 1 && name !== "all").toSorted((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]));
+function wholeShorthands(set) {
+  const picked = /* @__PURE__ */ new Map();
+  const covered = /* @__PURE__ */ new Set();
+  for (const [name, longhands] of SHORTHANDS) {
+    if (longhands.some((longhand) => !set.has(longhand))) continue;
+    if (longhands.every((longhand) => covered.has(longhand))) continue;
+    picked.set(name, longhands);
+    for (const longhand of longhands) covered.add(longhand);
+  }
+  return picked;
+}
+function namesForLonghands(longhands) {
+  const shorthands = wholeShorthands(new Set(longhands));
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const longhand of longhands) {
+    const owner = [...shorthands].find(([, members]) => members.includes(longhand));
+    const name = owner ? owner[0] : longhand;
+    if (!seen.has(name)) names.push(name);
+    seen.add(name);
+  }
+  return names;
+}
+
+// src/directive/order-overridden.ts
+function overriddenByPair(pair) {
+  const block = longhandsOf(pair.block.prop);
+  const later = new Set(longhandsOf(pair.later.prop).map((longhand) => standardName(longhand)));
+  const shared = block.filter((longhand) => later.has(standardName(longhand)));
+  return shared.length > 0 ? shared : block;
+}
+function overriddenLonghands(pairs2) {
+  const all = pairs2.flatMap((pair) => overriddenByPair(pair));
+  return [...new Set(all)];
+}
+
+// src/directive/migration.ts
+var MIGRATION_VERSION = "0.5.0";
+function overriderSentence(atom) {
+  return `Before @navecss/core ${MIGRATION_VERSION} "${atom}" won, because an atom's blocks were placed last in the rule.`;
+}
+function wrappedSpecificitySentence() {
+  return `Before @navecss/core ${MIGRATION_VERSION} they were left outside \`& { }\`, so they matched with each selector's own specificity.`;
+}
+function wrappedPseudoElementSentence() {
+  return `Before @navecss/core ${MIGRATION_VERSION} they did, because they were left outside \`& { }\`.`;
+}
+
+// src/directive/order-focus.ts
+var RING_CLAUSE = 'This hides the keyboard focus indicator that "focusRing" draws.';
+var REVEAL_CLAUSE = 'This hides again what "srOnlyFocusable" reveals on focus, such as a skip link.';
+var OUTLINE_PROPERTIES = /* @__PURE__ */ new Set([
+  "all",
+  "outline",
+  "outline-color",
+  "outline-style",
+  "outline-width"
+]);
+var STYLE_KEYWORDS = /* @__PURE__ */ new Set([
+  "auto",
+  "dashed",
+  "dotted",
+  "double",
+  "groove",
+  "inset",
+  "outset",
+  "ridge",
+  "solid"
+]);
+var UNJUDGED_FUNCTIONS = /* @__PURE__ */ new Set(["attr", "env", "var"]);
+var STYLE_RESETTING = /* @__PURE__ */ new Set(["all", "outline", "outline-style"]);
+var DECIDED_ELSEWHERE = /* @__PURE__ */ new Set(["inherit", "revert", "revert-layer"]);
+function significantTokens(value) {
+  return tokenize(value).filter((t) => t.type !== "whitespace-token" && t.type !== "comment");
+}
+function compact(value) {
+  return significantTokens(value).map((token) => token.raw).join("").toLowerCase();
+}
+function identOf(token) {
+  return token?.type === "ident-token" ? String(token.structured?.value).toLowerCase() : void 0;
+}
+function isZero(token) {
+  return (token.type === "number-token" || token.type === "dimension-token") && token.structured.value === 0;
+}
+var BLOCK_OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var BLOCK_CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function topLevelTokens(tokens) {
+  let depth = 0;
+  const kept = [];
+  for (const token of tokens) {
+    if (BLOCK_OPENERS.has(token.type)) depth += 1;
+    else if (BLOCK_CLOSERS.has(token.type)) depth = Math.max(0, depth - 1);
+    else if (depth === 0) kept.push(token);
+  }
+  return kept;
+}
+function isOutlineShorthandHiding(tokens) {
+  const top = topLevelTokens(tokens);
+  const idents = top.map((token) => identOf(token));
+  if (idents.every((ident) => ident === void 0 || !STYLE_KEYWORDS.has(ident))) return true;
+  return top.some((token) => isZero(token)) || idents.includes("transparent");
+}
+function isAutoStyle(declaration) {
+  const property = declaration.prop.toLowerCase();
+  const tokens = significantTokens(declaration.value);
+  if (property === "outline-style") return identOf(tokens[0]) === "auto";
+  if (property !== "outline") return false;
+  return topLevelTokens(tokens).some((token) => identOf(token) === "auto");
+}
+function keywordHides(property, keyword) {
+  if (keyword === "initial" || keyword === "unset") return STYLE_RESETTING.has(property);
+  if (DECIDED_ELSEWHERE.has(keyword)) return false;
+  return void 0;
+}
+function isRingHiddenByValue(property, tokens) {
+  if (property === "outline") return isOutlineShorthandHiding(tokens);
+  if (property === "outline-style") return identOf(tokens[0]) === "none";
+  if (property === "outline-width") return tokens.length === 1 && isZero(tokens[0]);
+  if (property === "outline-color") return identOf(tokens[0]) === "transparent";
+  return false;
+}
+function isRingHidden(declaration) {
+  const property = declaration.prop.toLowerCase();
+  if (!OUTLINE_PROPERTIES.has(property)) return false;
+  const tokens = significantTokens(declaration.value);
+  if (tokens.some(
+    (t) => t.type === "function-token" && UNJUDGED_FUNCTIONS.has(String(t.structured?.value).toLowerCase())
+  )) {
+    return false;
+  }
+  const keyword = tokens.length === 1 ? identOf(tokens[0]) : void 0;
+  const judged = keyword === void 0 ? void 0 : keywordHides(property, keyword);
+  return judged ?? isRingHiddenByValue(property, tokens);
+}
+function isRingHiddenInBlock(declaration, siblings) {
+  return isRingHidden(declaration) && siblings.every((sibling) => !isAutoStyle(sibling));
+}
+function isClipPathInset(declaration) {
+  return declaration.prop.toLowerCase() === "clip-path" && compact(declaration.value) === "inset(50%)";
+}
+function isHidingSize(declaration) {
+  const prop = declaration.prop.toLowerCase();
+  return (prop === "width" || prop === "height") && compact(declaration.value) === "1px";
+}
+function isHidingTrio(declarations) {
+  const isPresent = (prop, value) => declarations.some((d) => d.prop.toLowerCase() === prop && compact(d.value) === value);
+  return isPresent("width", "1px") && isPresent("height", "1px") && isPresent("overflow", "hidden");
+}
+function isRevealHidden(declaration, siblings) {
+  if (isClipPathInset(declaration)) return true;
+  const prop = declaration.prop.toLowerCase();
+  const isTrioMember = isHidingSize(declaration) || prop === "overflow" && compact(declaration.value) === "hidden";
+  return isTrioMember && isHidingTrio(siblings);
+}
+function focusClauseOf(finding) {
+  const { atom } = finding.unit;
+  const { declaration, siblings } = finding.candidate;
+  if (atom.name === "focusRing" && isRingHiddenInBlock(declaration, siblings)) return RING_CLAUSE;
+  if (atom.name === "srOnlyFocusable" && isRevealHidden(declaration, siblings)) return REVEAL_CLAUSE;
+  return void 0;
+}
+
+// src/directive/order-text.ts
+function joinList(items, conjunction = "and") {
+  if (items.length <= 1) return items.join("");
+  return `${items.slice(0, -1).join(", ")} ${conjunction} ${items.at(-1)}`;
+}
+function isLaterContaining(pair) {
+  const later = new Set(longhandsOf(pair.later.prop).map((longhand) => standardName(longhand)));
+  return longhandsOf(pair.block.prop).every((longhand) => later.has(standardName(longhand)));
+}
+function isBareDeclaration(finding) {
+  const { overrider } = finding.candidate;
+  return overrider.kind === "own" && overrider.top.kind === "declaration";
+}
+function overriddenName(pair) {
+  const block = new Set(longhandsOf(pair.block.prop).map((longhand) => standardName(longhand)));
+  const later = longhandsOf(pair.later.prop).map((longhand) => standardName(longhand));
+  if (later.every((longhand) => block.has(longhand))) {
+    const standard = standardName(pair.later.prop);
+    return standard === pair.later.prop.toLowerCase() ? pair.later.prop : standard;
+  }
+  return joinList([...new Set(later.filter((longhand) => block.has(longhand)))]);
+}
+function valueClause(finding) {
+  const [first] = finding.pairs;
+  const { block, later } = first;
+  const isBare = isBareDeclaration(finding);
+  const blockValue = printedValue(block.value);
+  const laterValue = printedValue(later.value);
+  if (finding.pairs.length > 1 || !isSameProperty(block.prop, later.prop) && isLaterContaining(first)) {
+    const list = joinList([...new Set(finding.pairs.map((pair) => pair.block.prop))]);
+    return `${later.prop}: ${laterValue} replaces ${list}`;
+  }
+  if (isSameProperty(block.prop, later.prop)) {
+    return `${block.prop} is ${laterValue}, not ${blockValue}`;
+  }
+  const subject = isBare ? "it" : `its ${later.prop}: ${laterValue}`;
+  if (isLogicalPhysicalPair(block.prop, later.prop)) {
+    return `${subject} may override ${block.prop}: ${blockValue}, depending on writing mode`;
+  }
+  return `${subject} replaces the ${overriddenName(first)} that ${block.prop}: ${blockValue} sets`;
+}
+function placeClause(finding) {
+  const { unit, candidate } = finding;
+  const placed = {
+    conditions: unit.conditions,
+    said: unit.placeStates,
+    selector: unit.placeSelector ?? unit.selector
+  };
+  const place = whereOf(placed.selector, unit.conditions);
+  const also = alsoWhere(placed, {
+    selector: candidate.holderSelector,
+    conditions: candidate.conditions
+  });
+  return also === "" ? place : `${place} while also ${also},`;
+}
+function overriderName(finding) {
+  const { overrider, declaration } = finding.candidate;
+  if (overrider.kind === "atom") return `"${overrider.atom.name}"`;
+  if (overrider.top.kind === "declaration") {
+    return `${declaration.prop}: ${printedValue(declaration.value)}`;
+  }
+  if (finding.outward?.overrider !== void 0) return finding.outward.overrider;
+  if (overrider.top.kind === "rule") return `the ${printedValue(overrider.top.selector)} block`;
+  return `the @${overrider.top.name} ${printedValue(overrider.top.prelude)} block`;
+}
+function fixSentence(finding, context) {
+  if (finding.canMove?.() !== true) return void 0;
+  const { unit, candidate } = finding;
+  const atom = `"${unit.atom.name}"`;
+  const { overrider } = candidate;
+  if (finding.outward !== void 0) {
+    const moved = overrider.kind === "own" ? overriderName(finding) : `the directive that names "${overrider.atom.name}"`;
+    return `To let ${atom} win, move ${moved} above ${finding.outward.above}.`;
+  }
+  if (overrider.kind === "own")
+    return `To let ${atom} win, move ${overriderName(finding)} above the directive.`;
+  const later = `"${overrider.atom.name}"`;
+  if (overrider.directive.ref !== unit.directive.ref || context.moveAfter === void 0) {
+    return `To let ${atom} win, move it into the later directive, after ${later}.`;
+  }
+  const occurrences = unit.directive.atoms.filter((named) => named.name === unit.atom.name);
+  const printed = reorderedDirective(unit.directive.prelude, unit.directive.atoms, {
+    moving: occurrences.map((named) => named.atomIndex),
+    after: context.moveAfter
+  });
+  return `To let ${atom} win, name it after ${later}: \`${printed}\`.`;
+}
+function markerSentence(finding, context) {
+  const { unit, candidate } = finding;
+  const { overrider } = candidate;
+  const printed = `\`${context.markedDirective}\``;
+  if (overrider.kind === "own") {
+    return `If it is meant to win, mark the directive that names "${unit.atom.name}": ${printed}`;
+  }
+  const isSameDirective = overrider.directive.ref === unit.directive.ref;
+  const target = isSameDirective ? "mark the directive" : `mark the directive that names "${unit.atom.name}"`;
+  return `If "${overrider.atom.name}" is meant to win, ${target}: ${printed}`;
+}
+function migrationSentence(finding) {
+  const { overrider } = finding.candidate;
+  const isBlock = overrider.kind === "atom" && overrider.isBlock;
+  if (isBlock || finding.outward !== void 0) return void 0;
+  return overriderSentence(finding.unit.atom.name);
+}
+function findingText(finding, context) {
+  const opening = `${overriderName(finding)} comes after "${finding.unit.atom.name}"`;
+  const reason = `so ${placeClause(finding)} ${valueClause(finding)}.`;
+  const sentences = [
+    `@nave: ${opening}, ${reason}`,
+    focusClauseOf(finding),
+    migrationSentence(finding),
+    fixSentence(finding, context),
+    markerSentence(finding, context)
+  ];
+  return sentences.filter((sentence) => sentence !== void 0).join(" ");
+}
+
+// src/directive/order-warnings.ts
+function anchorOf(finding) {
+  const { overrider } = finding.candidate;
+  if (overrider.kind === "atom") {
+    return { ref: overrider.directive.ref, offset: overrider.atom.offset };
+  }
+  return { ref: overrider.topRef, offset: void 0 };
+}
+function remainingLonghands(finding, markers) {
+  const covered = coveredLonghands(markers, finding.candidate.declaration.prop);
+  if (covered.has("*")) return [];
+  return overriddenLonghands(finding.pairs).filter(
+    (longhand) => !covered.has(standardName(longhand))
+  );
+}
+function warningOf(finding, all) {
+  const { prelude } = finding.unit.directive;
+  const remaining = remainingLonghands(finding, readMarkers(prelude).markers);
+  if (remaining.length === 0) return void 0;
+  const names = namesForLonghands(remaining);
+  const context = {
+    markedDirective: markedDirective(prelude, names),
+    moveAfter: lastOverriderIndex(finding, all)
+  };
+  return { anchor: anchorOf(finding), text: findingText(finding, context) };
+}
+function findingWarnings(findings) {
+  return findings.flatMap((finding) => warningOf(finding, findings) ?? []);
+}
+function isUsed(name, findings) {
+  if (name.toLowerCase() === "all") {
+    return findings.some((f) => f.candidate.declaration.prop.toLowerCase() === "all");
+  }
+  const covered = new Set(longhandsCoveredBy(name));
+  return findings.some(
+    (f) => overriddenLonghands(f.pairs).some((longhand) => covered.has(standardName(longhand)))
+  );
+}
+function nameReport(name, findings, isStaleReported) {
+  if (!isCssProperty(name)) {
+    return `@nave: the marker on this directive names "${name}", which is not a CSS property, so it allows nothing. The marker takes property names, such as display, not atom names.`;
+  }
+  if (!isStaleReported || isUsed(name, findings)) return void 0;
+  return `@nave: the marker on this directive names ${name}, but nothing after the directive overrides ${name} in its atoms' blocks. Remove ${name} from the marker.`;
+}
+function markerReports(directive, findings, options) {
+  const { isStaleReported, outwardFor } = options;
+  const mine = [
+    ...findings.filter((finding) => finding.unit.directive.ref === directive.ref),
+    ...outwardFor(directive)
+  ];
+  const { markers, malformed } = readMarkers(directive.prelude);
+  const reports = [];
+  for (const marker of markers) {
+    if (marker.names.length === 0) {
+      reports.push({
+        start: marker.start,
+        text: "@nave: the nave-allow-override marker on this directive names no property, so it allows nothing. Name the property a warning reported, or remove the marker."
+      });
+    }
+    for (const name of marker.names) {
+      const text = nameReport(name, mine, isStaleReported);
+      if (text) reports.push({ start: marker.start, text });
+    }
+  }
+  for (const bad of malformed) {
+    reports.push({
+      start: bad.start,
+      text: `@nave: the comment ${bad.text} in this directive is not a marker, so it allows nothing: a marker starts with nave-allow-override and a colon, with nothing between them, such as \`/* nave-allow-override: display */\`. Correct the comment, or remove it.`
+    });
+  }
+  return reports.toSorted((a, b) => a.start - b.start).map(({ start, text }) => ({ anchor: { ref: directive.ref, offset: start }, text }));
+}
+function markerWarnings(directives, findings, isStaleReported, outwardFor) {
+  const options = { isStaleReported, outwardFor };
+  return directives.flatMap((directive) => markerReports(directive, findings, options));
+}
+
+// src/directive/rule-state.ts
+function createState(input) {
+  return {
+    above: void 0,
+    directives: [],
+    dropped: [],
+    directiveTotal: input.nodes.filter((node) => node.kind === "directive").length,
+    hasOwnNested: false,
+    input,
+    isNested: false,
+    isPseudoElementRule: isPseudoElementOnlyList(input.selector),
+    items: [],
+    lastDirective: void 0,
+    lastNested: void 0,
+    ownDeclarationSinceAbove: false,
+    run: { refs: [], trailing: [] },
+    runs: [],
+    segments: []
+  };
+}
+
+// src/directive/shape-warnings.ts
+var WRAP = "`& { }`";
+function splitSelectors(list) {
+  const all = splitTopLevel(list).map((selector) => selector.trim()).filter((selector) => selector !== "");
+  return {
+    pseudoElements: all.filter((selector) => endsInPseudoElement(selector)),
+    others: all.filter((selector) => !endsInPseudoElement(selector))
+  };
+}
+function quoted(names) {
+  return joinList(names.map((name) => `"${name}"`));
+}
+function anchorOf2(run) {
+  if (run.kind === "own") return { ref: run.anchorRef, offset: void 0 };
+  return { ref: run.directive.ref, offset: run.atoms[0].offset };
+}
+function pseudoElementText(run, pseudo) {
+  const other = `Or move ${pseudo} to a separate rule, with or without them.`;
+  if (run.kind === "own") {
+    return `@nave: the declarations after ${run.nested} are written inside ${WRAP}, which cannot match a pseudo-element, so they do not apply to ${pseudo}. ${wrappedPseudoElementSentence()} To apply them there too, move them above ${run.above}. ${other}`;
+  }
+  const atoms2 = quoted(run.atoms.map((atom) => atom.name));
+  const sentence = run.isWrappedBefore ? "" : ` ${wrappedPseudoElementSentence()}`;
+  const separate = `Move ${pseudo} to a separate rule, with or without them.`;
+  if (run.follows) return followsText(run, { atoms: atoms2, pseudo, sentence, separate, other });
+  const nestedSentence = run.nested.block && !run.isWrappedBefore ? sentence : "";
+  const move = run.canMoveDirective ? ` To apply them there too, move the directive above ${run.above}. ${other}` : ` ${separate}`;
+  return `@nave: this directive comes after ${run.nested.text}, so the declarations of ${atoms2} are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${pseudo}.${nestedSentence}${move}`;
+}
+function followsText(run, parts) {
+  const { follows } = run;
+  const head = `@nave: the declarations of ${parts.atoms} follow the block of "${follows.atom.name}" ${follows.where}, so they are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${parts.pseudo}.${parts.sentence}`;
+  if (!run.canReorder) return `${head} ${parts.separate}`;
+  const printed = directiveWithAtomsBefore(run.directive.prelude, run.directive.atoms, {
+    moving: run.atoms.map((atom) => atom.atomIndex),
+    before: follows.atom.atomIndex
+  });
+  return `${head} To apply them there too, name ${parts.atoms} before "${follows.atom.name}": \`${printed}\`. ${parts.other}`;
+}
+function groupsText(selectors, specificities) {
+  const groups = [];
+  for (const [index, selector] of selectors.others.entries()) {
+    const specificity = specificities[index];
+    const group = groups.find((g) => compareSpecificity(g.specificity, specificity) === 0);
+    if (group) group.members.push(selector);
+    else groups.push({ specificity, members: [selector] });
+  }
+  groups[0].members.push(...selectors.pseudoElements);
+  return joinList(groups.map((group) => `\`${group.members.join(", ")}\``));
+}
+function wrapText(run, selectors) {
+  const specificities = selectors.others.map((selector) => ampersandSpecificity(selector));
+  const highest = maxSpecificity(specificities);
+  const mostIndex = specificities.findIndex((s) => compareSpecificity(s, highest) === 0);
+  const most = selectors.others[mostIndex];
+  const less = selectors.others.filter(
+    (_s, i) => compareSpecificity(specificities[i], highest) < 0
+  );
+  const list = selectors.others.join(", ");
+  const wholeList = [`:is(${list})`, ...selectors.pseudoElements].join(", ");
+  const subject = run.kind === "own" ? `the declarations after ${run.nested}` : `the declarations of ${quoted(run.atoms.map((atom) => atom.name))}`;
+  const sentence = run.kind === "directive" && run.isWrappedBefore ? "" : ` ${wrappedSpecificitySentence()}`;
+  return `@nave: ${subject} are written inside ${WRAP}, which under the selector list ${list} matches with the specificity of ${most}, so where ${joinList(less, "or")} matches they can win over a rule elsewhere that is more specific than ${joinList(less, "or")}.${sentence} To give each selector its own specificity, write the rule once for each of ${groupsText(selectors, specificities)}. To give the whole rule the specificity of ${most}, write the list as \`${wholeList}\`.`;
+}
+function isUnequal(selectors) {
+  const [first, ...rest] = selectors.others.map((selector) => ampersandSpecificity(selector));
+  return first !== void 0 && rest.some((s) => compareSpecificity(s, first) !== 0);
+}
+function droppedWarning(fact) {
+  const blocks = fact.atoms.flatMap(
+    ({ atom, wheres }) => wheres.map((where) => `the block of "${atom.name}" ${where}`)
+  );
+  const atoms2 = quoted(fact.atoms.map(({ atom }) => atom.name));
+  const declarations = fact.atoms.flatMap(({ declarations: own }) => own.map((d) => `${d.prop}: ${d.value}`)).join("; ");
+  const tail = declarations === "" ? "" : ` and write these declarations in the rule instead: \`${declarations}\``;
+  return {
+    anchor: { ref: fact.directive.ref, offset: void 0 },
+    text: `@nave: every selector in this rule ends in a pseudo-element, and an atom's pseudo-class, @media and @container blocks are written on \`&\`, which cannot match one, so this directive leaves out ${joinList(blocks)}. Remove ${atoms2} from the directive${tail}. If a block was meant for the pseudo-element, write a rule for the pseudo-element under that condition yourself.`
+  };
+}
+function shapeWarnings(state) {
+  if (state.isPseudoElementRule) return state.dropped.map((fact) => droppedWarning(fact));
+  if (state.runs.length === 0) return [];
+  const selectors = splitSelectors(state.input.selector);
+  const isMixed = selectors.pseudoElements.length > 0 && selectors.others.length > 0;
+  const hasUnequal = isUnequal(selectors);
+  const pseudo = selectors.pseudoElements.join(", ");
+  return state.runs.flatMap((run) => {
+    const anchor = anchorOf2(run);
+    const found = [];
+    if (isMixed) found.push({ anchor, text: pseudoElementText(run, pseudo) });
+    if (hasUnequal) found.push({ anchor, text: wrapText(run, selectors) });
+    return found;
+  });
+}
+
+// src/directive/rule-plan.ts
+var DirectiveFailure = class extends Error {
+  cause;
+  ref;
+  constructor(ref, cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.ref = ref;
+    this.cause = cause;
+  }
+};
+function isRunWrapped(state) {
+  return state.lastDirective !== void 0 && state.isNested && !state.isPseudoElementRule;
+}
+function flushRun(state) {
+  const { run, items } = state;
+  if (run.refs.length > 0) {
+    if (isRunWrapped(state)) {
+      items.push({ kind: "wrap", refs: run.refs, after: state.lastDirective });
+      state.runs.push({
+        kind: "own",
+        anchorRef: run.refs[0],
+        above: state.above ?? "",
+        nested: state.lastNested?.text ?? ""
+      });
+    } else {
+      for (const ref of run.refs) items.push({ kind: "keep", ref });
+    }
+  }
+  for (const ref of run.trailing) items.push({ kind: "keep", ref });
+  run.refs = [];
+  run.trailing = [];
+}
+function takeIntoRun(state, node) {
+  const { run } = state;
+  if (node.kind === "decl") {
+    run.refs.push(...run.trailing, node.ref);
+    run.trailing = [];
+    if (state.above !== void 0) state.ownDeclarationSinceAbove = true;
+  } else if (run.refs.length === 0) {
+    state.items.push({ kind: "keep", ref: node.ref });
+  } else {
+    run.trailing.push(node.ref);
+  }
+}
+function planDirective(state, node) {
+  try {
+    return plan(
+      node.prelude,
+      { isStyleRuleParent: true, isInsideKeyframes: state.input.isInsideKeyframes },
+      { extend: state.input.extend }
+    );
+  } catch (error) {
+    throw new DirectiveFailure(node.ref, error);
+  }
+}
+function expandDirective(state, node) {
+  flushRun(state);
+  const result = planDirective(state, node);
+  const directive = directiveFacts(node, result);
+  state.directives.push(directive);
+  recordSegments(state, directive, result.atoms);
+  state.items.push({
+    kind: "expand",
+    ref: node.ref,
+    emissions: emitAtoms(state, directive, result.atoms),
+    diagnostics: result.diagnostics
+  });
+  state.lastDirective = node.ref;
+}
+function keepNested(state, node) {
+  flushRun(state);
+  state.items.push({ kind: "keep", ref: node.ref });
+  state.isNested = true;
+  state.hasOwnNested = true;
+  state.lastNested = { text: nestedText(node) };
+  state.above ??= nestedText(node);
+}
+function warningsOf(state) {
+  const { emittedCache, extend, isInsideKeyframes, outward } = state.input;
+  const findings = canHoldPair(state.segments) ? checkOrder(
+    state.segments,
+    ampersandSpecificity(state.input.selector),
+    (directive) => plannedDirective(directive, { extend, isInsideKeyframes }, emittedCache),
+    state.isPseudoElementRule
+  ) : [];
+  const knownFor = (directive) => outward?.known.get(outward.identityOf(directive.ref)) ?? [];
+  const warnings = [
+    ...findingWarnings(findings),
+    ...markerWarnings(
+      state.directives,
+      findings,
+      state.input.reportStaleMarkers !== false,
+      knownFor
+    ),
+    ...shapeWarnings(state)
+  ];
+  return {
+    outwardFindings: findings.filter((finding) => finding.outward !== void 0),
+    warnings: warnings.toSorted(
+      (a, b) => a.anchor.ref - b.anchor.ref || (a.anchor.offset ?? -1) - (b.anchor.offset ?? -1)
+    )
+  };
+}
+function planRule(input) {
+  const state = createState(input);
+  for (const node of input.nodes) {
+    if (node.kind === "decl" || node.kind === "comment") takeIntoRun(state, node);
+    else if (node.kind === "directive") expandDirective(state, node);
+    else keepNested(state, node);
+    if (node.kind !== "comment" && node.kind !== "directive") {
+      state.segments.push({ kind: "own", node });
+    }
+  }
+  flushRun(state);
+  return { items: state.items, ...warningsOf(state) };
+}
+
+// src/directive/expand-text-apply.ts
+function significantEnd(w, item) {
+  let last = item.end - 1;
+  while (last > item.start && w.tokens[last].type === "whitespace-token") last--;
+  return w.tokens[last].endIndex;
+}
+function declarationEnd(w, item) {
+  let last = item.end - 1;
+  if (w.tokens[last].type === "semicolon-token") return w.tokens[last].endIndex;
+  while (last > item.start && isInertToken(w.tokens[last])) last--;
+  return w.tokens[last].endIndex;
+}
+function isInertToken(token) {
+  return token.type === "whitespace-token" || token.type === "comment";
+}
+function repositionDiagnostics(diagnostics, item, span) {
+  const preludeOffset = item.preludeOffset ?? 0;
+  return diagnostics.map((d) => {
+    if (d.code === "unknown-atom" || d.code === "bad-token") {
+      return { ...d, offset: preludeOffset + d.offset, endOffset: preludeOffset + d.endOffset };
+    }
+    return { ...d, offset: span.start, endOffset: span.end };
+  });
+}
+function applyExpand(w, plan2, itemOf) {
+  const item = itemOf[plan2.ref];
+  const span = { start: w.tokens[item.start].startIndex, end: significantEnd(w, item) };
+  const diagnostics = repositionDiagnostics(plan2.diagnostics, item, span);
+  if (item.blockStart !== void 0) {
+    diagnostics.push({ code: "has-block", offset: span.start, endOffset: span.end });
+  }
+  w.diagnostics.push(...diagnostics);
+  const text = renderEmissions(plan2.emissions);
+  const source = w.positionAt(span.start);
+  w.edits.push({
+    start: span.start,
+    end: span.end,
+    parts: text === "" ? [] : [{ text, source }]
+  });
+}
+function applyWrap(w, plan2, facts) {
+  const first = facts.model.itemOf[plan2.refs[0]];
+  const last = facts.model.itemOf[plan2.refs.at(-1)];
+  const directive = facts.model.itemOf[plan2.after];
+  const source = w.positionAt(w.tokens[directive.start].startIndex);
+  const open = w.tokens[first.start].startIndex;
+  w.edits.push({ start: open, end: open, parts: [{ text: "& { ", source }] });
+  if (!facts.isClosed && last === facts.items.at(-1)) {
+    facts.endParts.push({ text: " }", source });
+    return;
+  }
+  const close = declarationEnd(w, last);
+  w.edits.push({ start: close, end: close, parts: [{ text: " }", source }] });
+}
+function applyItem(w, plan2, facts) {
+  if (plan2.kind === "expand") applyExpand(w, plan2, facts.model.itemOf);
+  else if (plan2.kind === "wrap") applyWrap(w, plan2, facts);
+}
+function recordWarnings(w, warnings, itemOf) {
+  for (const { anchor, text } of warnings) {
+    const item = itemOf[anchor.ref];
+    const start = anchor.offset === void 0 ? w.tokens[item.start].startIndex : (item.preludeOffset ?? 0) + anchor.offset;
+    w.warnings.push({ offset: start, text });
+  }
+}
+function applyRuleFrame(w, facts) {
+  let plan2;
+  try {
+    plan2 = planRule({
+      selector: facts.selector,
+      nodes: facts.model.nodes,
+      isInsideKeyframes: facts.isInsideKeyframes,
+      extend: w.options.extend,
+      reportStaleMarkers: w.options.reportStaleMarkers,
+      emittedCache: w.emittedCache,
+      outward: { identityOf: (ref) => facts.model.itemOf[ref].start, known: w.outwardKnown }
+    });
+  } catch (error) {
+    throw error instanceof DirectiveFailure ? error.cause : error;
+  }
+  for (const finding of plan2.outwardFindings) {
+    const key = facts.model.itemOf[finding.unit.directive.ref].start;
+    w.outwardKnown.set(key, [...w.outwardKnown.get(key) ?? [], finding]);
+  }
+  recordWarnings(w, plan2.warnings, facts.model.itemOf);
+  for (const item of plan2.items) applyItem(w, item, facts);
+}
+
+// src/directive/group-at-rules.ts
+var WORKAROUND_GROUP_AT_RULE_NAMES = /* @__PURE__ */ new Set([
+  "container",
+  "layer",
+  "media",
+  "scope",
+  "starting-style",
+  "supports"
+]);
+
+// src/directive/expand-text-context.ts
+function isKeyframesName(name) {
+  return /keyframes$/i.test(name);
+}
+function childContext(source, item, context) {
+  const { isInsideKeyframes, hasStyleRuleAncestor } = context;
+  const { css, tokens } = source;
+  if (item.kind === "rule") {
+    const selectorEnd = tokens[item.blockStart - 1].startIndex;
+    return {
+      isStyleRuleParent: true,
+      isInsideKeyframes,
+      hasStyleRuleAncestor: true,
+      isWorkaroundGroup: false,
+      selector: css.slice(tokens[item.start].startIndex, selectorEnd).trim()
+    };
+  }
+  const name = atKeywordName(tokens[item.start]);
+  const isKeyframes = isInsideKeyframes || isKeyframesName(name);
+  return {
+    isStyleRuleParent: false,
+    isInsideKeyframes: isKeyframes,
+    hasStyleRuleAncestor,
+    isWorkaroundGroup: WORKAROUND_GROUP_AT_RULE_NAMES.has(name) && !isKeyframes && hasStyleRuleAncestor,
+    selector: ""
+  };
+}
+
+// src/directive/expand-text-terminator.ts
+function endOfToken(tokens, lastAt, limit) {
+  const last = tokens[lastAt];
+  const isLoneBackslash = last.type === "delim-token" && last.raw === "\\";
+  return isLoneBackslash && lastAt + 1 < limit ? tokens[lastAt + 1].endIndex : last.endIndex;
+}
+
+// src/directive/expand-text-eof-close.ts
+function hasUnescapedTrailingChar(raw, char) {
+  if (raw.length < 2 || raw.at(-1) !== char) return false;
+  let backslashes = 0;
+  for (let i = raw.length - 2; i >= 0 && raw[i] === "\\"; i--) backslashes++;
+  return backslashes % 2 === 0;
+}
+function trailingBackslashCount(raw) {
+  let count = 0;
+  for (let i = raw.length - 1; i >= 0 && raw[i] === "\\"; i--) count++;
+  return count;
+}
+var ESCAPE_CLOSER = "fffd";
+function isStringEndingInLoneBackslash(token) {
+  return token.type === "string-token" && !hasUnescapedTrailingChar(token.raw, token.raw[0] ?? "") && trailingBackslashCount(token.raw) % 2 === 1;
+}
+function lexicalEofCloser(token) {
+  if (token.type === "string-token") {
+    const quote = token.raw[0];
+    if (quote === void 0 || hasUnescapedTrailingChar(token.raw, quote)) return void 0;
+    return quote;
+  }
+  if (token.type === "url-token" || token.type === "bad-url-token") {
+    if (token.raw.endsWith(")")) return void 0;
+    return trailingBackslashCount(token.raw) % 2 === 1 ? String.raw`\)` : ")";
+  }
+  return trailingBackslashCount(token.raw) % 2 === 1 ? ESCAPE_CLOSER : void 0;
+}
+function bracketEofCloser(type) {
+  if (type === "{-token") return "}";
+  if (type === "[-token") return "]";
+  return ")";
+}
+function scanFrameTail(w, start, limit) {
+  const scan = { unmatchedOpeners: [], hasDanglingText: false, hasOpenColon: false };
+  let i = start;
+  while (i < limit) i = scanToken(w, i, limit, scan) + 1;
+  return { ...scan, unmatchedOpeners: scan.unmatchedOpeners.toReversed() };
+}
+function scanToken(w, i, limit, scan) {
+  const type = w.tokens[i].type;
+  if (type !== "whitespace-token" && type !== "comment") scan.hasDanglingText = true;
+  if (type === "semicolon-token") {
+    scan.hasOpenColon = false;
+    scan.hasDanglingText = false;
+  } else if (type === "colon-token") {
+    scan.hasOpenColon = true;
+  } else if (OPENERS.has(type)) {
+    const closeIndex = w.closerFor[i];
+    if (closeIndex === -1 || closeIndex >= limit) {
+      scan.unmatchedOpeners.push(i);
+      return i;
+    }
+    if (type === "{-token") scan.hasDanglingText = false;
+    return closeIndex;
+  }
+  return i;
+}
+function eofClosers(w, start, limit, last) {
+  const closers = [];
+  const lexical = last ? lexicalEofCloser(last) : void 0;
+  if (lexical) closers.push(lexical);
+  const scan = scanFrameTail(w, start, limit);
+  for (const openIndex of scan.unmatchedOpeners) {
+    closers.push(bracketEofCloser(w.tokens[openIndex].type));
+  }
+  if (scan.hasOpenColon) {
+    closers.push(";");
+  } else if (closers.length === (lexical === ESCAPE_CLOSER ? 1 : 0) && scan.hasDanglingText) {
+    closers.push("{}");
+  }
+  return closers.join("");
+}
+function closeInfoFor(w, frameStart, blockEndIndex, scanLimit) {
+  const closer = w.tokens[blockEndIndex];
+  if (closer) return { position: closer.startIndex, prefix: "", prefixPosition: closer.startIndex };
+  const last = scanLimit > frameStart ? w.tokens[scanLimit - 1] : void 0;
+  const trailing = unclosedTrailingComment(w);
+  if (trailing !== void 0 && last !== trailing) {
+    const prefix2 = eofClosers(w, frameStart, scanLimit, last);
+    return { position: trailing.startIndex, prefix: prefix2, prefixPosition: trailing.startIndex };
+  }
+  if (last?.type === "comment") {
+    const position = isClosedComment(last) ? w.css.length : last.startIndex;
+    return { position, ...closersBeforeComment(w, frameStart, scanLimit, position) };
+  }
+  const prefix = eofClosers(w, frameStart, scanLimit, last);
+  if (last !== void 0 && isStringEndingInLoneBackslash(last)) {
+    const position = last.endIndex - 1;
+    return { position, prefix, prefixPosition: position };
+  }
+  return { position: w.css.length, prefix, prefixPosition: w.css.length };
+}
+function isClosedComment(token) {
+  return token.raw.length >= 4 && token.raw.endsWith("*/");
+}
+function unclosedTrailingComment(w) {
+  const token = w.tokens.at(-1);
+  return token?.type === "comment" && !isClosedComment(token) ? token : void 0;
+}
+function isInert(token) {
+  return token.type === "whitespace-token" || token.type === "comment";
+}
+function closersBeforeComment(w, frameStart, scanLimit, fallback) {
+  let i = scanLimit - 1;
+  while (i >= frameStart && isInert(w.tokens[i])) i--;
+  if (i < frameStart) return { prefix: "", prefixPosition: fallback };
+  return {
+    prefix: eofClosers(w, frameStart, scanLimit, void 0),
+    prefixPosition: endOfToken(w.tokens, i, scanLimit)
+  };
+}
+
+// src/directive/expand-text-model.ts
+var GROUP_NAMES2 = /* @__PURE__ */ new Set(["container", "media", "supports"]);
+function isInert2(token) {
+  return token.type === "whitespace-token" || token.type === "comment";
+}
+function readBlockItems(source, start, limit) {
+  const items = [];
+  let i = start;
+  while (i < limit) {
+    if (isInert2(source.tokens[i])) {
+      i++;
+      continue;
+    }
+    const item = readItem(source.tokens, i, limit, source.closerFor);
+    items.push(item);
+    i = item.end;
+  }
+  return items;
+}
+function colonIndex(tokens, item) {
+  let i = item.start + 1;
+  while (i < item.end && tokens[i].type !== "colon-token") i++;
+  return i;
+}
+function valueEndIndex(tokens, item) {
+  const last = tokens[item.end - 1];
+  return last?.type === "semicolon-token" ? item.end - 1 : item.end;
+}
+function lastSignificant2(tokens, from, to) {
+  let i = to - 1;
+  while (i >= from && isInert2(tokens[i])) i--;
+  return i;
+}
+function isImportantIdent(token) {
+  return token?.type === "ident-token" && String(token.structured?.value).toLowerCase() === "important";
+}
+function importantIndex(tokens, from, to) {
+  const ident = lastSignificant2(tokens, from, to);
+  if (!isImportantIdent(tokens[ident])) return void 0;
+  const bang = lastSignificant2(tokens, from, ident);
+  const token = tokens[bang];
+  return token?.type === "delim-token" && token.structured?.value === "!" ? bang : void 0;
+}
+function trimmedText(source, from, to) {
+  let start = from;
+  let end = to;
+  while (start < end && isInert2(source.tokens[start])) start++;
+  while (end > start && isInert2(source.tokens[end - 1])) end--;
+  if (start >= end) return "";
+  return source.css.slice(source.tokens[start].startIndex, source.tokens[end - 1].endIndex);
+}
+function declarationNode2(source, item, ref) {
+  const { tokens } = source;
+  const colon = colonIndex(tokens, item);
+  const end = valueEndIndex(tokens, item);
+  const bang = importantIndex(tokens, colon + 1, end);
+  return {
+    kind: "decl",
+    ref,
+    prop: String(tokens[item.start].structured?.value),
+    value: trimmedText(source, colon + 1, bang ?? end),
+    important: bang !== void 0
+  };
+}
+function selectorOf(source, item) {
+  return trimmedText(source, item.start, item.blockStart - 1);
+}
+function usable(items) {
+  return items.filter((item) => item.kind !== "invalid");
+}
+function contentOf(source, item, itemOf) {
+  let nodes;
+  return () => {
+    nodes ??= readItems(source, readBlockItems(source, item.blockStart, item.blockEnd), itemOf);
+    return nodes;
+  };
+}
+function ruleNode(source, item, ref, itemOf) {
+  const content = contentOf(source, item, itemOf);
+  return {
+    kind: "rule",
+    ref,
+    selector: selectorOf(source, item),
+    get nodes() {
+      return content();
+    }
+  };
+}
+function atRuleNode(source, item, ref, itemOf) {
+  const prelude = source.css.slice(item.preludeOffset ?? 0, item.preludeEndOffset ?? 0);
+  if (isNaveAtKeyword(source.tokens[item.start])) return { kind: "directive", ref, prelude };
+  const name = item.atKeyword ?? "";
+  if (!GROUP_NAMES2.has(name) || item.blockStart === void 0) {
+    return { kind: "opaque", ref, name, prelude: prelude.trim() };
+  }
+  const content = contentOf(source, item, itemOf);
+  return {
+    kind: "group",
+    ref,
+    name,
+    prelude: prelude.trim(),
+    get nodes() {
+      return content();
+    }
+  };
+}
+function itemNode(source, item, ref, itemOf) {
+  if (item.kind === "declaration") return declarationNode2(source, item, ref);
+  if (item.kind === "rule" && item.blockStart !== void 0) {
+    return ruleNode(source, item, ref, itemOf);
+  }
+  if (item.kind === "at-rule") return atRuleNode(source, item, ref, itemOf);
+  return { kind: "opaque", ref, name: "", prelude: "" };
+}
+function readItems(source, items, itemOf) {
+  return usable(items).map((item) => {
+    const ref = itemOf.length;
+    itemOf.push(item);
+    return itemNode(source, item, ref, itemOf);
+  });
+}
+function readBlockModel(source, items) {
+  const itemOf = [];
+  const nodes = readItems(source, items, itemOf);
+  return { nodes, itemOf };
+}
+
+// src/directive/expand-text-walk.ts
+var Walker = class {
+  closerFor;
+  css;
+  diagnostics = [];
+  // The index of every `@nave` token, in order: whether a block holds a directive anywhere inside.
+  directiveTokens;
+  edits = [];
+  emittedCache = /* @__PURE__ */ new Map();
+  // Built once per call, not once per query: `positionAt` runs once per
+  // output token, and a fresh linear scan on every call made the whole
+  // pass quadratic in the stylesheet's size. Not private: this
+  // project's class-member-order and class-sort lint rules disagree with
+  // each other on where a private field goes relative to the surrounding
+  // public ones, which a field with no access modifier sidesteps.
+  // How far back an EOF-closing frame may look for its own unmatched
+  // brackets/declaration: shrinks to a frame's own start every time that
+  // frame writes its own EOF closers, so an ancestor frame further out
+  // never rediscovers — and re-closes — the same inner construct. Starts
+  // at `tokens.length`, unbounded, since nothing has closed anything yet.
+  eofScanLimit;
+  findPosition;
+  options;
+  // What an enclosing rule found for a directive written in a rule nested in it, by the directive's
+  // first token, for the plan of that rule.
+  outwardKnown = /* @__PURE__ */ new Map();
+  tokens;
+  warnings = [];
+  constructor(css, options) {
+    this.css = css;
+    this.tokens = tokenize(css);
+    this.closerFor = matchBrackets(this.tokens);
+    this.options = options;
+    this.findPosition = createPositionFinder(css);
+    this.eofScanLimit = this.tokens.length;
+    this.directiveTokens = this.tokens.flatMap(
+      (token, index) => isNaveAtKeyword(token) ? [index] : []
+    );
+  }
+  /**
+   * Whether a `@nave` stands between the tokens `start` and `limit`, at any depth.
+   */
+  hasDirectiveWithin(start, limit) {
+    let low = 0;
+    let high = this.directiveTokens.length;
+    while (low < high) {
+      const middle = low + high >> 1;
+      if (this.directiveTokens[middle] <= start) low = middle + 1;
+      else high = middle;
+    }
+    const next = this.directiveTokens[low];
+    return next !== void 0 && next < limit;
+  }
+  positionAt(offset) {
+    return this.findPosition(offset);
+  }
+};
+function markNestedGroup(diagnostics) {
+  for (const [i, d] of diagnostics.entries()) {
+    if (d.code === "bad-parent") diagnostics[i] = { ...d, detail: "nested-group" };
+  }
+}
+function processRefusedDirective(w, item, context) {
+  const directiveStart = w.tokens[item.start].startIndex;
+  const directiveEnd = w.tokens[item.end - 1].endIndex;
+  const prelude = w.css.slice(item.preludeOffset ?? 0, item.preludeEndOffset ?? 0);
+  const result = plan(
+    prelude,
+    { isStyleRuleParent: false, isInsideKeyframes: context.isInsideKeyframes },
+    { extend: w.options.extend }
+  );
+  const positioned = repositionDiagnostics(result.diagnostics, item, {
+    start: directiveStart,
+    end: directiveEnd
+  });
+  if (context.isWorkaroundGroup) markNestedGroup(positioned);
+  if (item.blockStart !== void 0)
+    positioned.push({ code: "has-block", offset: directiveStart, endOffset: directiveEnd });
+  w.diagnostics.push(...positioned);
+  w.edits.push({ start: directiveStart, end: directiveEnd, parts: [] });
+}
+function flushFrame(w, frameStart, blockEndIndex, frame) {
+  if (frame.parts.length === 0) return;
+  const close = closeInfoFor(w, frameStart, blockEndIndex, w.eofScanLimit);
+  if (w.tokens[blockEndIndex] === void 0) w.eofScanLimit = frameStart;
+  if (close.prefix !== "") {
+    const source = w.positionAt(close.prefixPosition);
+    w.edits.push({
+      start: close.prefixPosition,
+      end: close.prefixPosition,
+      parts: [{ text: close.prefix, source }]
+    });
+  }
+  w.edits.push({ start: close.position, end: close.position, parts: frame.parts });
+}
+function isDirective(w, item) {
+  return item.kind === "at-rule" && isNaveAtKeyword(w.tokens[item.start]);
+}
+function hasDirectiveInside(w, items, bounds) {
+  return items.some((item) => isDirective(w, item)) || w.hasDirectiveWithin(bounds.start, bounds.limit);
+}
+function toWalkFrame(w, bounds) {
+  const items = readBlockItems(w, bounds.start, bounds.limit);
+  const frame = { parts: [] };
+  if (bounds.context.isStyleRuleParent && hasDirectiveInside(w, items, bounds)) {
+    applyRuleFrame(w, {
+      items,
+      model: readBlockModel(w, items),
+      selector: bounds.context.selector,
+      isInsideKeyframes: bounds.context.isInsideKeyframes,
+      isClosed: w.tokens[bounds.limit] !== void 0,
+      endParts: frame.parts
+    });
+  }
+  return {
+    next: 0,
+    items,
+    limit: bounds.limit,
+    start: bounds.start,
+    context: bounds.context,
+    frame
+  };
+}
+function childFrameFor(w, item, context) {
+  if (item.blockStart === void 0 || item.blockEnd === void 0) return void 0;
+  return toWalkFrame(w, {
+    start: item.blockStart,
+    limit: item.blockEnd,
+    context: childContext(w, item, context)
+  });
+}
+function walkBlock(w, bounds) {
+  const stack = [toWalkFrame(w, bounds)];
+  while (stack.length > 0) {
+    const top = stack.at(-1);
+    const item = top.items[top.next];
+    if (item === void 0) {
+      flushFrame(w, top.start, top.limit, top.frame);
+      stack.pop();
+      continue;
+    }
+    top.next++;
+    if (isDirective(w, item)) {
+      if (!top.context.isStyleRuleParent) processRefusedDirective(w, item, top.context);
+    } else if (item.kind === "rule" || item.kind === "at-rule") {
+      const child = childFrameFor(w, item, top.context);
+      if (child) stack.push(child);
+    }
+  }
+}
+
+// src/directive/expand-text.ts
+function expandText(css, options = {}) {
+  const w = new Walker(css, options);
+  walkBlock(w, {
+    start: 0,
+    limit: w.tokens.length,
+    context: {
+      isStyleRuleParent: false,
+      isInsideKeyframes: false,
+      hasStyleRuleAncestor: false,
+      isWorkaroundGroup: false,
+      selector: ""
+    }
+  });
+  const { css: outputCss, map } = buildOutput({
+    css: w.css,
+    tokens: w.tokens,
+    edits: w.edits,
+    from: options.from,
+    inputSourceMap: options.inputSourceMap,
+    positionAt: (offset) => w.positionAt(offset)
+  });
+  return {
+    css: outputCss,
+    map,
+    diagnostics: reportDiagnostics(w.diagnostics, css, options),
+    warnings: positionWarnings(w.warnings, css, options.from)
+  };
+}
+
+// src/snapshot-extend-atoms.ts
+function snapshotDeclarations(declarations) {
+  if (!isPlainObject(declarations)) return declarations;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [prop, value] of Object.entries(declarations)) {
+    out[prop] = typeof value === "string" ? value : String(value);
+  }
+  return out;
+}
+function snapshotPseudos(pseudos) {
+  if (!isPlainObject(pseudos)) return pseudos;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [selector, declarations] of Object.entries(pseudos)) {
+    out[selector] = snapshotDeclarations(declarations);
+  }
+  return out;
+}
+function snapshotAtBlock(block) {
+  if (!isPlainObject(block)) return block;
+  const out = /* @__PURE__ */ Object.create(null);
+  if ("declarations" in block) out.declarations = snapshotDeclarations(block.declarations);
+  if ("pseudos" in block) out.pseudos = snapshotPseudos(block.pseudos);
+  return out;
+}
+function snapshotAtBlocks(blocks) {
+  if (!isPlainObject(blocks)) return blocks;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [condition, block] of Object.entries(blocks)) {
+    out[condition] = snapshotAtBlock(block);
+  }
+  return out;
+}
+function snapshotAtomDefinition(atom) {
+  if (!isPlainObject(atom)) return atom;
+  const out = /* @__PURE__ */ Object.create(null);
+  if ("declarations" in atom) out.declarations = snapshotDeclarations(atom.declarations);
+  if ("pseudos" in atom) out.pseudos = snapshotPseudos(atom.pseudos);
+  if ("media" in atom) out.media = snapshotAtBlocks(atom.media);
+  if ("container" in atom) out.container = snapshotAtBlocks(atom.container);
+  return out;
+}
+function snapshotExtendMap(map) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [name, atom] of Object.entries(map)) {
+    out[name] = snapshotAtomDefinition(atom);
+  }
+  return out;
+}
+
+// src/directive/fold.ts
+function splitAvailable(text) {
+  const lines = text.split("\n");
+  const last = lines.at(-1);
+  if (lines.length > 1 && last?.startsWith("Available: ")) {
+    return { body: lines.slice(0, -1).join("\n"), available: last };
+  }
+  return { body: text, available: void 0 };
+}
+function withoutNavePrefix(text) {
+  return text.startsWith("@nave: ") ? text.slice(7) : text;
+}
+function foldLocated(entries) {
+  const parts = entries.map((entry) => ({ ...splitAvailable(entry.text), entry }));
+  const [first, ...rest] = parts;
+  const lines = [first.body];
+  if (rest.length > 0) {
+    lines.push(`${rest.length} more in this stylesheet:`);
+    for (const { body, entry } of rest) {
+      lines.push(`${entry.line}:${entry.column}: ${withoutNavePrefix(body)}`);
+    }
+  }
+  const available = parts.find((part) => part.available !== void 0)?.available;
+  if (available) lines.push(available);
+  return lines.join("\n");
+}
+
+// src/validate-extend-scan.ts
+function isInert3(token) {
+  return token.type === "whitespace-token" || token.type === "comment";
+}
+function isOnlyInert(tokens, from, to) {
+  for (let i = from; i < to; i++) if (!isInert3(tokens[i])) return false;
+  return true;
+}
+function hasStrayCurlyCloser(wrapped, from, to) {
+  const matchedClosers = new Set(wrapped.closerFor);
+  for (let i = from; i < to; i++) {
+    if (wrapped.tokens[i].type === "}-token" && !matchedClosers.has(i)) return true;
+  }
+  return false;
+}
+function hasPaddedComment(tokens, from, to) {
+  for (let i = from; i < to; i++) {
+    if (tokens[i].type !== "comment") continue;
+    if (tokens[i - 1]?.type === "whitespace-token" || tokens[i + 1]?.type === "whitespace-token")
+      return true;
+  }
+  return false;
+}
+function hasTopLevelComment(wrapped, from, to) {
+  let i = from;
+  while (i < to) {
+    const closer = wrapped.closerFor[i];
+    const type = wrapped.tokens[i].type;
+    if (closer !== -1 && (type === "(-token" || type === "function-token")) {
+      i = closer + 1;
+      continue;
+    }
+    if (type === "comment") return true;
+    i++;
+  }
+  return false;
+}
+function hasBrokenString(tokens, from, to) {
+  for (let i = from; i < to; i++) {
+    if (tokens[i].type === "bad-string-token" || tokens[i].type === "bad-url-token") return true;
+  }
+  return false;
+}
+function hasUrl(tokens, from, to) {
+  for (let i = from; i < to; i++) {
+    if (tokens[i].type === "url-token" && tokens[i].raw.includes("/*")) return true;
+  }
+  return false;
+}
+function lastNonWhitespace(tokens, from, to) {
+  let i = to - 1;
+  while (i >= from && tokens[i].type === "whitespace-token") i--;
+  return i;
+}
+function hasTopLevelColon(wrapped, from, to) {
+  let i = from;
+  while (i < to) {
+    const closer = wrapped.closerFor[i];
+    const type = wrapped.tokens[i].type;
+    if (closer !== -1 && (type === "(-token" || type === "function-token")) {
+      i = closer + 1;
+      continue;
+    }
+    if (wrapped.tokens[i].type === "colon-token") return true;
+    i++;
+  }
+  return false;
+}
+function hasEscapedCommentOpener(text) {
+  const outsideStrings = tokenize(text).map((token) => token.type === "string-token" ? '""' : token.raw).join("");
+  return outsideStrings.includes(String.raw`\/*`);
+}
+function hasHtmlBreakout(text) {
+  return /<\/?style\b/i.test(text) || text.includes("<!--");
+}
+function hasUnstrippedTrailingSpace(text) {
+  const tokens = tokenize(text);
+  const last = lastNonWhitespace(tokens, 0, tokens.length);
+  const raw = tokens[last]?.raw;
+  return raw !== void 0 && raw !== raw.trimEnd();
+}
+function hasUnstrippedLeadingSpace(text) {
+  const tokens = tokenize(text);
+  const first = tokens.findIndex((token) => token.type !== "whitespace-token");
+  const raw = tokens[first]?.raw;
+  return raw !== void 0 && raw !== raw.trimStart();
+}
+function hasEscapedWhitespace(text) {
+  return /\\[\da-f]{0,6}[\t\n\f\r ]/i.test(text);
+}
+
+// src/validate-extend-breakout.ts
+var SENTINEL = ".nave-sentinel{}";
+var ATOM = "probe";
+function atomFor(splice) {
+  if (splice.kind === "declarations") {
+    return { atoms: { [ATOM]: { declarations: splice.declarations } }, nested: 0 };
+  }
+  const color = { color: "red" };
+  if (splice.kind === "pseudo") {
+    const pseudos = { [splice.key]: color };
+    return { atoms: { [ATOM]: { declarations: {}, pseudos } }, nested: 1 };
+  }
+  const blocks = { [splice.condition]: { declarations: color } };
+  return { atoms: { [ATOM]: { declarations: {}, [splice.atName]: blocks } }, nested: 1 };
+}
+function itemsIn(tokens, closerFor, from, to) {
+  const items = [];
+  let i = from;
+  while (i < to) {
+    const type = tokens[i].type;
+    if (type === "whitespace-token" || type === "comment") {
+      i++;
+      continue;
+    }
+    const item = readItem(tokens, i, to, closerFor);
+    items.push(item);
+    i = Math.max(item.end, i + 1);
+  }
+  return items;
+}
+function textOf(tokens, from, to) {
+  return tokens.slice(from, to).map((token) => token.raw).join("");
+}
+function isExpectedNested(splice, tokens, item) {
+  if (splice.kind === "condition") {
+    return item.kind === "at-rule" && item.atKeyword === splice.atName;
+  }
+  if (item.kind !== "rule" || item.blockStart === void 0) return false;
+  return textOf(tokens, item.start, item.blockStart - 1).trim() === anchorSelectorList(splice.key);
+}
+function readRuleThenSentinel(css) {
+  const tokens = tokenize(css);
+  const closerFor = matchBrackets(tokens);
+  const [rule, sentinel, ...rest] = itemsIn(tokens, closerFor, 0, tokens.length);
+  if (rule === void 0 || sentinel === void 0 || rest.length > 0) return void 0;
+  if (rule.blockStart === void 0 || closerFor[rule.blockStart - 1] !== rule.blockEnd) {
+    return void 0;
+  }
+  const isSentinelWhereAppended = textOf(tokens, 0, sentinel.start).length === css.length - SENTINEL.length;
+  const isSentinelText = textOf(tokens, sentinel.start, sentinel.end) === SENTINEL;
+  const isClosedBeforeIt = isOnlyInert(tokens, rule.end, sentinel.start);
+  return isSentinelWhereAppended && isSentinelText && isClosedBeforeIt ? { closerFor, rule, tokens } : void 0;
+}
+function isInsideRule(splice) {
+  const { atoms: atoms2, nested } = atomFor(splice);
+  let css;
+  try {
+    css = expandText(`.p { @nave ${ATOM}; }
+${SENTINEL}`, {
+      extend: atoms2,
+      onUnknown: "ignore"
+    }).css;
+  } catch {
+    return true;
+  }
+  const read = readRuleThenSentinel(css);
+  if (read === void 0) return false;
+  const { closerFor, rule, tokens } = read;
+  const inner = itemsIn(tokens, closerFor, rule.blockStart, rule.blockEnd);
+  const nestedItems = inner.filter((item) => item.kind === "rule" || item.kind === "at-rule");
+  if (nestedItems.length !== nested) return false;
+  return splice.kind === "declarations" || isExpectedNested(splice, tokens, nestedItems[0]);
+}
+
+// src/validate-extend-walk.ts
+function refuse(describedAs, clause) {
+  throw new Error(
+    `navePlugin({ extend }): ${describedAs} ${clause} extend is trusted, consumer-authored code, not sanitised input \u2014 fix the atom definition.`
+  );
+}
+var ESCAPED_LESS_THAN = String.raw`\3c`;
+function fail(describedAs, reason, value, splice) {
+  if (reason === "rewritten") {
+    refuse(
+      describedAs,
+      `parses, but would not be written back exactly as given: ${JSON.stringify(value)}. A "<" before "style", "/style" or "!--" is written back escaped: write the "<" as ${ESCAPED_LESS_THAN} with a space after it (${ESCAPED_LESS_THAN} /style), or as %3C inside a URL. Whitespace at either end of it is not written back as given: remove it.`
+    );
+  }
+  const clause = "does not parse as a single CSS declaration, selector or condition, ";
+  if (isInsideRule(splice)) {
+    refuse(
+      describedAs,
+      `${clause}though it would stay inside the rule it is spliced into: ${JSON.stringify(value)}. Write exactly one, with nothing else in it: no ";" or second declaration, no comment, and no trailing backslash.`
+    );
+  }
+  refuse(
+    describedAs,
+    `${clause}and would break out of the rule it is spliced into: ${JSON.stringify(value)}.`
+  );
+}
+function kindOf(value) {
+  if (Array.isArray(value)) return "an array";
+  const boxed = boxedPrimitiveKind(value);
+  return boxed === void 0 ? `a ${typeof value}` : `a ${boxed} object`;
+}
+function quoted2(value) {
+  if (typeof value === "function" || typeof value === "symbol") return void 0;
+  if (typeof value === "bigint") return `${value}n`;
+  if (typeof value === "number") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function printable(value) {
+  const isBoxed = boxedPrimitiveKind(value) !== void 0;
+  return quoted2(isBoxed ? unboxedPrimitive(value) : value);
+}
+function failShape(describedAs, value, isAtom) {
+  const printed = printable(value);
+  const shown = printed === void 0 ? "" : `: ${printed}`;
+  const advice = isAtom ? "Write an atom as { declarations: { ... } }." : "Write it as a plain object ({ ... }).";
+  refuse(describedAs, `is ${kindOf(value)}, not a plain object${shown}. ${advice}`);
+}
+function assertShape(value, describedAs) {
+  if (!value || isPlainObject(value)) return;
+  failShape(describedAs, value, false);
+}
+function assertDeclarationsSafe(declarations, where, p) {
+  assertShape(declarations, `${where}'s declarations`);
+  if (!isPlainObject(declarations)) return;
+  for (const [prop, value] of Object.entries(declarations)) {
+    const propRefusal = p.propRefusal(prop);
+    if (propRefusal) {
+      fail(`${where}'s declaration property "${prop}"`, propRefusal, prop, {
+        declarations: { [prop]: "0" },
+        kind: "declarations"
+      });
+    }
+    if (typeof value !== "string") continue;
+    const valueRefusal = p.declarationRefusal(prop, value);
+    if (valueRefusal) {
+      fail(`${where}'s declaration value for "${prop}"`, valueRefusal, value, {
+        declarations: { [prop]: value },
+        kind: "declarations"
+      });
+    }
+  }
+}
+function assertPseudosSafe(pseudos, where, p) {
+  assertShape(pseudos, `${where}'s pseudos`);
+  if (!isPlainObject(pseudos)) return;
+  for (const [pseudo, declarations] of Object.entries(pseudos)) {
+    const refusal = p.selectorRefusal(pseudo);
+    if (refusal) {
+      fail(`${where}'s pseudo "${pseudo}"`, refusal, pseudo, { key: pseudo, kind: "pseudo" });
+    }
+    assertDeclarationsSafe(declarations, `${where}'s pseudo "${pseudo}"`, p);
+  }
+}
+function assertAtBlocksSafe(blocks, atName, where, p) {
+  assertShape(blocks, `${where}'s ${atName} map`);
+  if (!isPlainObject(blocks)) return;
+  for (const [condition, block] of Object.entries(blocks)) {
+    const refusal = p.conditionRefusal(atName, condition);
+    if (refusal) {
+      fail(`${where}'s ${atName} condition "${condition}"`, refusal, condition, {
+        atName,
+        condition,
+        kind: "condition"
+      });
+    }
+    const blockWhere2 = `${where}'s ${atName} "${condition}"`;
+    assertShape(block, `${blockWhere2} block`);
+    if (!isPlainObject(block)) continue;
+    assertDeclarationsSafe(block.declarations, blockWhere2, p);
+    assertPseudosSafe(block.pseudos, blockWhere2, p);
+  }
+}
+function walkExtendAtoms(extend, predicates) {
+  for (const [name, atom] of Object.entries(extend)) {
+    if (!atom) continue;
+    const where = `atom "${name}"`;
+    if (!isPlainObject(atom)) failShape(where, atom, true);
+    assertDeclarationsSafe(atom.declarations, where, predicates);
+    assertPseudosSafe(atom.pseudos, where, predicates);
+    assertAtBlocksSafe(atom.media, "media", where, predicates);
+    assertAtBlocksSafe(atom.container, "container", where, predicates);
+  }
+}
+
+export { DirectiveFailure, WORKAROUND_GROUP_AT_RULE_NAMES, anchorSelectorList, expandText, foldLocated, hasBrokenString, hasEscapedCommentOpener, hasEscapedWhitespace, hasHtmlBreakout, hasPaddedComment, hasStrayCurlyCloser, hasTopLevelColon, hasTopLevelComment, hasUnstrippedLeadingSpace, hasUnstrippedTrailingSpace, hasUrl, isInert3 as isInert, isOnlyInert, lastNonWhitespace, plan, planRule, snapshotExtendMap, walkExtendAtoms };