@navecss/core 0.3.0 → 0.5.0

package/dist/postcss.js

@@ -1,15 +1,32 @@
+import { framedText } from './chunk-KKUYU75D.js';
 import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
-import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, formatDiagnostic, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-S7DZUVV3.js';
-import { tokenize } from './chunk-NFS2REPQ.js';
-import './chunk-LIUB4EES.js';
+import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, planRule, DirectiveFailure, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-MWHZ26S4.js';
+import './chunk-UVHGEVMV.js';
+import { formatDiagnostic } from './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
+import './chunk-GZL2VW7C.js';
 import postcss from 'postcss';
 
-// src/postcss-nested-builders.ts
-function isNestedNode(node) {
-  return node.type === "rule" || node.type === "atrule" && node.name.toLowerCase() !== "nave";
+// src/postcss-fold.ts
+function positionOf(entry, fallbackLine) {
+  if (!entry.atRule.source) return { column: 0, line: fallbackLine };
+  return entry.atRule.positionBy(entry.index === void 0 ? {} : { index: entry.index });
+}
+function sortFoldBySourceOrder(entries) {
+  return entries.map((entry, originalIndex) => ({ entry, originalIndex })).toSorted((a, b) => {
+    const pa = positionOf(a.entry, a.originalIndex);
+    const pb = positionOf(b.entry, b.originalIndex);
+    return pa.line - pb.line || pa.column - pb.column;
+  }).map(({ entry }) => entry);
 }
-function isFollowingNestedNode(rule, atRule) {
-  return rule.nodes.slice(0, rule.index(atRule)).some((node) => isNestedNode(node));
+function foldMessage(entries) {
+  return foldLocated(
+    entries.map((entry, i) => {
+      const position = positionOf(entry, i);
+      return { text: entry.text, line: position.line, column: position.column };
+    })
+  );
 }
 
 // src/postcss-node-utils.ts
@@ -41,6 +58,38 @@ function stampSource(node, source) {
     child.source = source;
   });
 }
+function writtenText(cleaned, raws) {
+  return raws?.value === cleaned ? raws.raw.trim() : cleaned;
+}
+
+// src/postcss-warn.ts
+function isTurbopack() {
+  return (process.env.TURBOPACK ?? "") !== "";
+}
+function framedAtNode(node, result, text, index) {
+  const input = node.source?.input;
+  if (input === void 0) return text;
+  const { line, column } = node.rangeBy(index === void 0 ? {} : { index }).start;
+  const origin = input.origin(line, column);
+  if (origin !== false)
+    return framedText(origin.file ?? origin.url, origin.line, origin.column, text);
+  return framedText(result.opts.from ?? input.file ?? input.id ?? "", line, column, text);
+}
+var ORDER_MARK = "naveOrderWarning";
+function isOrderWarning(warning) {
+  return warning[ORDER_MARK] === true;
+}
+function reportWarning(node, result, text, place = {}) {
+  const { index } = place;
+  if (place.printWarnings !== false && isTurbopack()) {
+    console.warn(framedAtNode(node, result, text, index));
+    return;
+  }
+  node.warn(result, text, {
+    ...index !== void 0 && { index },
+    ...place.isOrder === true && { [ORDER_MARK]: true }
+  });
+}
 
 // src/postcss-at-rule.ts
 function currentParams(atRule) {
@@ -51,10 +100,11 @@ function currentParams(atRule) {
 function matchNaveAtRule(atRule) {
   const afterName = atRule.raws.afterName ?? " ";
   const paramsRaw = currentParams(atRule);
+  const between = atRule.raws.between ?? "";
   const nameBoundary = 1 + atRule.name.length;
-  const full = `@${atRule.name}${afterName}${paramsRaw}`;
+  const full = `@${atRule.name}${afterName}${paramsRaw}${between}`;
   const token = tokenize(full)[0];
-  const commonPrelude = { prelude: paramsRaw, preludeStartIndex: nameBoundary + afterName.length };
+  const commonPrelude = { prelude: full.slice(nameBoundary), preludeStartIndex: nameBoundary };
   if (token?.type !== "at-keyword-token") return { isNave: false, ...commonPrelude };
   const isNave = (token.structured?.value).toLowerCase() === "nave";
   if (token.endIndex === nameBoundary) return { isNave, ...commonPrelude };
@@ -75,79 +125,239 @@ function reportDiagnostic(diagnostic, ctx, preludeStartIndex) {
   );
   const index = atRuleErrorIndex(preludeStartIndex, diagnostic);
   if (ctx.onUnknown === "warn") {
-    ctx.atRule.warn(ctx.result, text, index === void 0 ? {} : { index });
+    reportWarning(ctx.atRule, ctx.result, text, {
+      index,
+      printWarnings: ctx.printWarnings
+    });
     return;
   }
   if (ctx.onUnknown === "ignore") return;
   ctx.fold.push({ atRule: ctx.atRule, text, index });
 }
+function hasBlock(atRule) {
+  return atRule.nodes !== void 0;
+}
+function throwMalformedAtom(atRule, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  throw atRule.error(message);
+}
+function handleAtRule(atRule, ctx) {
+  const match = matchNaveAtRule(atRule);
+  if (!match.isNave) return;
+  const parent = atRule.parent;
+  if (parent?.type === "rule") return;
+  const fullCtx = { ...ctx, atRule };
+  const diagnostics = plan(
+    match.prelude,
+    {
+      isStyleRuleParent: false,
+      isInsideKeyframes: parent !== void 0 && isInsideKeyframes(parent)
+    },
+    { extend: ctx.extend }
+  ).diagnostics;
+  for (const diagnostic of diagnostics) {
+    reportDiagnostic(diagnostic, fullCtx, match.preludeStartIndex);
+  }
+  if (hasBlock(atRule)) {
+    reportDiagnostic(
+      { code: "has-block", offset: 0, endOffset: atRule.toString().length },
+      fullCtx,
+      match.preludeStartIndex
+    );
+  }
+  atRule.remove();
+}
 function declNode(atRule, decl) {
   const node = postcss.decl({ prop: decl.prop, value: decl.value });
   if (atRule.source) node.source = atRule.source;
   return node;
 }
-function insertDeclarations(atRule, declarations, isWrapped) {
-  if (declarations.length === 0) return;
-  if (!isWrapped) {
-    for (const decl of declarations) atRule.before(declNode(atRule, decl));
-    return;
-  }
-  const wrapper = postcss.rule({ selector: "&" });
-  if (atRule.source) wrapper.source = atRule.source;
-  for (const decl of declarations) wrapper.append(declNode(atRule, decl));
-  atRule.before(wrapper);
-}
 function buildRule(selector, declarations) {
   const rule = postcss.rule({ selector });
   for (const decl of declarations) rule.append(postcss.decl({ prop: decl.prop, value: decl.value }));
   return rule;
 }
-function buildAppendedNode(block) {
+function buildBlockNode(block) {
   if (block.kind === "pseudo") return buildRule(block.selector, block.declarations);
   const node = postcss.atRule({ name: block.kind, params: block.condition });
   if (block.declarations.length > 0) node.append(buildRule("&", block.declarations));
   for (const pseudo of block.pseudos) node.append(buildRule(pseudo.selector, pseudo.declarations));
   return node;
 }
-function throwMalformedAtom(atRule, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  throw atRule.error(message);
+function nodesOf(atRule, emission) {
+  if (emission.kind === "block") {
+    const node = buildBlockNode(emission.block);
+    stampSource(node, atRule.source);
+    return [node];
+  }
+  if (!emission.isWrapped) return emission.declarations.map((decl) => declNode(atRule, decl));
+  const wrapper = postcss.rule({ selector: "&" });
+  if (atRule.source) wrapper.source = atRule.source;
+  for (const decl of emission.declarations) wrapper.append(declNode(atRule, decl));
+  return [wrapper];
 }
-function planAtRule(atRule, extend, prelude) {
-  const parent = atRule.parent;
-  const isStyleRuleParent = parent?.type === "rule";
-  const isFollowingNestedNodeHere = isStyleRuleParent ? isFollowingNestedNode(parent, atRule) : false;
-  try {
+function insertBlock(atRule, node) {
+  const previous = atRule.prev();
+  atRule.before(node);
+  if (previous?.raws.before === void 0) delete node.raws.before;
+  else node.raws.before = previous.raws.before.replaceAll(/\S/g, "");
+}
+function insertEmissions(atRule, emissions) {
+  for (const emission of emissions) {
+    for (const node of nodesOf(atRule, emission)) {
+      if (emission.kind === "block") insertBlock(atRule, node);
+      else atRule.before(node);
+    }
+  }
+}
+function wrapRun(nodes, source) {
+  const wrapper = postcss.rule({ selector: "&" });
+  if (source) wrapper.source = source;
+  nodes[0].before(wrapper);
+  for (const node of nodes) wrapper.append(node);
+}
+
+// src/postcss-rule-nesting.ts
+function isRuleDirective(node) {
+  return node.type === "atrule" && node.parent?.type === "rule" && matchNaveAtRule(node).isNave;
+}
+function isOrHoldsRuleDirective(node) {
+  const stack = [node];
+  while (stack.length > 0) {
+    const next = stack.pop();
+    if (isRuleDirective(next)) return true;
+    if (next.type === "rule" || next.type === "atrule") stack.push(...next.nodes ?? []);
+  }
+  return false;
+}
+function isLastDirectiveUnder(root, atRule) {
+  let node = atRule;
+  for (; ; ) {
+    const parent = node.parent;
+    const later = (parent.nodes ?? []).slice(parent.index(node) + 1);
+    if (later.some((child) => isOrHoldsRuleDirective(child))) {
+      return false;
+    }
+    if (parent === root) return true;
+    node = parent;
+  }
+}
+function outermostRule(rule) {
+  let outer = rule;
+  let node = rule.parent;
+  while (node !== void 0 && node !== null) {
+    const container = node;
+    if (container.type === "rule") outer = node;
+    node = container.parent;
+  }
+  return outer;
+}
+function markAncestors(directive, root, marked) {
+  let up = directive.parent;
+  while (up !== void 0 && up !== null && !marked.has(up)) {
+    marked.add(up);
+    up = up === root ? void 0 : up.parent;
+  }
+}
+function rulesAboveDirectives(root) {
+  const marked = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (isRuleDirective(node)) markAncestors(node, root, marked);
+    if (node.type === "rule" || node.type === "atrule") stack.push(...node.nodes ?? []);
+  }
+  return marked;
+}
+
+// src/postcss-rule.ts
+var GROUP_NAMES = /* @__PURE__ */ new Set(["container", "media", "supports"]);
+function contentOf(container, table) {
+  let nodes;
+  return () => {
+    nodes ??= (container.nodes ?? []).map((child) => toModel(child, table));
+    return nodes;
+  };
+}
+function toModel(node, table) {
+  const ref = table.length;
+  table.push(node);
+  if (node.type === "decl") {
+    const raw = node.raws.value;
+    const value = raw?.value === node.value ? raw.raw : node.value;
+    return { kind: "decl", ref, prop: node.prop, value, important: node.important };
+  }
+  if (node.type === "comment") return { kind: "comment", ref };
+  if (node.type === "rule") {
+    const content2 = contentOf(node, table);
     return {
-      isStyleRuleParent,
-      parent,
-      result: plan(
-        prelude,
-        {
-          isStyleRuleParent,
-          isInsideKeyframes: parent !== void 0 && isInsideKeyframes(parent),
-          isFollowingNestedNode: isFollowingNestedNodeHere
-        },
-        { extend }
-      )
+      kind: "rule",
+      ref,
+      selector: writtenText(node.selector, node.raws.selector),
+      get nodes() {
+        return content2();
+      }
     };
-  } catch (error) {
-    return throwMalformedAtom(atRule, error);
   }
+  const match = matchNaveAtRule(node);
+  if (match.isNave) return { kind: "directive", ref, prelude: match.prelude };
+  const name = node.name.toLowerCase();
+  if (!GROUP_NAMES.has(name) || node.nodes === void 0) {
+    return { kind: "opaque", ref, name, prelude: writtenText(node.params, node.raws.params) };
+  }
+  const content = contentOf(node, table);
+  return {
+    kind: "group",
+    ref,
+    name,
+    prelude: writtenText(node.params, node.raws.params),
+    get nodes() {
+      return content();
+    }
+  };
 }
-function hasBlock(atRule) {
-  return atRule.nodes !== void 0;
+function readRule(rule) {
+  const table = [];
+  return { table, nodes: rule.nodes.map((child) => toModel(child, table)) };
 }
-function handleAtRule(atRule, ctx) {
+function pendingWarnings(warnings, table) {
+  return warnings.map(({ anchor, text }) => {
+    const node = table[anchor.ref];
+    if (anchor.offset === void 0) return { node, text, index: void 0 };
+    const { preludeStartIndex } = matchNaveAtRule(node);
+    return { node, text, index: preludeStartIndex + anchor.offset };
+  });
+}
+function placeOf(warning) {
+  if (warning.node.source === void 0) return [Number.MAX_SAFE_INTEGER, 0];
+  const { column, line } = warning.node.positionInside(warning.index ?? 0);
+  return [line, column];
+}
+function reportInSourceOrder(warnings, ctx) {
+  const placed = warnings.map((warning) => ({ warning, place: placeOf(warning) }));
+  const ordered = placed.toSorted((a, b) => a.place[0] - b.place[0] || a.place[1] - b.place[1]);
+  for (const { warning } of ordered) {
+    reportWarning(warning.node, ctx.result, warning.text, {
+      index: warning.index,
+      isOrder: true,
+      printWarnings: ctx.printWarnings
+    });
+  }
+}
+function applyItem(item, table, ctx) {
+  if (item.kind === "keep") return;
+  if (item.kind === "wrap") {
+    const source = table[item.after].source;
+    wrapRun(
+      item.refs.map((ref) => table[ref]),
+      source
+    );
+    return;
+  }
+  const atRule = table[item.ref];
   const match = matchNaveAtRule(atRule);
-  if (!match.isNave) return;
   const fullCtx = { ...ctx, atRule };
-  const {
-    isStyleRuleParent,
-    parent,
-    result: planResult
-  } = planAtRule(atRule, ctx.extend, match.prelude);
-  for (const diagnostic of planResult.diagnostics) {
+  for (const diagnostic of item.diagnostics) {
     reportDiagnostic(diagnostic, fullCtx, match.preludeStartIndex);
   }
   if (hasBlock(atRule)) {
@@ -157,36 +367,77 @@ function handleAtRule(atRule, ctx) {
       match.preludeStartIndex
     );
   }
-  insertDeclarations(atRule, planResult.declarations, planResult.wrapInAmpersand);
+  insertEmissions(atRule, item.emissions);
   atRule.remove();
-  if (isStyleRuleParent && parent) {
-    for (const block of planResult.blocks) {
-      const node = buildAppendedNode(block);
-      stampSource(node, atRule.source);
-      parent.append(node);
+}
+function planOrThrow(rule, read, ctx) {
+  try {
+    return planRule({
+      selector: rule.selector,
+      nodes: read.nodes,
+      isInsideKeyframes: isInsideKeyframes(rule),
+      extend: ctx.extend,
+      emittedCache: ctx.emittedCache,
+      outward: ctx.outward
+    });
+  } catch (error) {
+    if (error instanceof DirectiveFailure) {
+      return throwMalformedAtom(read.table[error.ref], error.cause);
     }
+    throw error;
   }
 }
-
-// src/postcss-fold.ts
-function positionOf(entry, fallbackLine) {
-  if (!entry.atRule.source) return { column: 0, line: fallbackLine };
-  return entry.atRule.positionBy(entry.index === void 0 ? {} : { index: entry.index });
-}
-function sortFoldBySourceOrder(entries) {
-  return entries.map((entry, originalIndex) => ({ entry, originalIndex })).toSorted((a, b) => {
-    const pa = positionOf(a.entry, a.originalIndex);
-    const pb = positionOf(b.entry, b.originalIndex);
-    return pa.line - pb.line || pa.column - pb.column;
-  }).map(({ entry }) => entry);
+function planTree(root, ctx) {
+  const emittedCache = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  const holders = rulesAboveDirectives(root);
+  const planned = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const container = stack.pop();
+    if (container.type === "rule" && holders.has(container)) {
+      const read = readRule(container);
+      const outward = { identityOf: (ref) => read.table[ref], known };
+      const plan2 = planOrThrow(container, read, { ...ctx, emittedCache, outward });
+      for (const finding of plan2.outwardFindings) {
+        const key = read.table[finding.unit.directive.ref];
+        known.set(key, [...known.get(key) ?? [], finding]);
+      }
+      planned.push({ table: read.table, plan: plan2 });
+    }
+    const inner = (container.nodes ?? []).filter(
+      (child) => child.type === "rule" || child.type === "atrule"
+    );
+    stack.push(...inner.toReversed());
+  }
+  return planned;
 }
-function foldMessage(entries) {
-  return foldLocated(
-    entries.map((entry, i) => {
-      const position = positionOf(entry, i);
-      return { text: entry.text, line: position.line, column: position.column };
-    })
+function handleRuleTree(root, ctx) {
+  const planned = planTree(root, ctx);
+  reportInSourceOrder(
+    planned.flatMap(({ plan: plan2, table }) => pendingWarnings(plan2.warnings, table)),
+    ctx
   );
+  for (const { plan: plan2, table } of planned) {
+    for (const item of plan2.items) applyItem(item, table, ctx);
+  }
+}
+function expandLeftovers(root, ctx) {
+  const outer = /* @__PURE__ */ new Set();
+  root.walkAtRules((atRule) => {
+    if (isRuleDirective(atRule)) outer.add(outermostRule(atRule.parent));
+  });
+  for (const rule of outer) handleRuleTree(rule, ctx);
+}
+function handleDirective(atRule, ctx) {
+  const parent = atRule.parent;
+  if (parent?.type !== "rule") {
+    handleAtRule(atRule, ctx);
+    return;
+  }
+  if (!matchNaveAtRule(atRule).isNave) return;
+  const root = outermostRule(parent);
+  if (isLastDirectiveUnder(root, atRule)) handleRuleTree(root, ctx);
 }
 function unescapeHtml(text) {
   return text.replaceAll(/\\3c (?=\/?style\b|!--)/gi, "<");
@@ -253,7 +504,7 @@ function validateExtendAtoms(extend) {
 
 // src/postcss.ts
 var navePlugin = (options = {}) => {
-  const { onUnknown = "error", extend: extendOption } = options;
+  const { onUnknown = "error", printWarnings = true, extend: extendOption } = options;
   const extendFile = typeof extendOption === "string" ? resolveExtendSpecifier(extendOption) : void 0;
   const staticExtend = typeof extendOption === "object" ? snapshotExtendMap(extendOption) : {};
   validateExtendAtoms(staticExtend);
@@ -285,9 +536,10 @@ var navePlugin = (options = {}) => {
           });
         },
         AtRule(atRule) {
-          handleAtRule(atRule, { onUnknown, result, extend, fold });
+          handleDirective(atRule, { onUnknown, printWarnings, result, extend, fold });
         },
-        OnceExit() {
+        OnceExit(root) {
+          expandLeftovers(root, { onUnknown, printWarnings, result, extend, fold });
           if (fold.length === 0) return;
           const ordered = sortFoldBySourceOrder(fold);
           const first = ordered[0];
@@ -303,4 +555,4 @@ var navePlugin = (options = {}) => {
 navePlugin.postcss = true;
 var postcss_default = navePlugin;
 
-export { postcss_default as default, navePlugin };
+export { postcss_default as default, isOrderWarning, navePlugin };

package/dist/standalone.css

@@ -475,6 +475,9 @@
     --nave-color-action-primary-active: light-dark(oklch(0.27 0.0398 186.17), oklch(0.94 0.0574 186.17));
     --nave-color-on-action-primary: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
     --nave-color-action-secondary: light-dark(oklch(from var(--nave-color-tint) 0.965 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.27 0.0067 h / 1));
+    --nave-color-action-secondary-hover: light-dark(oklch(from var(--nave-color-tint) 0.94 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.37 0.0067 h / 1));
+    --nave-color-action-secondary-active: light-dark(oklch(from var(--nave-color-tint) 0.905 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.225 0.0067 h / 1));
+    --nave-color-action-highlight: light-dark(oklch(from var(--nave-color-tint) 0.965 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.37 0.0067 h / 1));
     --nave-color-feedback-danger: light-dark(oklch(0.47 0.1455 15.02), oklch(0.835 0.0661 15.02));
     --nave-color-feedback-danger-foreground: light-dark(oklch(0.47 0.1455 15.02), oklch(0.835 0.0661 15.02));
     --nave-color-on-feedback-danger: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
@@ -488,6 +491,7 @@
     --nave-color-feedback-info: light-dark(oklch(from var(--nave-color-tint) 0.47 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.835 0.0067 h / 1));
     --nave-color-feedback-info-foreground: light-dark(oklch(from var(--nave-color-tint) 0.47 0.0067 h / 1), oklch(from var(--nave-color-tint) 0.835 0.0067 h / 1));
     --nave-color-on-feedback-info: light-dark(oklch(from var(--nave-color-tint) 1 0 h / 1), oklch(from var(--nave-color-tint) 0.18 0.0067 h / 1));
+    --nave-color-backdrop-modal: light-dark(oklch(from var(--nave-color-tint) 0.12 0.0067 h / 0.3), oklch(from var(--nave-color-tint) 0.12 0.0067 h / 0.6));
   }
 }
 

package/dist/vite-options-sOCeGn9B.d.ts

@@ -0,0 +1,87 @@
+import { A as AtomName } from './atom-names-B8Ud-7zD.js';
+
+/**
+ * The options that choose which atoms the Vite plugin ships, and their validation. A value a
+ * type would refuse in TypeScript is refused here too, so a JavaScript config gets the same
+ * answer; every text opens `navePlugin(): `, the prefix of the plugin's config-level messages.
+ */
+
+interface UsedAtomOptions {
+    /**
+     * Which atoms the build ships. `'used'` (the default): the atoms your `cx()` calls and your
+     * written Nave classes name, plus those in `keep` and `keepFor`. Under the default the build
+     * filters the atomic layer of every stylesheet it can reach, and the dev server serves the same
+     * set as far as it has read; a stylesheet imported with `?inline` or `?raw` ships every atom
+     * with a warning; a `cx()` call whose atoms the build cannot read fails the build, and is an
+     * error in the dev server. In a build, each `cx()` call the plugin read also becomes the class
+     * string it returns.
+     * `'all'`: every atom, and no `cx()` call is read or rewritten, as with the PostCSS plugin.
+     */
+    atomic?: 'all' | 'used';
+    /**
+     * Atoms always shipped, whether or not the build reads a use of them: every atom your own
+     * `cx.dynamic()` calls can take, and the atom of each Nave class written where the build cannot
+     * read it, such as in a server template or in CMS text.
+     */
+    keep?: readonly AtomName[];
+    /**
+     * By package name: the atoms a dependency's own `cx()` calls can produce, for a package whose
+     * calls the build cannot read. They ship as if they were in `keep`, beside the atoms of the
+     * package's calls the build does read. The calls it cannot read are not changed, so any other
+     * atom they apply has no rule unless the build ships it for another reason. An empty list is
+     * accepted: it says those calls produce no atom, so the list adds none, and a `cx.dynamic()` call
+     * in the package still fails the build, as it does with no entry. A package in your own workspace
+     * is your code, not a dependency. The entry stands in for the package's own calls only: a
+     * re-export of `cx` in the package that the build reads and a module of yours takes (imports,
+     * re-exports or reads off a namespace, directly or through re-exports of it that the build reads,
+     * as `export ... from` or an import exported unchanged, in this package or another) still fails
+     * the build, because the calls your module makes through it would ship with no rule, and the
+     * message says how to clear it. Listing here a package that only re-exports it does not clear a
+     * take of yours, since a re-export is not a call. A server build that leaves the package external
+     * does not read it, so a take only your server code makes is judged by what the client build
+     * read: it fails the build as above when the client build read the re-export it takes and the
+     * build can read the take, and gets a warning naming `ssr.noExternal` when the build cannot tell,
+     * because no environment read the file the server loads, or your file reaches the package in a
+     * way the build cannot read as a take (a `require()`, say, or a `#` import); with separate client
+     * and server commands, the next client command judges what the last build of each server recorded
+     * of server files that still exist.
+     */
+    keepFor?: Readonly<Record<string, readonly AtomName[]>>;
+    /**
+     * Modules that re-export `cx` from `@navecss/core/cx` unchanged, as
+     * `export { cx } from '@navecss/core/cx'`, in your code or in a dependency: a file that imports
+     * `cx` from one is read as if it imported it from `@navecss/core/cx`. The build follows a listed
+     * module one step. A relative entry (`'./src/ui/index.ts'`) is a path from Vite's `root`. A
+     * package name or subpath, an alias or an absolute path matches an import written the same way.
+     * A `#` entry matches an import written the same way only where that import resolves to a listed
+     * file, since a `#` import resolves through the `package.json` nearest the file that writes it.
+     * Every entry also matches an import that resolves to its file through a specifier naming that
+     * file or, for an `index` file, its directory; in your code, an import that reaches the file
+     * through any other specifier fails the build instead. A relative entry that resolves to no file
+     * is ignored, and so is an entry naming `@navecss/core/cx`, which the build always reads. The
+     * same setting, with the same entries, as `@navecss/eslint-plugin`'s `cxModules`, which reads a
+     * relative entry from the working directory instead of Vite's `root`.
+     */
+    cxModules?: readonly string[];
+}
+interface ResolvedUsedOptions {
+    readonly atomic: 'all' | 'used';
+    readonly keep: readonly string[];
+    readonly keepFor: Readonly<Record<string, readonly string[]>>;
+    readonly cxModules: readonly string[];
+}
+/**
+ * Throws the first problem in the options, if there is one.
+ */
+declare function assertOptions(options: UsedAtomOptions | ResolvedUsedOptions, own: ReadonlySet<string> | undefined): void;
+/**
+ * The options with their defaults filled in.
+ */
+declare function resolveUsedOptions(options: UsedAtomOptions): ResolvedUsedOptions;
+/**
+ * Every atom the options always ship: `keep` and every `keepFor` list.
+ */
+declare function keptAtoms(options: ResolvedUsedOptions): string[];
+
+export { assertOptions as a, keptAtoms as k, resolveUsedOptions as r };
+export type { ResolvedUsedOptions as R, UsedAtomOptions as U };