@navecss/core 0.3.0 → 0.5.0

package/dist/chunk-BCUK4M4P.js

@@ -0,0 +1,2765 @@
+import { decodeIncomingMap, MappingsBuilder, formatDiagnostic } from './chunk-SYNQJNVB.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
+import { atomClassMap } from './chunk-GZL2VW7C.js';
+
+// src/vite-ast.ts
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function nodeAt(node, key) {
+  const value = node[key];
+  return isNode(value) ? value : void 0;
+}
+function nodesAt(node, key) {
+  const value = node[key];
+  return Array.isArray(value) ? value.filter((item) => isNode(item)) : [];
+}
+function stringAt(node, key) {
+  const value = node[key];
+  return typeof value === "string" ? value : void 0;
+}
+function pushAll(target, items) {
+  for (const item of items) target.push(item);
+}
+var NO_KEYS = /* @__PURE__ */ new Set();
+function childrenOf(node, skipping = NO_KEYS) {
+  return Object.entries(node).flatMap(([key, value]) => {
+    if (skipping.has(key)) return [];
+    if (Array.isArray(value)) return value.filter((item) => isNode(item));
+    return isNode(value) ? [value] : [];
+  });
+}
+var ASSERTIONS = /* @__PURE__ */ new Set([
+  "TSAsExpression",
+  "TSNonNullExpression",
+  "TSSatisfiesExpression",
+  "TSTypeAssertion"
+]);
+function assertedBy(node) {
+  return ASSERTIONS.has(node.type) ? nodeAt(node, "expression") : void 0;
+}
+function wrappedBy(node) {
+  return node.type === "ParenthesizedExpression" ? nodeAt(node, "expression") : assertedBy(node);
+}
+function isTypeOnly(node) {
+  return node.importKind === "type" || node.exportKind === "type";
+}
+function valueSpecifiersOf(node) {
+  return nodesAt(node, "specifiers").filter((specifier) => !isTypeOnly(specifier));
+}
+function staticStringOf(node) {
+  if (!node) return void 0;
+  if (node.type === "Literal") {
+    return typeof node.value === "string" ? node.value : void 0;
+  }
+  if (node.type !== "TemplateLiteral" || nodesAt(node, "expressions").length > 0) return void 0;
+  const quasi = nodesAt(node, "quasis")[0];
+  const value = quasi?.value;
+  if (typeof value !== "object" || value === null) return void 0;
+  const cooked = value.cooked;
+  return typeof cooked === "string" ? cooked : void 0;
+}
+function exportNameOf(node) {
+  if (!node) return void 0;
+  return node.type === "Identifier" ? stringAt(node, "name") : staticStringOf(node);
+}
+function propertyNameOf(key, isComputed) {
+  if (!key) return void 0;
+  if (!isComputed && key.type === "Identifier") return stringAt(key, "name");
+  return staticStringOf(key);
+}
+
+// src/vite-assertion-text.ts
+function endOfComment(code, at) {
+  if (code.startsWith("/*", at)) {
+    const close = code.indexOf("*/", at + 2);
+    return close === -1 ? code.length : close + 2;
+  }
+  if (code.startsWith("//", at)) {
+    const newline = code.indexOf("\n", at);
+    return newline === -1 ? code.length : newline + 1;
+  }
+  return void 0;
+}
+function skipBlanks(code, from) {
+  let at = from;
+  for (; ; ) {
+    const commentEnd = endOfComment(code, at);
+    if (commentEnd !== void 0) at = commentEnd;
+    else if (/\s/.test(code.charAt(at))) at += 1;
+    else return at;
+  }
+}
+function skipClosings(code, from) {
+  let next = skipBlanks(code, from);
+  let closed = from;
+  while (code[next] === ")") {
+    closed = next + 1;
+    next = skipBlanks(code, closed);
+  }
+  return { next, closed };
+}
+function droppedPartOf(code, node, asserted) {
+  if (node.type !== "TSTypeAssertion") return [skipClosings(code, asserted.end).closed, node.end];
+  const type = nodeAt(node, "typeAnnotation");
+  if (!type) return [node.start, asserted.start];
+  return [node.start, skipClosings(code, type.end).next + 1];
+}
+function textWithoutAssertions(code, args) {
+  const dropped = [];
+  const stack = [...args];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const asserted = assertedBy(node);
+    if (asserted) dropped.push(droppedPartOf(code, node, asserted));
+    pushAll(stack, childrenOf(node));
+  }
+  dropped.sort(([first2], [second]) => first2 - second);
+  let text = "";
+  let from = args[0].start;
+  for (const [start, end] of dropped) {
+    text += code.slice(from, start);
+    from = end;
+  }
+  return text + code.slice(from, args.at(-1).end);
+}
+
+// src/vite-atom-check.ts
+function isBuiltInAtom(name) {
+  return Object.hasOwn(atomClassMap, name);
+}
+function hintFor(name) {
+  const text = formatDiagnostic({ code: "unknown-atom", name, offset: 0, endOffset: 0 });
+  const hint = text.slice(`@nave: unknown atom "${name}". `.length);
+  return hint.startsWith("Did you mean") ? hint : void 0;
+}
+function literal(text) {
+  return `'${text.replaceAll("\\", "\\\\").replaceAll("'", String.raw`\'`)}'`;
+}
+function whitespaceText(value) {
+  const names = value.split(/\s+/).filter(Boolean);
+  if (names.length < 2) {
+    return `"${value}" has whitespace around the atom name. Write it without: cx(${literal(names[0] ?? "")}).`;
+  }
+  const count = names.length === 2 ? "two" : String(names.length);
+  const call = names.map((name) => literal(name)).join(", ");
+  return `"${value}" is ${count} atom names in one string. Pass one per argument: cx(${call}).`;
+}
+function unknownText(name) {
+  return `unknown atom "${name}". cx() takes Nave atoms only; for a class of your own, use a CSS Module class or cx.raw(${literal(name)}).`;
+}
+function judgeAtom(value, own) {
+  if (/\s/.test(value)) return { kind: "whitespace", text: whitespaceText(value) };
+  if (isBuiltInAtom(value)) return { kind: "atom" };
+  if (own.has(value)) return { kind: "own" };
+  const hint = hintFor(value);
+  if (hint) return { kind: "unknown", text: `unknown atom "${value}". ${hint}`, hasHint: true };
+  return { kind: "unknown", text: unknownText(value), hasHint: false };
+}
+function availableLine() {
+  return `Available: ${Object.keys(atomClassMap).join(", ")}`;
+}
+
+// src/vite-setup-member.ts
+function setupMemberName(node) {
+  if (node.type !== "MemberExpression") return void 0;
+  const object = nodeAt(node, "object");
+  if (object?.type !== "Identifier" || stringAt(object, "name") !== "$setup") return void 0;
+  return propertyNameOf(nodeAt(node, "property"), node.computed === true);
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionDeclaration",
+  "FunctionExpression"
+]);
+function isOutsideFunctions(node, parentOf) {
+  for (let current = parentOf.get(node); current; current = parentOf.get(current)) {
+    if (FUNCTION_TYPES.has(current.type)) return false;
+  }
+  return true;
+}
+var SETUP_PARAMETER_POSITIONS = [3, 5];
+function isSetupParameter(analysis, identifier) {
+  const binding = analysis.referenceOf(identifier)?.binding;
+  const owner = binding?.owner;
+  if (!owner || binding.kind !== "param" || binding.name !== "$setup") return false;
+  if (!isOutsideFunctions(owner, analysis.parentOf)) return false;
+  const params = nodesAt(owner, "params");
+  return SETUP_PARAMETER_POSITIONS.some((position) => {
+    const parameter = params[position];
+    return parameter?.type === "Identifier" && stringAt(parameter, "name") === binding.name;
+  });
+}
+function isSetupMethod(setup, parentOf) {
+  const property = setup && parentOf.get(setup);
+  if (setup?.type !== "FunctionExpression" || property?.type !== "Property") return false;
+  return propertyNameOf(nodeAt(property, "key"), property.computed === true) === "setup";
+}
+function isSetupReturn(declarator, parentOf) {
+  if (declarator?.type !== "VariableDeclarator") return false;
+  if (stringAt(nodeAt(declarator, "id") ?? declarator, "name") !== "__returned__") return false;
+  const declaration = parentOf.get(declarator);
+  const block = declaration && parentOf.get(declaration);
+  return block?.type === "BlockStatement" && isSetupMethod(parentOf.get(block), parentOf);
+}
+function mergedExposures(linked, own) {
+  if (own.size === 0) return linked;
+  return new Map([...own, ...linked ?? []]);
+}
+
+// src/vite-cx-args.ts
+function literalValue(node) {
+  const value = node.value;
+  if (value === null && node.raw === "null") return [];
+  return value === false ? [] : void 0;
+}
+function unaryValue(node) {
+  const argument = nodeAt(node, "argument");
+  const isNumber = (value) => argument?.type === "Literal" && argument.value === value;
+  const isFalse = node.operator === "!" && isNumber(1);
+  const isUndefined = node.operator === "void" && isNumber(0);
+  return isFalse || isUndefined ? [] : void 0;
+}
+function soleInitialiserBinding(binding) {
+  const isPlain = binding && ["const", "let", "var"].includes(binding.kind);
+  return isPlain && binding.init && binding.writes === 0 ? binding : void 0;
+}
+function operandOf(node) {
+  if (node?.type !== "Literal") return void 0;
+  const { value } = node;
+  return { isFalsy: !value, isNullish: value === null };
+}
+function setupValue(node, context) {
+  const object = nodeAt(node, "object");
+  if (!object || !isSetupParameter(context.analysis, object)) return void 0;
+  const name = setupMemberName(node);
+  const exposure = name === void 0 ? void 0 : context.setup?.get(name);
+  if (exposure?.kind !== "values") return void 0;
+  return exposure.values.filter((value) => value !== "").map((value) => ({ value, node }));
+}
+var RESOLVED = /* @__PURE__ */ new WeakMap();
+function resolvedFor(analysis, setup) {
+  if (setup) return /* @__PURE__ */ new Map();
+  const found = RESOLVED.get(analysis) ?? /* @__PURE__ */ new Map();
+  RESOLVED.set(analysis, found);
+  return found;
+}
+function unionOf(parts) {
+  if (parts.includes(void 0)) return void 0;
+  const seen = /* @__PURE__ */ new Map();
+  const isNew = (possible) => {
+    const values = seen.get(possible.node) ?? /* @__PURE__ */ new Set();
+    seen.set(possible.node, values);
+    const before = values.size;
+    values.add(possible.value);
+    return values.size > before;
+  };
+  return parts.flatMap((part) => part.filter((possible) => isNew(possible)));
+}
+var first = (done) => done[0];
+var leaf = (result) => ({ deps: [], combine: () => result });
+function planOfName(node, context) {
+  const reference2 = context.analysis.referenceOf(node);
+  if (!reference2?.binding) return leaf(stringAt(node, "name") === "undefined" ? [] : void 0);
+  const binding = soleInitialiserBinding(reference2.binding);
+  if (!binding) return leaf(void 0);
+  if (context.resolved.has(binding)) return leaf(context.resolved.get(binding));
+  if (context.resolving.has(binding)) return leaf(void 0);
+  context.resolving.add(binding);
+  return {
+    deps: [binding.init],
+    combine: first,
+    finish(result) {
+      context.resolving.delete(binding);
+      context.resolved.set(binding, result);
+    }
+  };
+}
+function operandsRead(node) {
+  const left = nodeAt(node, "left");
+  const right = nodeAt(node, "right");
+  const operand = operandOf(left);
+  if (node.operator === "&&") return operand?.isFalsy ? [] : [right];
+  const isDecided = node.operator === "||" ? operand?.isFalsy : operand?.isNullish;
+  return isDecided === false ? [left] : [left, right];
+}
+function planOfLogical(node) {
+  const read = operandsRead(node);
+  if (read.length === 0) return leaf([]);
+  return { deps: read, combine: read.length === 1 ? first : unionOf };
+}
+function planOf(node, context) {
+  const text = staticStringOf(node);
+  if (text !== void 0) return leaf(text === "" ? [] : [{ value: text, node }]);
+  const inner = wrappedBy(node);
+  if (inner) return { deps: [inner], combine: first };
+  switch (node.type) {
+    case "ConditionalExpression": {
+      return {
+        deps: [nodeAt(node, "consequent"), nodeAt(node, "alternate")],
+        combine: unionOf
+      };
+    }
+    case "Identifier": {
+      return planOfName(node, context);
+    }
+    case "Literal": {
+      return leaf(literalValue(node));
+    }
+    case "LogicalExpression": {
+      return planOfLogical(node);
+    }
+    case "MemberExpression": {
+      return leaf(setupValue(node, context));
+    }
+    case "UnaryExpression": {
+      return leaf(unaryValue(node));
+    }
+    default: {
+      return leaf(void 0);
+    }
+  }
+}
+function possibles(root, context) {
+  if (!root) return void 0;
+  const stack = [{ plan: planOf(root, context), done: [] }];
+  let result;
+  while (stack.length > 0) {
+    const top = stack.at(-1);
+    const next = top.plan.deps[top.done.length];
+    if (top.done.length < top.plan.deps.length) {
+      if (next) stack.push({ plan: planOf(next, context), done: [] });
+      else top.done.push(void 0);
+      continue;
+    }
+    result = top.plan.combine(top.done);
+    top.plan.finish?.(result);
+    stack.pop();
+    stack.at(-1)?.done.push(result);
+  }
+  return result;
+}
+function isFilteredOut(node, analysis) {
+  switch (node.type) {
+    case "Identifier": {
+      return stringAt(node, "name") === "undefined" && !analysis.referenceOf(node)?.binding;
+    }
+    case "Literal": {
+      return literalValue(node) !== void 0;
+    }
+    case "UnaryExpression": {
+      return unaryValue(node) !== void 0;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+function constantOf(node, analysis) {
+  const text = staticStringOf(node);
+  if (text !== void 0) return text;
+  return isFilteredOut(node, analysis) ? "" : void 0;
+}
+function resolveArgument(node, analysis, setup) {
+  const resolved = resolvedFor(analysis, setup);
+  return possibles(node, { analysis, resolving: /* @__PURE__ */ new Set(), resolved, setup });
+}
+
+// src/vite-cx-bindings.ts
+function cxBindingsOf(analysis, sources) {
+  const found = /* @__PURE__ */ new Map();
+  for (const { binding } of analysis.references) {
+    if (binding?.kind !== "import" || !binding.source || !sources.has(binding.source)) continue;
+    if (binding.imported === "cx") found.set(binding, { binding, isNamespace: false });
+    else if (binding.imported === "*") found.set(binding, { binding, isNamespace: true });
+  }
+  return found;
+}
+function isImportingCx(program, sources) {
+  return nodesAt(program, "body").some((node) => {
+    const source = staticStringOf(nodeAt(node, "source"));
+    const isImport = node.type === "ImportDeclaration" && !isTypeOnly(node);
+    return isImport && source !== void 0 && sources.has(source);
+  });
+}
+
+// src/vite-cx-refuse.ts
+function textOf(reading, node) {
+  return reading.code.slice(node.start, node.end);
+}
+function calleeName(reading, call) {
+  const callee = nodeAt(call, "callee");
+  if (!callee) return "a function";
+  if (callee.type === "Identifier") return stringAt(callee, "name") ?? "a function";
+  const isPlainMember = callee.type === "MemberExpression" && callee.computed !== true;
+  const property = isPlainMember ? nodeAt(callee, "property") : void 0;
+  return stringAt(property ?? callee, "name") ?? textOf(reading, callee);
+}
+var assignedTo = (reading, parent, local) => {
+  const target = nodeAt(parent, "id") ?? nodeAt(parent, "left") ?? parent;
+  return `${local} is assigned to ${textOf(reading, target)}`;
+};
+var reexported = (reading, parent, local) => `${textOf(reading, parent)}: a re-export of ${local}, which the build follows only from a module listed in cxModules`;
+var PHRASES = {
+  VariableDeclarator: assignedTo,
+  AssignmentExpression: assignedTo,
+  CallExpression: (reading, parent, local) => `${local} is passed to ${calleeName(reading, parent)}() as a value instead of being called`,
+  SpreadElement: (_reading, _parent, local) => `${local} is spread`,
+  ExportSpecifier: reexported,
+  ExportDefaultDeclaration: reexported
+};
+function isWrittenTo(parent, expression) {
+  return parent.type === "AssignmentExpression" && nodeAt(parent, "right") !== expression;
+}
+function phraseFor(reading, expression, local) {
+  const parent = reading.analysis.parentOf.get(expression);
+  const phrase = parent && !isWrittenTo(parent, expression) && PHRASES[parent.type];
+  return phrase && parent ? phrase(reading, parent, local) : `${local} is used as a value instead of being called`;
+}
+function isReexportOf(reading, expression) {
+  const parent = reading.analysis.parentOf.get(expression);
+  return parent?.type === "ExportSpecifier" || parent?.type === "ExportDefaultDeclaration";
+}
+function reexportNameOf(reading, expression) {
+  const parent = reading.analysis.parentOf.get(expression);
+  if (parent?.type === "ExportDefaultDeclaration") return "default";
+  return parent?.type === "ExportSpecifier" ? exportNameOf(nodeAt(parent, "exported")) : void 0;
+}
+function isRenamedReexportOf(reading, expression) {
+  const parent = reading.analysis.parentOf.get(expression);
+  if (parent?.type === "ExportDefaultDeclaration") return true;
+  return parent?.type === "ExportSpecifier" && exportNameOf(nodeAt(parent, "exported")) !== "cx";
+}
+
+// src/vite-cx-reference.ts
+function isCallee(parent, node) {
+  return parent?.type === "CallExpression" && nodeAt(parent, "callee") === node;
+}
+function isOnlyRaw(pattern) {
+  const properties = nodesAt(pattern, "properties");
+  const only = properties[0];
+  if (properties.length !== 1 || only?.type !== "Property") return false;
+  const name = propertyNameOf(nodeAt(only, "key"), only.computed === true);
+  return name === "raw" && nodeAt(only, "value")?.type === "Identifier";
+}
+function refused(node, local, phrase) {
+  return { kind: "refused", node, local, phrase };
+}
+function rawMemberUse(parent, member, local) {
+  const isAlias = parent?.type === "VariableDeclarator" && nodeAt(parent, "init") === member && nodeAt(parent, "id")?.type === "Identifier";
+  if (isAlias || isCallee(parent, member)) return { kind: "raw", node: member, local };
+  return refused(member, local, `${local}.raw is used other than by calling it`);
+}
+function memberUse(reading, member, local) {
+  const parent = reading.analysis.parentOf.get(member);
+  const isComputed = member.computed === true;
+  const name = propertyNameOf(nodeAt(member, "property"), isComputed);
+  if (name === "raw") return rawMemberUse(parent, member, local);
+  if (name === "dynamic" && !isComputed) {
+    if (parent && isCallee(parent, member)) return { kind: "dynamic", node: parent, local };
+    return refused(member, local, `${local}.dynamic is referenced other than by a direct call`);
+  }
+  if (name === "call" || name === "apply") {
+    return refused(member, local, `${local} is called through .${name}()`);
+  }
+  if (isComputed) return refused(member, local, `${local} is read with a computed member`);
+  return refused(member, local, `${local}.${name ?? "?"} is not a member the build reads`);
+}
+function isVueUnref(reading, callee) {
+  if (callee?.type !== "Identifier") return false;
+  const binding = reading.analysis.referenceOf(callee)?.binding;
+  return binding?.kind === "import" && binding.source === "vue" && binding.imported === "unref";
+}
+function throughUnref(reading, expression) {
+  let current = expression;
+  for (; ; ) {
+    const call = reading.analysis.parentOf.get(current);
+    const args = call ? nodesAt(call, "arguments") : [];
+    const isUnref = call?.type === "CallExpression" && args.length === 1 && args[0] === current && isVueUnref(reading, nodeAt(call, "callee"));
+    if (!isUnref) return current;
+    current = call;
+  }
+}
+function ancestor(reading, node, levels) {
+  let current = node;
+  for (let level = 0; current && level < levels; level += 1) {
+    current = reading.analysis.parentOf.get(current);
+  }
+  return current;
+}
+function exposureName(reading, expression) {
+  if (reading.allowsExposure !== true) return void 0;
+  const getter = ancestor(reading, expression, 4);
+  const isGetter = getter?.type === "Property" && getter.kind === "get";
+  const isReturn = ancestor(reading, expression, 1)?.type === "ReturnStatement";
+  if (!isGetter || !isReturn || !isSetupReturn(ancestor(reading, expression, 6), reading.analysis.parentOf))
+    return void 0;
+  return propertyNameOf(nodeAt(getter, "key"), getter.computed === true);
+}
+function rawDestructuring(parent, expression, local) {
+  if (parent.type !== "VariableDeclarator" || nodeAt(parent, "init") !== expression)
+    return void 0;
+  const id = nodeAt(parent, "id");
+  if (id?.type !== "ObjectPattern" || !isOnlyRaw(id)) return void 0;
+  return { kind: "raw", node: id, local };
+}
+function readableUse(reading, expression, local) {
+  const parent = reading.analysis.parentOf.get(expression);
+  if (!parent) return void 0;
+  if (isCallee(parent, expression)) return { kind: "call", node: parent, local };
+  if (parent.type === "MemberExpression" && nodeAt(parent, "object") === expression) {
+    return memberUse(reading, parent, local);
+  }
+  return rawDestructuring(parent, expression, local);
+}
+function useOfExpression(reading, start, local) {
+  const expression = throughUnref(reading, start);
+  const readable = readableUse(reading, expression, local);
+  if (readable) return readable;
+  const exposedAs = exposureName(reading, expression);
+  if (exposedAs !== void 0) return { kind: "exposure", node: expression, local, exposedAs };
+  const phrase = phraseFor(reading, expression, local);
+  const isReexport = isReexportOf(reading, expression);
+  const isRenamed = isReexport && isRenamedReexportOf(reading, expression);
+  const exportedAs = reexportedAs(reading, expression);
+  return {
+    ...refused(expression, local, phrase),
+    isReexport,
+    ...isRenamed && { isRenamed },
+    ...exportedAs
+  };
+}
+function reexportedAs(reading, expression) {
+  const name = reexportNameOf(reading, expression);
+  return name === void 0 ? void 0 : { exportedAs: [name] };
+}
+function isOtherKey(property) {
+  if (property.type !== "Property") return false;
+  const name = propertyNameOf(nodeAt(property, "key"), property.computed === true);
+  return name !== void 0 && name !== "cx";
+}
+function isPatternAssignment(reading, node) {
+  if (node?.type === "AssignmentPattern") return true;
+  return node?.type === "AssignmentExpression" && node.operator === "=" && reading.analysis.parentOf.get(node)?.type === "ExpressionStatement";
+}
+function patternDestructuring(reading, expression) {
+  const parent = reading.analysis.parentOf.get(expression);
+  if (parent?.type === "VariableDeclarator" && nodeAt(parent, "init") === expression) {
+    return nodeAt(parent, "id");
+  }
+  return isPatternAssignment(reading, parent) && nodeAt(parent, "right") === expression ? nodeAt(parent, "left") : void 0;
+}
+function isOtherKeysDestructuring(reading, expression) {
+  const pattern = patternDestructuring(reading, expression);
+  return pattern?.type === "ObjectPattern" && nodesAt(pattern, "properties").every((p) => isOtherKey(p));
+}
+function memberReadOf(reading, expression) {
+  const member = reading.analysis.parentOf.get(expression);
+  if (member?.type !== "MemberExpression" || nodeAt(member, "object") !== expression) {
+    return void 0;
+  }
+  return { member, key: propertyNameOf(nodeAt(member, "property"), member.computed === true) };
+}
+function namespaceUse(reading, expression, cx) {
+  const local = cx.binding.name;
+  const read = memberReadOf(reading, expression);
+  if (read?.key === "cx") return useOfExpression(reading, read.member, `${local}.cx`);
+  const isListed = reading.declaredSources?.has(cx.binding.source ?? "") === true;
+  const isOtherExport = read ? read.key !== void 0 : isOtherKeysDestructuring(reading, expression);
+  if (isListed && isOtherExport) return void 0;
+  const use = refused(expression, local, `${local} is used other than as ${local}.cx`);
+  const exportedAs = reexportedAs(reading, expression);
+  return exportedAs ? { ...use, ...exportedAs, isRenamed: true } : use;
+}
+function useOf(reading, reference2, cx) {
+  if (cx.isNamespace) return namespaceUse(reading, reference2.node, cx);
+  const local = cx.binding.name;
+  const use = useOfExpression(reading, reference2.node, local);
+  if (!use.isReexport) return use;
+  const isDeclaredSource = reading.declaredSources?.has(cx.binding.source ?? "") === true;
+  return { ...use, isListable: !isDeclaredSource };
+}
+
+// src/vite-cx-source-forms.ts
+var REEXPORT_TEXT = "a re-export of cx, which the build follows only from a module listed in cxModules.";
+var SECOND_HOP_TEXT = "a re-export of the cx of a module listed in cxModules, which the build follows one step only.";
+var DYNAMIC_IMPORT_TEXT = "a dynamic import of cx, which the build cannot follow. Import it at the top of the module.";
+function isExportingCx(node) {
+  if (node.type === "ExportAllDeclaration") return true;
+  return valueSpecifiersOf(node).some((specifier) => {
+    const local = nodeAt(specifier, "local");
+    return (local?.type === "Identifier" ? stringAt(local, "name") : staticStringOf(local)) === "cx";
+  });
+}
+function isExportingRenamed(node) {
+  if (node.type === "ExportAllDeclaration") return nodeAt(node, "exported") !== void 0;
+  return valueSpecifiersOf(node).some(
+    (specifier) => exportNameOf(nodeAt(specifier, "local")) === "cx" && exportNameOf(nodeAt(specifier, "exported")) !== "cx"
+  );
+}
+function exportedNamesOf(node) {
+  if (node.type === "ExportAllDeclaration") {
+    return [exportNameOf(nodeAt(node, "exported")) ?? "cx"];
+  }
+  return valueSpecifiersOf(node).filter((specifier) => exportNameOf(nodeAt(specifier, "local")) === "cx").flatMap((specifier) => exportNameOf(nodeAt(specifier, "exported")) ?? []);
+}
+function reexportProblem(code, node, isListed) {
+  if (isListed && !isExportingCx(node)) return void 0;
+  return {
+    kind: "reexport",
+    offset: node.start,
+    construct: code.slice(node.start, node.end),
+    text: isListed ? SECOND_HOP_TEXT : REEXPORT_TEXT,
+    isListable: !isListed,
+    ...!isListed && isExportingRenamed(node) && { isRenamed: true },
+    exportedAs: exportedNamesOf(node)
+  };
+}
+function sourceFormProblem(code, node, options) {
+  const source = staticStringOf(nodeAt(node, "source"));
+  if (source === void 0 || !options.cxSources.has(source)) return void 0;
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+    if (isTypeOnly(node) || options.isDeclared === true) return void 0;
+    return reexportProblem(code, node, options.declaredSources?.has(source) === true);
+  }
+  if (node.type !== "ImportExpression") return void 0;
+  const construct = code.slice(node.start, node.end);
+  return { kind: "reference", offset: node.start, construct, text: DYNAMIC_IMPORT_TEXT };
+}
+function sourceFormProblems(code, program, options) {
+  const problems = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const problem2 = sourceFormProblem(code, node, options);
+    if (problem2) problems.push(problem2);
+    pushAll(stack, childrenOf(node));
+  }
+  return problems;
+}
+
+// src/vite-declared-exports.ts
+var DECLARED_TEXT = "listed in cxModules, but this export can give it a cx the build does not follow: the build follows a listed module one step, to Nave's cx re-exported from @navecss/core/cx under the name cx.";
+function innerPatterns(pattern) {
+  switch (pattern.type) {
+    case "ArrayPattern": {
+      return nodesAt(pattern, "elements");
+    }
+    case "AssignmentPattern": {
+      return [nodeAt(pattern, "left")].filter((inner) => inner !== void 0);
+    }
+    case "ObjectPattern": {
+      return nodesAt(pattern, "properties").flatMap(
+        (property) => [nodeAt(property, property.type === "Property" ? "value" : "argument")].filter(
+          (inner) => inner !== void 0
+        )
+      );
+    }
+    case "RestElement": {
+      return [nodeAt(pattern, "argument")].filter((inner) => inner !== void 0);
+    }
+    default: {
+      return [];
+    }
+  }
+}
+function patternNames(pattern) {
+  const names = [];
+  const stack = pattern ? [pattern] : [];
+  while (stack.length > 0) {
+    const next = stack.pop();
+    if (next.type === "Identifier") names.push(stringAt(next, "name") ?? "");
+    pushAll(stack, innerPatterns(next));
+  }
+  return names;
+}
+function declaredNames(declaration) {
+  if (declaration.type !== "VariableDeclaration") {
+    return patternNames(nodeAt(declaration, "id"));
+  }
+  return nodesAt(declaration, "declarations").flatMap(
+    (declarator) => patternNames(nodeAt(declarator, "id"))
+  );
+}
+function problem(node) {
+  return { kind: "declared", offset: node.start, construct: "", text: DECLARED_TEXT };
+}
+function isPlainReExport(local, exported) {
+  return local === "cx" && exported === "cx";
+}
+function fromSourceProblems(node, source, input) {
+  const isNave = input.cxSources.has(source) && !input.declaredSources.has(source);
+  const isListed = input.declaredSources.has(source);
+  const isBad = valueSpecifiersOf(node).some((specifier) => {
+    const local = exportNameOf(nodeAt(specifier, "local"));
+    const exported = exportNameOf(nodeAt(specifier, "exported"));
+    if (isNave) return !isPlainReExport(local, exported);
+    return exported === "cx" || isListed && local === "cx";
+  });
+  return isBad ? [problem(node)] : [];
+}
+function localProblems(node, input) {
+  const isBad = valueSpecifiersOf(node).some((specifier) => {
+    const local = nodeAt(specifier, "local");
+    const binding = local && input.analysis.referenceOf(local)?.binding;
+    const cx = binding ? input.bindings.get(binding) : void 0;
+    if (exportNameOf(nodeAt(specifier, "exported")) !== "cx") return cx !== void 0;
+    const isNaves = cx !== void 0 && !cx.isNamespace && !input.declaredSources.has(binding?.source ?? "");
+    return !isNaves;
+  });
+  return isBad ? [problem(node)] : [];
+}
+function namedExportProblems(node, input) {
+  const declaration = nodeAt(node, "declaration");
+  if (declaration) return declaredNames(declaration).includes("cx") ? [problem(node)] : [];
+  const source = staticStringOf(nodeAt(node, "source"));
+  return source === void 0 ? localProblems(node, input) : fromSourceProblems(node, source, input);
+}
+function starExportProblems(node, input, hasNaveCx) {
+  const source = staticStringOf(nodeAt(node, "source"));
+  if (source === void 0) return [];
+  const exported = nodeAt(node, "exported");
+  if (!input.cxSources.has(source)) {
+    return exportNameOf(exported) === "cx" ? [problem(node)] : [];
+  }
+  if (exported !== void 0) return [problem(node)];
+  return !hasNaveCx && input.declaredSources.has(source) ? [problem(node)] : [];
+}
+function isNaveSource(source, input) {
+  return source !== void 0 && input.cxSources.has(source) && !input.declaredSources.has(source);
+}
+function isNaveLocalExport(local, exported, input) {
+  const binding = local && input.analysis.referenceOf(local)?.binding;
+  const cx = binding ? input.bindings.get(binding) : void 0;
+  const isListed = input.declaredSources.has(binding?.source ?? "");
+  return exported === "cx" && cx !== void 0 && !cx.isNamespace && !isListed;
+}
+function isNaveSpecifier(specifier, source, input) {
+  const local = nodeAt(specifier, "local");
+  const exported = exportNameOf(nodeAt(specifier, "exported"));
+  if (source === void 0) return isNaveLocalExport(local, exported, input);
+  return isNaveSource(source, input) && isPlainReExport(exportNameOf(local), exported);
+}
+function isNaveCxExport(node, input) {
+  const source = staticStringOf(nodeAt(node, "source"));
+  if (node.type === "ExportAllDeclaration") {
+    return isNaveSource(source, input) && nodeAt(node, "exported") === void 0;
+  }
+  if (node.type !== "ExportNamedDeclaration" || nodeAt(node, "declaration")) return false;
+  return valueSpecifiersOf(node).some((specifier) => isNaveSpecifier(specifier, source, input));
+}
+function unfollowedStarProblems(body, input) {
+  if (body.some((node) => isNaveCxExport(node, input))) return [];
+  const star = body.find((node) => {
+    const source = staticStringOf(nodeAt(node, "source"));
+    const isPlainStar = node.type === "ExportAllDeclaration" && nodeAt(node, "exported") === void 0;
+    return isPlainStar && source !== void 0 && !input.cxSources.has(source);
+  });
+  return star ? [problem(star)] : [];
+}
+function defaultExportProblems(node, input) {
+  const declaration = nodeAt(node, "declaration");
+  const binding = declaration && input.analysis.referenceOf(declaration)?.binding;
+  return binding && input.bindings.has(binding) ? [problem(node)] : [];
+}
+var EXPORT_PROBLEMS = {
+  ExportDefaultDeclaration: defaultExportProblems,
+  ExportNamedDeclaration: namedExportProblems
+};
+function declaredExportProblems(input) {
+  const body = nodesAt(input.program, "body").filter((node) => !isTypeOnly(node));
+  const hasNaveCx = body.some((node) => isNaveCxExport(node, input));
+  const problems = [
+    ...body.flatMap(
+      (node) => node.type === "ExportAllDeclaration" ? starExportProblems(node, input, hasNaveCx) : EXPORT_PROBLEMS[node.type]?.(node, input) ?? []
+    ),
+    ...unfollowedStarProblems(body, input)
+  ];
+  return hasNaveCx ? problems.map((found) => ({ ...found, hasNaveCx })) : problems;
+}
+
+// src/vite-class-pieces.ts
+function isIdentChar(char) {
+  if (char === void 0) return false;
+  return /[\w-]/.test(char) || char.codePointAt(0) >= 128;
+}
+function pieceOfText(node, text) {
+  let start = text.length;
+  while (start > 0 && isIdentChar(text[start - 1])) start -= 1;
+  return { node, head: text.slice(start, start + 5), isOpen: start === 0 };
+}
+function leafPiece(node) {
+  const asserted = assertedBy(node);
+  if (asserted) {
+    const piece = leafPiece(asserted);
+    return piece && { ...piece, node };
+  }
+  const whole = staticStringOf(node);
+  if (whole !== void 0) return pieceOfText(node, whole);
+  if (node.type !== "TemplateLiteral") return void 0;
+  const cooked = nodesAt(node, "quasis").at(-1)?.value?.cooked;
+  return cooked === void 0 ? void 0 : pieceOfText(node, cooked);
+}
+function isPlus(node) {
+  return node?.type === "BinaryExpression" && node.operator === "+";
+}
+function edgePiece(start, memo) {
+  const path = [];
+  let node = start;
+  while (isPlus(node) && !memo.edges.has(node)) {
+    path.push(node);
+    node = nodeAt(node, "right");
+  }
+  let found;
+  if (node !== void 0) found = memo.edges.has(node) ? memo.edges.get(node) : leafPiece(node);
+  for (const visited of path) memo.edges.set(visited, found);
+  return found;
+}
+function joinPieces(before, last) {
+  if (!last.isOpen) return { node: before.node, head: last.head, isOpen: false };
+  return {
+    node: before.node,
+    head: (before.head + last.head).slice(0, 5),
+    isOpen: before.isOpen
+  };
+}
+function pieceOfPlus(link, before, last) {
+  if (last === void 0) return void 0;
+  const isAdjacent = before !== void 0 && nodeAt(link, "right") === last.node;
+  return isAdjacent ? joinPieces(before, last) : last;
+}
+function rightmostPiece(start, memo) {
+  const spine = [];
+  let node = start;
+  while (isPlus(node) && !memo.rightmost.has(node)) {
+    spine.push(node);
+    node = nodeAt(node, "left");
+  }
+  let before;
+  if (node !== void 0) {
+    before = memo.rightmost.has(node) ? memo.rightmost.get(node) : edgePiece(node, memo);
+  }
+  for (const link of spine.toReversed()) {
+    before = pieceOfPlus(link, before, edgePiece(link, memo));
+    memo.rightmost.set(link, before);
+  }
+  return before;
+}
+
+// src/vite-string-values.ts
+var none = () => [];
+var leaf2 = (values) => ({ deps: none, combine: () => values });
+function unionOf2(parts) {
+  if (parts.includes(void 0)) return void 0;
+  return [...new Set(parts.flat())];
+}
+function planOfFallback(node) {
+  const left = nodeAt(node, "left");
+  const right = nodeAt(node, "right");
+  const isOr = node.operator === "||";
+  return {
+    deps: (done) => {
+      if (done.length === 0) return [left];
+      const known = done[0];
+      return known && isOr && known.includes("") ? [left, right] : [left];
+    },
+    combine: (done) => {
+      const [known, other] = done;
+      if (!known || !isOr || !known.includes("")) return known;
+      return other && unionOf2([known.filter((value) => value !== ""), other]);
+    }
+  };
+}
+function planOfName2(node, analysis) {
+  const init = soleInitialiserBinding(analysis.referenceOf(node)?.binding)?.init;
+  if (!init) return leaf2(void 0);
+  return { deps: () => [init], combine: ([only]) => only };
+}
+function planOf2(node, analysis) {
+  const text = staticStringOf(node);
+  if (text !== void 0) return leaf2([text]);
+  const inner = wrappedBy(node);
+  if (inner) return { deps: () => [inner], combine: ([only]) => only };
+  switch (node.type) {
+    case "ConditionalExpression": {
+      const parts = [nodeAt(node, "consequent"), nodeAt(node, "alternate")];
+      return { deps: () => parts, combine: unionOf2 };
+    }
+    case "Identifier": {
+      return planOfName2(node, analysis);
+    }
+    case "LogicalExpression": {
+      return node.operator === "&&" ? leaf2(void 0) : planOfFallback(node);
+    }
+    default: {
+      return leaf2(void 0);
+    }
+  }
+}
+function stringValues(root, analysis) {
+  if (!root) return void 0;
+  const memo = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Set([root]);
+  const stack = [{ node: root, plan: planOf2(root, analysis), done: [] }];
+  let result;
+  while (stack.length > 0) {
+    const top = stack.at(-1);
+    const deps = top.plan.deps(top.done);
+    if (top.done.length < deps.length) {
+      const child = deps[top.done.length];
+      if (!child) top.done.push(void 0);
+      else if (memo.has(child)) top.done.push(memo.get(child));
+      else if (active.has(child)) top.done.push(void 0);
+      else {
+        active.add(child);
+        stack.push({ node: child, plan: planOf2(child, analysis), done: [] });
+      }
+      continue;
+    }
+    result = top.plan.combine(top.done);
+    memo.set(top.node, result);
+    active.delete(top.node);
+    stack.pop();
+    stack.at(-1)?.done.push(result);
+  }
+  return result;
+}
+
+// src/vite-class-endings.ts
+function isEndingValue(value) {
+  return !(isIdentChar(value[0]) || value.startsWith("\\"));
+}
+function operandsOf(element) {
+  if (typeof element === "string") return void 0;
+  const inner = unwrap(element);
+  if (inner.type !== "BinaryExpression" || inner.operator !== "+") return void 0;
+  const left = nodeAt(inner, "left");
+  const right = nodeAt(inner, "right");
+  return left && right ? [left, right] : void 0;
+}
+function* sequenceOf(first2, rest) {
+  const pending = first2.toReversed();
+  for (; ; ) {
+    let element = pending.pop();
+    if (element === void 0) return;
+    const operands = operandsOf(element);
+    if (operands) pending.push(operands[1], operands[0]);
+    else yield element;
+  }
+}
+function verdictOf(elements, analysis) {
+  for (const element of elements) {
+    const values = typeof element === "string" ? [element] : stringValues(element, analysis);
+    if (!values?.every((value) => value === "" || isEndingValue(value))) return false;
+    if (!values.includes("")) return true;
+  }
+  return void 0;
+}
+function isEndingAfter(start, analysis, memo) {
+  const walked = [];
+  let link = start;
+  let verdict;
+  while (verdict === void 0) {
+    if (!link) {
+      verdict = true;
+    } else if (memo.has(link)) {
+      verdict = memo.get(link);
+    } else {
+      walked.push(link);
+      verdict = verdictOf(sequenceOf([link.node]), analysis);
+      link = link.next;
+    }
+  }
+  for (const walkedLink of walked) memo.set(walkedLink, verdict);
+  return verdict;
+}
+function isEndingTheClass(first2, rest, analysis, memo) {
+  return verdictOf(sequenceOf(first2), analysis) ?? isEndingAfter(rest, analysis, memo);
+}
+function unwrap(node) {
+  let current = node;
+  for (let inner = wrappedBy(current); inner; inner = wrappedBy(current)) current = inner;
+  return current;
+}
+
+// src/vite-literal-classes.ts
+var ATOM_OF_CLASS = new Map(
+  Object.entries(atomClassMap).map(([atom, className]) => [className, atom])
+);
+function atomOfClass(className) {
+  return ATOM_OF_CLASS.get(className);
+}
+function isBoundary(code, index) {
+  if (index === 0 || !isIdentChar(code[index - 1])) return true;
+  return code[index - 2] === "\\" && /[bfnrtv0]/.test(code[index - 1]);
+}
+function identifierAt(code, index) {
+  let end = index;
+  while (isIdentChar(code[end])) end += 1;
+  return code.slice(index, end);
+}
+function atomsWrittenIn(code) {
+  const found = /* @__PURE__ */ new Set();
+  let index = code.indexOf("nave-");
+  while (index !== -1) {
+    if (isBoundary(code, index)) {
+      const atom = ATOM_OF_CLASS.get(identifierAt(code, index));
+      if (atom) found.add(atom);
+    }
+    index = code.indexOf("nave-", index + 5);
+  }
+  return found;
+}
+function isEndingInNavePrefix(text) {
+  let start = text.length;
+  while (start > 0 && isIdentChar(text[start - 1])) start -= 1;
+  return text.slice(start).startsWith("nave-");
+}
+function isBreakingOut(node, analysis, ending) {
+  if (node.type !== "TemplateLiteral") return false;
+  const quasis = nodesAt(node, "quasis");
+  const substitutions = nodesAt(node, "expressions");
+  return quasis.slice(0, -1).some((quasi, index) => {
+    const cooked = quasi.value?.cooked;
+    if (cooked === void 0 || !isEndingInNavePrefix(cooked)) return false;
+    const following = substitutions.slice(index).flatMap((substitution, offset) => {
+      const next = quasis[index + 1 + offset];
+      const text = next?.value?.cooked;
+      return [substitution, ...next ? [text ?? next] : []];
+    });
+    return !isEndingTheClass(following, ending.after, analysis, ending.memo);
+  });
+}
+function concatenatedPiece(node, memo, analysis, ending) {
+  if (!isPlus(node)) return void 0;
+  const piece = rightmostPiece(nodeAt(node, "left"), memo);
+  if (piece?.head !== "nave-") return void 0;
+  const right = nodeAt(node, "right");
+  return isEndingTheClass(right ? [right] : [], ending.after, analysis, ending.memo) ? void 0 : piece;
+}
+function escapedText(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return { raw: String(node.raw), decoded: node.value };
+  }
+  if (node.type !== "TemplateElement") return void 0;
+  const { raw, cooked } = node.value;
+  if (!cooked || !raw?.includes("\\")) return void 0;
+  return { raw, decoded: cooked };
+}
+var CHARACTER_REFERENCE = /&#(?:(\d+)|x([\dA-Fa-f]+));/g;
+function decodeCharacterReferences(text) {
+  return text.replaceAll(CHARACTER_REFERENCE, (reference2, decimal, hex) => {
+    const codePoint = decimal === void 0 ? Number.parseInt(hex, 16) : Number(decimal);
+    const isScalar = codePoint <= 1114111 && (codePoint < 55296 || codePoint > 57343);
+    return isScalar ? String.fromCodePoint(codePoint) : reference2;
+  });
+}
+function jsxAttributeText(node) {
+  if (node.type !== "JSXAttribute") return void 0;
+  const value = nodeAt(node, "value");
+  if (value?.type !== "Literal" || typeof value.value !== "string") return void 0;
+  const written = typeof value.raw === "string" ? value.raw.slice(1, -1) : value.value;
+  return written.includes("&#") ? decodeCharacterReferences(written) : void 0;
+}
+var PARENTHESES_KEPT = "readModule reads a syntax tree with no node for a pair of parentheses, as Vite's parser returns it. This tree keeps one (a ParenthesizedExpression): parse with the parentheses dropped, for example oxc-parser with preserveParens: false.";
+function refuseParenthesesAndFindEscapedAtoms(program) {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "ParenthesizedExpression") throw new TypeError(PARENTHESES_KEPT);
+    const text = escapedText(node);
+    const decoded = text?.raw.includes("\\") ? text.decoded : jsxAttributeText(node);
+    if (decoded !== void 0) {
+      for (const atom of atomsWrittenIn(decoded)) found.add(atom);
+    }
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+var SENTENCE = "a Nave class built from pieces is invisible to the build, so its atom would not ship.";
+function concatenationProblems(program, code, analysis) {
+  const problems = [];
+  const memo = { edges: /* @__PURE__ */ new Map(), rightmost: /* @__PURE__ */ new Map() };
+  const ends = /* @__PURE__ */ new Map();
+  const stack = [{ node: program, after: void 0 }];
+  while (stack.length > 0) {
+    const { node, after } = stack.pop();
+    const offset = concatenatedPiece(node, memo, analysis, { after, memo: ends })?.node.start ?? (isBreakingOut(node, analysis, { after, memo: ends }) ? node.start : -1);
+    if (offset !== -1) {
+      problems.push({
+        kind: "concatenation",
+        offset,
+        construct: code.slice(node.start, node.end),
+        text: SENTENCE
+      });
+    }
+    pushAll(stack, childrenWithAfter(node, after));
+  }
+  return problems.toSorted((a, b) => a.offset - b.offset);
+}
+function childrenWithAfter(node, after) {
+  const isOperands = node.type === "BinaryExpression" && node.operator === "+";
+  if (isOperands) {
+    const left = nodeAt(node, "left");
+    const right = nodeAt(node, "right");
+    return [
+      ...left ? [{ node: left, after: right ? { node: right, next: after } : after }] : [],
+      ...right ? [{ node: right, after }] : []
+    ];
+  }
+  const isWrapper = node.type === "ParenthesizedExpression";
+  return childrenOf(node).map((child) => ({ node: child, after: isWrapper ? after : void 0 }));
+}
+
+// src/vite-rewrite-class.ts
+function classOf(name) {
+  return Object.hasOwn(atomClassMap, name) ? atomClassMap[name] : name;
+}
+function decode(node, frame, out) {
+  const found = resolveArgument(node, frame.analysis, frame.setup) ?? [];
+  const values = [...new Set(found.map((possible) => possible.value))];
+  if (values.length === 0) return;
+  const text = frame.code.slice(node.start, node.end);
+  const chain = values.map((value) => `${text} === ${JSON.stringify(value)} ? ${JSON.stringify(classOf(value))} : `).join("");
+  out.push({ start: node.start, end: node.end, text: `(${chain}${text})` });
+}
+var decodeName = (node, frame, out) => {
+  if (frame.analysis.referenceOf(node)?.binding) decode(node, frame, out);
+};
+var collectEach = (keys) => (node, frame, out) => {
+  for (const key of keys) collect(nodeAt(node, key), frame, out);
+};
+var COLLECTORS = /* @__PURE__ */ new Map([
+  ["ConditionalExpression", collectEach(["consequent", "alternate"])],
+  ["Identifier", decodeName],
+  [
+    "LogicalExpression",
+    (node, frame, out) => {
+      for (const operand of operandsRead(node)) collect(operand, frame, out);
+    }
+  ],
+  ["MemberExpression", decode],
+  ["ParenthesizedExpression", collectEach(["expression"])]
+]);
+function collect(node, frame, out) {
+  const text = staticStringOf(node);
+  if (text === void 0) {
+    COLLECTORS.get(node.type)?.(node, frame, out);
+  } else if (text !== "") {
+    out.push({ start: node.start, end: node.end, text: JSON.stringify(classOf(text)) });
+  }
+}
+function classEdits(argument, frame) {
+  const out = [];
+  collect(argument, frame, out);
+  return out;
+}
+
+// src/vite-source-map.ts
+function toSourceMap(map) {
+  return {
+    version: 3,
+    sources: map.sources,
+    names: map.names ?? [],
+    mappings: map.mappings,
+    ...map.sourceRoot !== void 0 && { sourceRoot: map.sourceRoot },
+    ...map.sourcesContent !== void 0 && { sourcesContent: map.sourcesContent }
+  };
+}
+function combinedMapOf(ctx) {
+  const map = ctx.getCombinedSourcemap();
+  return map.mappings === "" ? void 0 : decodeIncomingMap(toSourceMap(map));
+}
+var LINE_TERMINATOR = /\r\n|[\n\r\u{2028}\u{2029}]/gu;
+function lineStartsOf(code) {
+  const starts = [0];
+  for (const match of code.matchAll(LINE_TERMINATOR)) starts.push(match.index + match[0].length);
+  return starts;
+}
+function lineIndexOf(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (starts[middle] <= offset) low = middle;
+    else high = middle - 1;
+  }
+  return low;
+}
+function positionIn(code) {
+  let starts;
+  return (offset) => {
+    starts ??= lineStartsOf(code);
+    const index = lineIndexOf(starts, offset);
+    return { line: index + 1, column: offset - starts[index] + 1 };
+  };
+}
+function normalized(text) {
+  return text.replace(/^\u{FEFF}/u, "").replaceAll("\r\n", "\n");
+}
+function placerFor(code, map, authored) {
+  const position = positionIn(code);
+  const isAuthored = (index) => {
+    const source = map?.sourcesContent?.[index];
+    return authored === void 0 || typeof source !== "string" ? true : normalized(source) === normalized(authored);
+  };
+  return (offset) => {
+    const generated = position(offset);
+    const origin = map?.originalPositionFor({ line: generated.line, column: generated.column - 1 });
+    return origin && isAuthored(origin.sourceIndex) ? { line: origin.line, column: origin.column + 1 } : void 0;
+  };
+}
+
+// src/vite-rewrite-edit.ts
+function afterComment(code, at) {
+  if (code.startsWith("/*", at)) {
+    const end2 = code.indexOf("*/", at + 2);
+    return end2 === -1 ? code.length : end2 + 2;
+  }
+  if (!code.startsWith("//", at)) return void 0;
+  const end = code.slice(at).search(/[\n\r\u{2028}\u{2029}]/u);
+  return end === -1 ? code.length : at + end + 1;
+}
+function startOfNext(code, from) {
+  let at = from;
+  while (at < code.length) {
+    const comment = afterComment(code, at);
+    if (comment !== void 0) at = comment;
+    else if (/\s/.test(code[at])) at += 1;
+    else break;
+  }
+  return at;
+}
+var TOKEN = /\w+|[\s\S]/gu;
+function countable(text) {
+  return text.replaceAll("\f", " ").replaceAll(/[\u{2028}\u{2029}]/gu, "\n");
+}
+function applyEdits(code, id, edits) {
+  const position = positionIn(code);
+  const mappings = new MappingsBuilder();
+  const mark = (offset) => {
+    const { line, column } = position(offset);
+    mappings.mark({ line, column: column - 1 });
+  };
+  let out = "";
+  const keep = (from, to) => {
+    const text = code.slice(from, to);
+    for (const token of text.matchAll(TOKEN)) {
+      if (token[0].trim() !== "") mark(from + token.index);
+      mappings.advance(countable(token[0]));
+    }
+    out += text;
+  };
+  const ordered = edits.toSorted((a, b) => a.start - b.start || a.end - b.end);
+  let cursor = 0;
+  for (const edit of ordered) {
+    keep(cursor, edit.start);
+    if (edit.text !== "") {
+      mark(edit.start);
+      mappings.advance(countable(edit.text));
+      out += edit.text;
+    }
+    cursor = edit.end;
+  }
+  keep(cursor, code.length);
+  const map = { version: 3, sources: [id], names: [], mappings: mappings.toMappings() };
+  return { code: out, map: JSON.stringify(map) };
+}
+
+// src/vite-rewrite-call.ts
+var JOIN = '].filter(Boolean).join(" ")';
+function argumentsStart(code, call) {
+  let at = nodeAt(call, "callee").end;
+  while (at < code.length) {
+    const char = code[at];
+    if (char === "(") return at + 1;
+    const comment = afterComment(code, at);
+    if (char === ")" || /\s/.test(char)) at += 1;
+    else if (code.startsWith("?.", at)) at += 2;
+    else if (comment === void 0) return void 0;
+    else at = comment;
+  }
+  return void 0;
+}
+var STATEMENT_LISTS = /* @__PURE__ */ new Set([
+  "BlockStatement",
+  "Program",
+  "StaticBlock",
+  "SwitchCase"
+]);
+function isStatementStart(call, frame) {
+  const { parentOf } = frame.analysis;
+  let node = call;
+  for (let parent = parentOf.get(node); parent?.start === call.start; parent = parentOf.get(node)) {
+    node = parent;
+  }
+  const holder = parentOf.get(node);
+  return node.type === "ExpressionStatement" && holder !== void 0 && STATEMENT_LISTS.has(holder.type);
+}
+function lead(call, frame) {
+  return isStatementStart(call, frame) ? ";" : "";
+}
+function joined(call, frame, inside) {
+  const open = argumentsStart(frame.code, call);
+  if (open === void 0) return void 0;
+  return [
+    { start: call.start, end: open, text: `${lead(call, frame)}[` },
+    ...inside,
+    { start: call.end - 1, end: call.end, text: JOIN }
+  ];
+}
+function literal2(call, frame, text) {
+  return [{ start: call.start, end: call.end, text: `${lead(call, frame)}${JSON.stringify(text)}` }];
+}
+function constantsOf(args, frame) {
+  const constants = args.map((arg) => constantOf(arg, frame.analysis));
+  return constants.includes(void 0) ? void 0 : constants;
+}
+function cxCallEdits(call, frame) {
+  const args = nodesAt(call, "arguments");
+  const constants = constantsOf(args, frame);
+  if (constants) {
+    return literal2(
+      call,
+      frame,
+      constants.filter(Boolean).map((name) => classOf(name)).join(" ")
+    );
+  }
+  return joined(
+    call,
+    frame,
+    args.flatMap((arg) => classEdits(arg, frame))
+  );
+}
+function rawCallEdits(call, frame) {
+  const args = nodesAt(call, "arguments");
+  const constants = constantsOf(args, frame);
+  if (constants) return literal2(call, frame, constants.filter(Boolean).join(" "));
+  return joined(call, frame, []);
+}
+function rawCallOf(member, frame) {
+  const parent = frame.analysis.parentOf.get(member);
+  return parent?.type === "CallExpression" && nodeAt(parent, "callee") === member ? parent : void 0;
+}
+function trailingComma(code, argument, call) {
+  let at = argument.end;
+  const end = call.end - 1;
+  while (at < end) {
+    const char = code[at];
+    if (char === ",") return at;
+    const comment = afterComment(code, at);
+    if (char === ")" || /\s/.test(char)) at += 1;
+    else if (comment === void 0) return void 0;
+    else at = comment;
+  }
+  return void 0;
+}
+function dynamicCallEdits(call, frame, map) {
+  const args = nodesAt(call, "arguments");
+  const open = argumentsStart(frame.code, call);
+  if (open === void 0) return void 0;
+  const [argument] = args;
+  const head = `${lead(call, frame)}(${map}[`;
+  const end = { start: call.end - 1, end: call.end };
+  if (args.length !== 1 || argument.type === "SpreadElement") {
+    return [
+      { start: call.start, end: open, text: `${head}[` },
+      { ...end, text: '][0]] || "")' }
+    ];
+  }
+  const comma = trailingComma(frame.code, argument, call);
+  return [
+    { start: call.start, end: open, text: head },
+    ...comma === void 0 ? [] : [{ start: comma, end: comma + 1, text: "" }],
+    { ...end, text: '] || "")' }
+  ];
+}
+
+// src/vite-rewrite-module.ts
+function newRewriting() {
+  return { attempts: 0, done: /* @__PURE__ */ new Set(), kept: /* @__PURE__ */ new Set() };
+}
+function addEdits(subject, nodes, build) {
+  const { options, result, rewriting } = subject;
+  if (!options.rewrite || rewriting.done.has(nodes[0])) return;
+  let edits;
+  try {
+    edits = build();
+  } catch (error) {
+    if (error instanceof RangeError) return;
+    throw error;
+  }
+  if (!edits) return;
+  for (const node of nodes) rewriting.done.add(node);
+  pushAll(result.edits, edits);
+}
+function frameOf(subject, analysis) {
+  return { code: subject.code, analysis, setup: subject.options.setup };
+}
+function rewriteCx(subject, call, analysis) {
+  addEdits(subject, [call], () => cxCallEdits(call, frameOf(subject, analysis)));
+}
+function rewriteRaw(subject, member, analysis) {
+  const frame = frameOf(subject, analysis);
+  const call = rawCallOf(member, frame);
+  if (call) addEdits(subject, [member, call], () => rawCallEdits(call, frame));
+}
+function mapLiteral(keep) {
+  const entries = Object.entries(keep).map(
+    ([atom, name]) => `${JSON.stringify(atom)}:${JSON.stringify(name)}`
+  );
+  return `{${["__proto__:null", ...entries].join(",")}}`;
+}
+function rewriteDynamic(subject, call, analysis) {
+  const keep = subject.options.rewrite?.keep;
+  if (!keep) return;
+  addEdits(
+    subject,
+    [call],
+    () => dynamicCallEdits(call, frameOf(subject, analysis), mapLiteral(keep))
+  );
+}
+function noteUse(rewriting, cx, use) {
+  if (cx && !(use && rewriting.done.has(use.node))) rewriting.kept.add(cx.binding);
+}
+function localNamesOf(declaration) {
+  return nodesAt(declaration, "specifiers").map((specifier) => {
+    const local = nodeAt(specifier, "local");
+    return (local && stringAt(local, "name")) ?? "";
+  });
+}
+var CONTINUING = /[([`+\-/]/;
+function removeUnusedImports(subject, program, bound) {
+  if (bound.hasDirectEval) return;
+  const unused = new Set(
+    bound.bindings.keys().filter((binding) => !subject.rewriting.kept.has(binding)).map((binding) => binding.name)
+  );
+  const { code } = subject;
+  for (const declaration of nodesAt(program, "body")) {
+    const names = declaration.type === "ImportDeclaration" && staticStringOf(nodeAt(declaration, "source")) === bound.source ? localNamesOf(declaration) : [];
+    if (names.length === 0 || names.some((name) => !unused.has(name))) continue;
+    const line = /^\r?\n/.exec(code.slice(declaration.end));
+    const end = declaration.end + (line?.[0].length ?? 0);
+    const text = CONTINUING.test(code.charAt(startOfNext(code, end))) ? ";" : "";
+    subject.result.edits.push({ start: declaration.start, end, text });
+  }
+}
+function finishRewrite(subject, program, bound) {
+  if (!subject.options.rewrite || subject.result.edits.length === 0) return;
+  removeUnusedImports(subject, program, bound);
+}
+
+// src/vite-scope-types.ts
+function newScope(parent, isFunction) {
+  return { parent, isFunction, bindings: /* @__PURE__ */ new Map() };
+}
+function functionScopeOf(scope) {
+  let current = scope;
+  while (!current.isFunction && current.parent) current = current.parent;
+  return current;
+}
+function declare(scope, binding, isAssigning = true) {
+  const existing = scope.bindings.get(binding.name);
+  if (existing) {
+    if (isAssigning) existing.writes += 1;
+    return existing;
+  }
+  scope.bindings.set(binding.name, binding);
+  return binding;
+}
+function reference(walker, node, scope, isWrite = false) {
+  walker.references.push({ node, scope, isWrite, binding: void 0 });
+}
+
+// src/vite-scope-enum.ts
+function visitEnum(node, scope, walker) {
+  const inner = newScope(scope, false);
+  const body = nodeAt(node, "body");
+  const members = body ? nodesAt(body, "members") : [];
+  for (const member of members) {
+    const name = propertyNameOf(nodeAt(member, "id"), false);
+    if (name !== void 0) declare(inner, { name, kind: "const", writes: 0 });
+  }
+  if (!body) return;
+  walker.parentOf.set(body, node);
+  walker.visit(body, inner);
+}
+
+// src/vite-scope-imports.ts
+function importedName(specifier) {
+  if (specifier.type === "ImportNamespaceSpecifier") return "*";
+  if (specifier.type !== "ImportSpecifier") return "default";
+  const imported = nodeAt(specifier, "imported");
+  return stringAt(imported ?? specifier, "name") ?? String(imported?.value);
+}
+function declareImport(node, scope) {
+  if (isTypeOnly(node)) return;
+  const source = String(nodeAt(node, "source")?.value);
+  for (const specifier of nodesAt(node, "specifiers")) {
+    if (isTypeOnly(specifier)) continue;
+    const local = stringAt(nodeAt(specifier, "local") ?? specifier, "name");
+    if (local === void 0) continue;
+    const imported = importedName(specifier);
+    scope.bindings.set(local, { name: local, kind: "import", writes: 0, source, imported });
+  }
+}
+
+// src/vite-scope-pattern.ts
+function partsOf(pattern) {
+  return nodesAt(pattern, pattern.type === "ArrayPattern" ? "elements" : "properties");
+}
+function targetOf(part) {
+  return part.type === "Property" ? nodeAt(part, "value") : part;
+}
+function functionScopeOrHere(spec, scope) {
+  return spec.kind === "var" ? functionScopeOf(scope) : scope;
+}
+function declarePattern(pattern, spec, scope, walker) {
+  if (!pattern) return;
+  const name = stringAt(pattern, "name");
+  if (name !== void 0 && pattern.type === "Identifier") {
+    const into = functionScopeOrHere(spec, scope);
+    const isAssigning = spec.kind !== "var" || spec.init !== void 0 || spec.isAssigned === true;
+    const binding = { name, kind: spec.kind, writes: 0 };
+    if (spec.owner) binding.owner = spec.owner;
+    const declared = declare(into, binding, isAssigning);
+    if (spec.init) declared.init = spec.init;
+    return;
+  }
+  DECLARE[pattern.type]?.(pattern, spec, scope, walker);
+}
+var DECLARE = {
+  TSParameterProperty: (pattern, spec, scope, walker) => {
+    declarePattern(nodeAt(pattern, "parameter"), spec, scope, walker);
+  },
+  AssignmentPattern: (pattern, spec, scope, walker) => {
+    declarePattern(nodeAt(pattern, "left"), spec, scope, walker);
+    const right = nodeAt(pattern, "right");
+    if (right) walker.parentOf.set(right, pattern);
+    walker.visit(right, scope);
+  },
+  RestElement: (pattern, spec, scope, walker) => {
+    declarePattern(nodeAt(pattern, "argument"), spec, scope, walker);
+  },
+  ArrayPattern: (pattern, spec, scope, walker) => {
+    for (const part of partsOf(pattern)) declarePattern(part, spec, scope, walker);
+  },
+  ObjectPattern: (pattern, spec, scope, walker) => {
+    for (const part of partsOf(pattern)) {
+      if (part.computed === true) walker.visit(nodeAt(part, "key"), scope);
+      declarePattern(targetOf(part), spec, scope, walker);
+    }
+  }
+};
+function writeTargets(target, scope, walker) {
+  if (!target) return;
+  const inner = assertedBy(target);
+  if (inner) {
+    walker.parentOf.set(inner, target);
+    writeTargets(inner, scope, walker);
+    return;
+  }
+  if (target.type === "Identifier") {
+    reference(walker, target, scope, true);
+    return;
+  }
+  const write = WRITE[target.type];
+  if (write) write(target, void 0, scope, walker);
+  else walker.visit(target, scope);
+}
+var WRITE = {
+  ArrayPattern: (target, _result, scope, walker) => {
+    for (const part of partsOf(target)) writeTargets(part, scope, walker);
+  },
+  ObjectPattern: (target, _result, scope, walker) => {
+    for (const part of partsOf(target)) {
+      if (part.computed === true) walker.visit(nodeAt(part, "key"), scope);
+      writeTargets(targetOf(part), scope, walker);
+    }
+  },
+  AssignmentPattern: (target, _result, scope, walker) => {
+    writeTargets(nodeAt(target, "left"), scope, walker);
+    walker.visit(nodeAt(target, "right"), scope);
+  },
+  RestElement: (target, _result, scope, walker) => {
+    writeTargets(nodeAt(target, "argument"), scope, walker);
+  }
+};
+
+// src/vite-scope-walk.ts
+function visit(node, scope, walker) {
+  if (!node) return;
+  const handler = HANDLERS[node.type];
+  if (handler) handler(node, scope, walker);
+  else visitChildren(node, scope, walker);
+}
+var TYPE_KEYS = /* @__PURE__ */ new Set(["typeAnnotation", "typeArguments"]);
+function visitChildren(node, scope, walker) {
+  for (const child of childrenOf(node, TYPE_KEYS)) {
+    walker.parentOf.set(child, node);
+    visit(child, scope, walker);
+  }
+}
+function visitKeys(node, keys, scope, walker) {
+  const children = keys.flatMap((key) => {
+    const value = node[key];
+    return (Array.isArray(value) ? value : [value]).filter((child) => isNode(child));
+  });
+  for (const child of children) {
+    walker.parentOf.set(child, node);
+    visit(child, scope, walker);
+  }
+}
+function expressionKeys(node, others) {
+  return node.computed === true ? ["key", ...others] : [...others];
+}
+function visitLoop(node, scope, walker) {
+  const inner = newScope(scope, false);
+  const left = nodeAt(node, "left");
+  if (left?.type === "VariableDeclaration") {
+    const kind = left.kind === "var" ? "var" : "loop";
+    for (const declarator of nodesAt(left, "declarations")) {
+      declarePattern(nodeAt(declarator, "id"), { kind, isAssigned: true }, inner, walker);
+    }
+  } else {
+    writeTargets(left, inner, walker);
+  }
+  visitKeys(node, ["right"], scope, walker);
+  visitKeys(node, ["body"], inner, walker);
+}
+function visitFunction(node, scope, walker) {
+  let outer = scope;
+  const id = nodeAt(node, "id");
+  if (id && node.type === "FunctionExpression") {
+    outer = newScope(scope, false);
+    declare(outer, { name: stringAt(id, "name") ?? "", kind: "function", writes: 0 });
+  }
+  const parameters = newScope(outer, true);
+  for (const param of nodesAt(node, "params")) {
+    visitKeys(param, ["decorators"], scope, walker);
+    declarePattern(param, { kind: "param", owner: node }, parameters, walker);
+  }
+  const body = nodeAt(node, "body");
+  if (body?.type === "BlockStatement") {
+    walker.parentOf.set(body, node);
+    visitChildren(body, newScope(parameters, true), walker);
+  } else {
+    visitKeys(node, ["body"], parameters, walker);
+  }
+}
+function visitClass(node, scope, walker) {
+  visitKeys(node, ["decorators"], scope, walker);
+  const inner = newScope(scope, false);
+  const name = stringAt(nodeAt(node, "id") ?? node, "name");
+  if (name !== void 0) declare(inner, { name, kind: "class", writes: 0 });
+  visitKeys(node, ["superClass", "body"], inner, walker);
+}
+function visitDeclaration(node, scope, walker) {
+  const kind = node.kind;
+  for (const declarator of nodesAt(node, "declarations")) {
+    walker.parentOf.set(declarator, node);
+    const id = nodeAt(declarator, "id");
+    const init = nodeAt(declarator, "init");
+    const hasPlainInit = id?.type === "Identifier" && init !== void 0;
+    const spec = hasPlainInit ? { kind, init } : { kind, isAssigned: init !== void 0 };
+    declarePattern(id, spec, scope, walker);
+    if (id) walker.parentOf.set(id, declarator);
+    visit(init, scope, walker);
+    if (init) walker.parentOf.set(init, declarator);
+  }
+}
+function visitExport(node, scope, walker) {
+  if (node.source || isTypeOnly(node)) return;
+  visitKeys(node, ["declaration"], scope, walker);
+  for (const specifier of nodesAt(node, "specifiers")) {
+    const local = nodeAt(specifier, "local");
+    if (!local || isTypeOnly(specifier)) continue;
+    walker.parentOf.set(specifier, node);
+    walker.parentOf.set(local, specifier);
+    reference(walker, local, scope);
+  }
+}
+function leaf3() {
+}
+function isDirectEval(node) {
+  let callee = nodeAt(node, "callee");
+  while (callee?.type === "ParenthesizedExpression") callee = nodeAt(callee, "expression");
+  return callee?.type === "Identifier" && stringAt(callee, "name") === "eval";
+}
+function writeTarget(node, key, scope, walker) {
+  const target = nodeAt(node, key);
+  if (target) walker.parentOf.set(target, node);
+  writeTargets(target, scope, walker);
+}
+function visitChain(node, scope, walker) {
+  const spine = [];
+  let current = node;
+  while (current?.type === "BinaryExpression" || current?.type === "LogicalExpression") {
+    spine.push(current);
+    current = nodeAt(current, "left");
+  }
+  const links = [...spine, ...current ? [current] : []];
+  for (let index = 1; index < links.length; index += 1) {
+    walker.parentOf.set(links[index], links[index - 1]);
+  }
+  visit(current, scope, walker);
+  for (const link of spine.toReversed()) visitKeys(link, ["right"], scope, walker);
+}
+var MEMBER_LIKE = (node, scope, walker) => {
+  visitKeys(node, ["decorators", ...expressionKeys(node, ["value"])], scope, walker);
+};
+var HANDLERS = {
+  Identifier: (node, scope, walker) => {
+    reference(walker, node, scope);
+  },
+  MemberExpression: (node, scope, walker) => {
+    visitKeys(node, node.computed === true ? ["object", "property"] : ["object"], scope, walker);
+  },
+  Property: MEMBER_LIKE,
+  MethodDefinition: MEMBER_LIKE,
+  PropertyDefinition: MEMBER_LIKE,
+  AccessorProperty: MEMBER_LIKE,
+  LabeledStatement: (node, scope, walker) => {
+    visitKeys(node, ["body"], scope, walker);
+  },
+  BreakStatement: leaf3,
+  ContinueStatement: leaf3,
+  MetaProperty: leaf3,
+  ExportAllDeclaration: leaf3,
+  TSEnumDeclaration: visitEnum,
+  TSEnumMember: (node, scope, walker) => {
+    visitKeys(node, ["initializer"], scope, walker);
+  },
+  TSInterfaceDeclaration: leaf3,
+  TSTypeAliasDeclaration: leaf3,
+  TSDeclareFunction: leaf3,
+  TSEmptyBodyFunctionExpression: leaf3,
+  TSAbstractMethodDefinition: leaf3,
+  TSAbstractPropertyDefinition: leaf3,
+  TSAbstractAccessorProperty: leaf3,
+  TSIndexSignature: leaf3,
+  TSModuleDeclaration: (node, scope, walker) => {
+    visitKeys(node, ["body"], newScope(scope, true), walker);
+  },
+  CallExpression: (node, scope, walker) => {
+    if (isDirectEval(node)) walker.evalScopes.push(scope);
+    visitChildren(node, scope, walker);
+  },
+  BinaryExpression: visitChain,
+  LogicalExpression: visitChain,
+  AssignmentExpression: (node, scope, walker) => {
+    writeTarget(node, "left", scope, walker);
+    visitKeys(node, ["right"], scope, walker);
+  },
+  UpdateExpression: (node, scope, walker) => {
+    writeTarget(node, "argument", scope, walker);
+  },
+  ImportDeclaration: (node, scope) => {
+    declareImport(node, scope);
+  },
+  ExportNamedDeclaration: visitExport,
+  VariableDeclaration: visitDeclaration,
+  FunctionDeclaration: (node, scope, walker) => {
+    const name = stringAt(nodeAt(node, "id") ?? node, "name");
+    if (name !== void 0) declare(scope, { name, kind: "function", writes: 0 });
+    visitFunction(node, scope, walker);
+  },
+  FunctionExpression: visitFunction,
+  ArrowFunctionExpression: visitFunction,
+  ClassDeclaration: (node, scope, walker) => {
+    const name = stringAt(nodeAt(node, "id") ?? node, "name");
+    if (name !== void 0) declare(scope, { name, kind: "class", writes: 0 });
+    visitClass(node, scope, walker);
+  },
+  ClassExpression: visitClass,
+  StaticBlock: (node, scope, walker) => {
+    visitChildren(node, newScope(scope, true), walker);
+  },
+  BlockStatement: (node, scope, walker) => {
+    visitChildren(node, newScope(scope, false), walker);
+  },
+  SwitchStatement: (node, scope, walker) => {
+    visitKeys(node, ["discriminant"], scope, walker);
+    visitKeys(node, ["cases"], newScope(scope, false), walker);
+  },
+  CatchClause: (node, scope, walker) => {
+    const inner = newScope(scope, false);
+    declarePattern(nodeAt(node, "param"), { kind: "catch" }, inner, walker);
+    visitKeys(node, ["body"], inner, walker);
+  },
+  ForStatement: (node, scope, walker) => {
+    visitChildren(node, newScope(scope, false), walker);
+  },
+  ForInStatement: visitLoop,
+  ForOfStatement: visitLoop
+};
+
+// src/vite-scope.ts
+function lookup(scope, name) {
+  for (let current = scope; current; current = current.parent) {
+    const found = current.bindings.get(name);
+    if (found) return found;
+  }
+  return void 0;
+}
+function resolve(reference2) {
+  const name = stringAt(reference2.node, "name");
+  reference2.binding = name === void 0 ? void 0 : lookup(reference2.scope, name);
+  if (reference2.binding && reference2.isWrite) reference2.binding.writes += 1;
+}
+var ASSIGNABLE = /* @__PURE__ */ new Set([
+  "catch",
+  "class",
+  "function",
+  "let",
+  "loop",
+  "param",
+  "var"
+]);
+function assignable(scope) {
+  return scope.bindings.values().filter((binding) => ASSIGNABLE.has(binding.kind)).toArray();
+}
+function markEvalWrites(scopes) {
+  const marked = /* @__PURE__ */ new Set();
+  for (const start of scopes) {
+    for (let scope = start; scope && !marked.has(scope); scope = scope.parent) {
+      marked.add(scope);
+      for (const binding of assignable(scope)) binding.writes += 1;
+    }
+  }
+}
+function analyze(program) {
+  const walker = {
+    references: [],
+    parentOf: /* @__PURE__ */ new Map(),
+    evalScopes: [],
+    visit: (node, scope) => {
+      visit(node, scope, walker);
+    }
+  };
+  const module = newScope(void 0, true);
+  for (const statement of nodesAt(program, "body")) {
+    walker.parentOf.set(statement, program);
+    visit(statement, module, walker);
+  }
+  const byNode = /* @__PURE__ */ new Map();
+  for (const reference2 of walker.references) {
+    resolve(reference2);
+    byNode.set(reference2.node, reference2);
+  }
+  const evalScopes = walker.evalScopes.filter((scope) => !lookup(scope, "eval"));
+  markEvalWrites(evalScopes);
+  return {
+    hasDirectEval: evalScopes.length > 0,
+    references: walker.references,
+    parentOf: walker.parentOf,
+    referenceOf: (node) => byNode.get(node)
+  };
+}
+
+// src/vite-vue-setup.ts
+function returnedObject(analysis) {
+  for (const [node] of analysis.parentOf) {
+    if (!isSetupReturn(node, analysis.parentOf)) continue;
+    const init = nodeAt(node, "init");
+    if (init?.type === "ObjectExpression") return init;
+  }
+  return void 0;
+}
+function stringExposures(analysis) {
+  const exposures = /* @__PURE__ */ new Map();
+  const object = returnedObject(analysis);
+  const properties = object ? nodesAt(object, "properties") : [];
+  for (const property of properties) {
+    const value = nodeAt(property, "value");
+    const name = propertyNameOf(nodeAt(property, "key"), property.computed === true);
+    if (name === void 0 || value?.type !== "Identifier" || property.kind === "get") continue;
+    const possibles2 = resolveArgument(value, analysis);
+    if (possibles2) exposures.set(name, { kind: "values", values: possibles2.map((p) => p.value) });
+  }
+  return exposures;
+}
+function cxReadsOnSetup(analysis, exposures) {
+  const reads = [];
+  for (const reference2 of analysis.references) {
+    if (!isSetupParameter(analysis, reference2.node)) continue;
+    const member = analysis.parentOf.get(reference2.node);
+    const name = member && setupMemberName(member);
+    if (member && name !== void 0 && exposures.get(name)?.kind === "cx") reads.push(member);
+  }
+  return reads;
+}
+
+// src/vite-collect.ts
+var CX_SOURCE = "@navecss/core/cx";
+function report(reading, problem2) {
+  reading.rewriting.attempts += 1;
+  const key = `${problem2.kind}:${problem2.offset}`;
+  if (reading.seen.has(key)) return;
+  reading.seen.add(key);
+  reading.result.problems.push(problem2);
+}
+var COMPILER_PREFIX = /\$setup\.|\$\$props\./g;
+function quoteCall(reading, use, args, callee = use.local) {
+  const inner = args.length > 0 ? textWithoutAssertions(reading.code, args) : "";
+  return `${callee}(${inner.replaceAll(COMPILER_PREFIX, "")})`;
+}
+function judgeString(reading, use, value, node) {
+  const verdict = judgeAtom(value, reading.options.ownAtoms);
+  switch (verdict.kind) {
+    case "atom": {
+      reading.result.atoms.add(value);
+      break;
+    }
+    case "own": {
+      report(reading, {
+        kind: "own",
+        offset: node.start,
+        construct: `${use.local}()`,
+        text: `"${value}" is an atom of your own, which has no class. Use @nave ${value} in a CSS rule instead.`
+      });
+      break;
+    }
+    case "whitespace": {
+      report(reading, {
+        kind: "argument",
+        offset: node.start,
+        construct: `${use.local}()`,
+        text: verdict.text
+      });
+      break;
+    }
+    default: {
+      report(reading, {
+        kind: "unknown",
+        offset: node.start,
+        construct: `${use.local}()`,
+        text: verdict.text,
+        needsAvailable: !verdict.hasHint
+      });
+    }
+  }
+}
+function readCall(reading, use, analysis) {
+  const args = nodesAt(use.node, "arguments");
+  let quote;
+  const quoted = () => quote ??= quoteCall(reading, use, args);
+  for (const arg of args) {
+    if (arg.type === "SpreadElement") {
+      report(reading, {
+        kind: "argument",
+        offset: arg.start,
+        construct: quoted(),
+        text: "a spread argument."
+      });
+      continue;
+    }
+    const possibles2 = resolveArgument(arg, analysis, reading.options.setup);
+    if (!possibles2) {
+      report(reading, {
+        kind: "argument",
+        offset: arg.start,
+        construct: quoted(),
+        text: "the argument is not a literal atom name."
+      });
+      continue;
+    }
+    for (const { value, node } of possibles2) judgeString(reading, use, value, node);
+  }
+}
+function refusedProblem(reading, use) {
+  if (use.isReexport && reading.options.isDeclared === true) return void 0;
+  return {
+    kind: use.isReexport ? "reexport" : "reference",
+    offset: use.node.start,
+    construct: "",
+    text: `${use.phrase ?? ""}.`,
+    ...use.isReexport && { isListable: use.isListable },
+    ...use.isRenamed === true && { isRenamed: true },
+    ...use.exportedAs && { exportedAs: use.exportedAs }
+  };
+}
+function readUse(reading, use, analysis) {
+  switch (use.kind) {
+    case "call": {
+      const before = reading.rewriting.attempts;
+      readCall(reading, use, analysis);
+      if (reading.rewriting.attempts === before) rewriteCx(reading, use.node, analysis);
+      break;
+    }
+    case "dynamic": {
+      const args = nodesAt(use.node, "arguments");
+      const construct = quoteCall(reading, use, args, `${use.local}.dynamic`);
+      reading.result.dynamicCalls.push({ offset: use.node.start, construct });
+      rewriteDynamic(reading, use.node, analysis);
+      break;
+    }
+    case "exposure": {
+      reading.result.exposes.set(use.exposedAs ?? use.local, { kind: "cx" });
+      break;
+    }
+    case "raw": {
+      rewriteRaw(reading, use.node, analysis);
+      break;
+    }
+    case "refused": {
+      const problem2 = refusedProblem(reading, use);
+      if (problem2) report(reading, problem2);
+      break;
+    }
+  }
+}
+function readUses(reading, program) {
+  const { code, options, result } = reading;
+  const analysis = analyze(program);
+  const bindings = cxBindingsOf(analysis, options.cxSources);
+  const frame = {
+    analysis,
+    code,
+    allowsExposure: options.isVueScript === true,
+    declaredSources: options.declaredSources
+  };
+  for (const reference2 of analysis.references) {
+    const cx = reference2.binding && bindings.get(reference2.binding);
+    const use = cx && useOf(frame, reference2, cx);
+    if (use) readUse(reading, use, analysis);
+    noteUse(reading.rewriting, cx, use);
+  }
+  for (const [name, exposure] of stringExposures(analysis)) result.exposes.set(name, exposure);
+  const setup = mergedExposures(options.setup, result.exposes);
+  const members = setup ? cxReadsOnSetup(analysis, setup) : [];
+  const withSetup = { ...reading, options: { ...options, setup } };
+  for (const member of members) {
+    readUse(withSetup, useOfExpression(frame, member, setupMemberName(member) ?? "cx"), analysis);
+  }
+  return { analysis, bindings };
+}
+function readModule(code, program, options) {
+  const escapedAtoms = refuseParenthesesAndFindEscapedAtoms(program);
+  const result = {
+    atoms: /* @__PURE__ */ new Set(),
+    classes: /* @__PURE__ */ new Set(),
+    problems: [],
+    dynamicCalls: [],
+    exposes: /* @__PURE__ */ new Map(),
+    usesCx: isImportingCx(program, options.cxSources),
+    edits: []
+  };
+  const reading = { code, options, result, seen: /* @__PURE__ */ new Set(), rewriting: newRewriting() };
+  const { analysis, bindings } = readUses(reading, program);
+  finishRewrite(reading, program, {
+    bindings,
+    hasDirectEval: analysis.hasDirectEval,
+    source: CX_SOURCE
+  });
+  const listed = options.isDeclared === true ? declaredExportProblems({
+    program,
+    analysis,
+    bindings,
+    cxSources: options.cxSources,
+    declaredSources: options.declaredSources ?? /* @__PURE__ */ new Set()
+  }) : [];
+  for (const problem2 of [...sourceFormProblems(code, program, options), ...listed]) {
+    report(reading, problem2);
+  }
+  for (const atom of atomsWrittenIn(code)) result.classes.add(atom);
+  for (const atom of escapedAtoms) result.classes.add(atom);
+  if (result.usesCx || !options.isDependency) {
+    for (const problem2 of concatenationProblems(program, code, analysis)) report(reading, problem2);
+  }
+  return result;
+}
+
+// src/vite-options.ts
+function unknownAtomText(name) {
+  const hint = hintFor(name);
+  return hint ? ` ${hint}` : "";
+}
+function problemWithName(where, name, own) {
+  if (typeof name === "string" && isBuiltInAtom(name)) return void 0;
+  if (typeof name === "string" && own === void 0) return void 0;
+  if (typeof name === "string" && own?.has(name)) {
+    return `navePlugin(): ${where} names "${name}", an atom of your own; those have no class, so there is nothing to keep.`;
+  }
+  const spelled = typeof name === "string" ? name : String(name);
+  return `navePlugin(): ${where} names an unknown atom "${spelled}".${unknownAtomText(spelled)}`;
+}
+function problemsInList(where, list, own) {
+  if (!Array.isArray(list)) return [`navePlugin(): ${where} must be an array of atom names.`];
+  return Array.from(list, (name) => problemWithName(where, name, own) ?? []).flat();
+}
+function problemsInKeepFor(keepFor, own) {
+  if (typeof keepFor !== "object" || keepFor === null || Array.isArray(keepFor)) {
+    return ["navePlugin(): keepFor must be an object from package names to arrays of atom names."];
+  }
+  const problems = [];
+  for (const [pkg, list] of Object.entries(keepFor)) {
+    problems.push(...problemsInList(`keepFor["${pkg}"]`, list, own));
+  }
+  return problems;
+}
+function problemsInCxModules(cxModules) {
+  if (!Array.isArray(cxModules)) {
+    return ["navePlugin(): cxModules must be an array of module paths or specifiers."];
+  }
+  return Array.from(
+    cxModules,
+    (entry, index) => typeof entry === "string" ? [] : `navePlugin(): cxModules[${index}] must be a string: a module path or a specifier.`
+  ).flat();
+}
+function problemsInOptions(options, own) {
+  const problems = [];
+  const { atomic, keep, keepFor, cxModules } = options;
+  if (atomic !== void 0 && atomic !== "all" && atomic !== "used") {
+    problems.push("navePlugin(): atomic must be 'used' or 'all'.");
+  }
+  if (keep !== void 0) problems.push(...problemsInList("keep", keep, own));
+  if (keepFor !== void 0) problems.push(...problemsInKeepFor(keepFor, own));
+  if (cxModules !== void 0) problems.push(...problemsInCxModules(cxModules));
+  return problems;
+}
+function assertOptions(options, own) {
+  const [first2] = problemsInOptions(options, own);
+  if (first2 !== void 0) throw new Error(first2);
+}
+function resolveUsedOptions(options) {
+  return {
+    atomic: options.atomic ?? "used",
+    keep: [...options.keep ?? []],
+    keepFor: Object.fromEntries(
+      Object.entries(options.keepFor ?? {}).map(([pkg, list]) => [pkg, [...list]])
+    ),
+    cxModules: [...options.cxModules ?? []]
+  };
+}
+function keptAtoms(options) {
+  return [.../* @__PURE__ */ new Set([...options.keep, ...Object.values(options.keepFor).flat()])];
+}
+
+// src/vite-css-blocks.ts
+function matchBraces(tokens) {
+  const matches = /* @__PURE__ */ new Map();
+  const open = [];
+  for (const [index, token] of tokens.entries()) {
+    if (token.type === "{-token") open.push(index);
+    else if (token.type === "}-token" && open.length > 0) matches.set(open.pop(), index);
+  }
+  return matches;
+}
+function isBlank(tokens, from, to) {
+  for (let index = from; index < to; index += 1) {
+    const type = tokens[index].type;
+    if (type !== "whitespace-token" && type !== "comment") return false;
+  }
+  return true;
+}
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token"]);
+function readSheet(css) {
+  const tokens = tokenize(css);
+  const matches = matchBraces(tokens);
+  return {
+    tokens,
+    slice: (from, to) => css.slice(tokens[from]?.startIndex ?? css.length, tokens[to - 1]?.endIndex ?? 0),
+    statements(from, to) {
+      const found = [];
+      let start = from;
+      let index = from;
+      let depth = 0;
+      while (index < to) {
+        const type = tokens[index].type;
+        if (OPENERS.has(type)) depth += 1;
+        else if (CLOSERS.has(type)) depth = Math.max(0, depth - 1);
+        const close = type === "{-token" && depth === 0 ? matches.get(index) : void 0;
+        if (close !== void 0 && close < to) {
+          found.push({ from: start, to: close + 1, open: index, close });
+          index = close + 1;
+          start = index;
+        } else if (type === "semicolon-token") {
+          found.push({ from: start, to: index + 1 });
+          index += 1;
+          start = index;
+        } else {
+          index += 1;
+        }
+      }
+      if (!isBlank(tokens, start, to)) found.push({ from: start, to });
+      return found;
+    }
+  };
+}
+function firstSignificant(tokens, from, to) {
+  let index = from;
+  while (index < to && isBlank(tokens, index, index + 1)) index += 1;
+  return index;
+}
+
+// src/vite-selector-atoms.ts
+var OPENERS2 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token"]);
+var CLOSERS2 = /* @__PURE__ */ new Set([")-token", "]-token"]);
+function membersOf(sheet, from, to) {
+  const members = [];
+  let start = from;
+  let depth = 0;
+  for (let index = from; index < to; index += 1) {
+    const type = sheet.tokens[index].type;
+    if (OPENERS2.has(type)) depth += 1;
+    else if (CLOSERS2.has(type)) depth -= 1;
+    else if (type === "comma-token" && depth === 0) {
+      members.push([start, index]);
+      start = index + 1;
+    }
+  }
+  members.push([start, to]);
+  return members;
+}
+var closings = /* @__PURE__ */ new WeakMap();
+function closesOf(sheet) {
+  const known = closings.get(sheet);
+  if (known) return known;
+  const closes = /* @__PURE__ */ new Map();
+  const open = [];
+  for (const [index, token] of sheet.tokens.entries()) {
+    if (OPENERS2.has(token.type)) open.push(index);
+    else if (CLOSERS2.has(token.type) && open.length > 0) closes.set(open.pop(), index);
+  }
+  closings.set(sheet, closes);
+  return closes;
+}
+function afterGroup(sheet, index, to) {
+  return Math.min((closesOf(sheet).get(index) ?? to - 1) + 1, to);
+}
+function isTransparentList(sheet, index) {
+  const token = sheet.tokens[index];
+  if (token.type !== "function-token" || sheet.tokens[index - 1]?.type !== "colon-token") {
+    return false;
+  }
+  const name = token.structured.value.toLowerCase();
+  return name === "is" || name === "where";
+}
+function atomAt(sheet, index, to) {
+  const name = sheet.tokens[index + 1];
+  if (index + 1 >= to || name?.type !== "ident-token") return void 0;
+  const dot = sheet.tokens[index];
+  if (dot.type !== "delim-token" || dot.raw !== ".") return void 0;
+  return atomOfClass(name.structured.value);
+}
+function atomsNamedBy(sheet, from, to) {
+  const atoms = [];
+  let index = from;
+  while (index < to) {
+    const isGroup = OPENERS2.has(sheet.tokens[index].type);
+    if (isGroup && !isTransparentList(sheet, index)) {
+      index = afterGroup(sheet, index, to);
+      continue;
+    }
+    const atom = isGroup ? void 0 : atomAt(sheet, index, to);
+    if (atom) atoms.push(atom);
+    index += 1;
+  }
+  return atoms;
+}
+var newNeeds = () => ({ parts: [], size: 0 });
+var newList = () => ({ finished: [], current: newNeeds() });
+function closeList(done, parent) {
+  const all = [...done.finished, done.current];
+  if (all.some((needs) => needs.size === 0)) return;
+  for (const needs of all) {
+    parent.current.parts.push(needs.parts);
+    parent.current.size += needs.size;
+  }
+}
+function flatten(parts) {
+  const atoms = [];
+  const stack = [parts];
+  while (stack.length > 0) {
+    const part = stack.pop();
+    if (typeof part === "string") atoms.push(part);
+    else for (let index = part.length - 1; index >= 0; index -= 1) stack.push(part[index]);
+  }
+  return atoms;
+}
+function readToken(sheet, index, limit, lists) {
+  const type = sheet.tokens[index].type;
+  const list = lists.at(-1);
+  const isNested = lists.length > 1;
+  if (OPENERS2.has(type)) {
+    if (!isTransparentList(sheet, index)) return afterGroup(sheet, index, limit.to);
+    lists.push(newList());
+  } else if (isNested && type === ")-token") {
+    closeList(lists.pop(), lists.at(-1));
+  } else if (isNested && type === "comma-token") {
+    list.finished.push(list.current);
+    list.current = newNeeds();
+  } else {
+    const atom = atomAt(sheet, index, limit.to);
+    if (atom && !limit.emitted.has(atom)) {
+      list.current.parts.push(atom);
+      list.current.size += 1;
+    }
+  }
+  return index + 1;
+}
+function blockersOf(sheet, from, to, emitted) {
+  const lists = [newList()];
+  let index = from;
+  while (index < to) index = readToken(sheet, index, { emitted, to }, lists);
+  while (lists.length > 1) closeList(lists.pop(), lists.at(-1));
+  return flatten(lists[0].current.parts);
+}
+
+// src/vite-prune.ts
+var GROUPS = /* @__PURE__ */ new Set([
+  "container",
+  "document",
+  "layer",
+  "media",
+  "scope",
+  "starting-style",
+  "supports"
+]);
+function atKeywordAt(sheet, index) {
+  const token = sheet.tokens[index];
+  if (token?.type !== "at-keyword-token") return void 0;
+  return token.structured.value.toLowerCase();
+}
+function isAtomicLayer(sheet, statement) {
+  if (statement.open === void 0) return false;
+  const significant = [];
+  for (let index = statement.from; index < statement.open; index += 1) {
+    const type = sheet.tokens[index].type;
+    if (type !== "whitespace-token" && type !== "comment") significant.push(index);
+  }
+  const name = sheet.tokens[significant[1] ?? -1];
+  return significant.length === 2 && atKeywordAt(sheet, significant[0]) === "layer" && name?.type === "ident-token" && name.structured.value === "atomic";
+}
+var CONDITIONALS = /* @__PURE__ */ new Set(["container", "document", "media", "scope", "supports"]);
+function layerBlocks(sheet, from, to) {
+  const found = [];
+  for (const statement of sheet.statements(from, to)) {
+    const { open, close } = statement;
+    if (open === void 0 || close === void 0) continue;
+    if (isAtomicLayer(sheet, statement)) found.push(statement);
+    else {
+      const keyword = atKeywordAt(sheet, firstSignificant(sheet.tokens, statement.from, open));
+      if (keyword !== void 0 && CONDITIONALS.has(keyword)) {
+        found.push(...layerBlocks(sheet, open + 1, close));
+      }
+    }
+  }
+  return found;
+}
+function isEmptyRegion(sheet, from, to) {
+  return sheet.statements(from, to).length === 0;
+}
+function pruneRule(sheet, statement, emitted) {
+  const { from, open, close } = statement;
+  const first2 = firstSignificant(sheet.tokens, from, open);
+  const members = membersOf(sheet, first2, open);
+  const kept = members.filter(([start, end]) => blockersOf(sheet, start, end, emitted).length === 0);
+  if (kept.length === members.length) return sheet.slice(from, close + 1);
+  if (kept.length === 0) return "";
+  let trailing = open;
+  while (trailing > first2 && firstSignificant(sheet.tokens, trailing - 1, trailing) === trailing) {
+    trailing -= 1;
+  }
+  const list = sheet.slice(first2, trailing);
+  const separator = /,\s/.test(list) ? ", " : ",";
+  const text = kept.map(([start, end]) => sheet.slice(start, end).trim()).join(separator);
+  return `${sheet.slice(from, first2)}${text}${sheet.slice(trailing, open)}${sheet.slice(open, close + 1)}`;
+}
+function pruneRegion(sheet, from, to, emitted) {
+  const statements = sheet.statements(from, to);
+  let out = "";
+  for (const statement of statements) out += pruneStatement(sheet, statement, emitted);
+  const last = statements.at(-1);
+  return last ? out + sheet.slice(last.to, to) : sheet.slice(from, to);
+}
+function pruneStatement(sheet, statement, emitted) {
+  const { open, close } = statement;
+  if (open === void 0 || close === void 0) return sheet.slice(statement.from, statement.to);
+  const first2 = firstSignificant(sheet.tokens, statement.from, open);
+  const keyword = atKeywordAt(sheet, first2);
+  if (keyword === void 0) return pruneRule(sheet, statement, emitted);
+  if (!GROUPS.has(keyword)) return sheet.slice(statement.from, close + 1);
+  if (isEmptyRegion(sheet, open + 1, close)) return sheet.slice(statement.from, close + 1);
+  const inner = pruneRegion(sheet, open + 1, close, emitted);
+  if (inner.trim() === "") return "";
+  return `${sheet.slice(statement.from, open + 1)}${inner}}`;
+}
+function pruneAtomicLayer(css, emitted) {
+  if (!css.includes("@")) return css;
+  const sheet = readSheet(css);
+  let out = "";
+  let cursor = 0;
+  for (const statement of layerBlocks(sheet, 0, sheet.tokens.length)) {
+    const { open, close } = statement;
+    out += sheet.slice(cursor, open + 1) + pruneRegion(sheet, open + 1, close, emitted);
+    cursor = close;
+  }
+  return cursor === 0 ? css : out + sheet.slice(cursor, sheet.tokens.length);
+}
+function visitMembers(sheet, from, to, visit2) {
+  for (const statement of sheet.statements(from, to)) {
+    const { open, close } = statement;
+    if (open === void 0 || close === void 0) continue;
+    const first2 = firstSignificant(sheet.tokens, statement.from, open);
+    const keyword = atKeywordAt(sheet, first2);
+    if (keyword === void 0) {
+      for (const [start, end] of membersOf(sheet, first2, open)) visit2(start, end);
+    } else if (GROUPS.has(keyword)) {
+      visitMembers(sheet, open + 1, close, visit2);
+    }
+  }
+}
+function inspectAtomicLayer(css) {
+  const atoms = /* @__PURE__ */ new Set();
+  if (!css.includes("@")) return { hasLayer: false, atoms };
+  const sheet = readSheet(css);
+  const blocks = layerBlocks(sheet, 0, sheet.tokens.length);
+  for (const { open, close } of blocks) {
+    visitMembers(sheet, open + 1, close, (start, end) => {
+      for (const atom of atomsNamedBy(sheet, start, end)) atoms.add(atom);
+    });
+  }
+  return { hasLayer: blocks.length > 0, atoms };
+}
+function unprunedAtoms(css, emitted) {
+  if (!css.includes("@")) return [];
+  const atoms = /* @__PURE__ */ new Set();
+  const sheet = readSheet(css);
+  for (const { open, close } of layerBlocks(sheet, 0, sheet.tokens.length)) {
+    visitMembers(sheet, open + 1, close, (start, end) => {
+      for (const atom of blockersOf(sheet, start, end, emitted)) atoms.add(atom);
+    });
+  }
+  return [...atoms].toSorted((a, b) => a.localeCompare(b));
+}
+
+// src/vite-restorers.ts
+function withRestorers(atoms) {
+  if (atoms.has("srOnly")) atoms.add("srOnlyFocusable");
+  return atoms;
+}
+
+// src/vite-problems.ts
+var PROBLEM_KINDS = [
+  "argument",
+  "reference",
+  "reexport",
+  "declared",
+  "concatenation",
+  "dynamic",
+  "unknown",
+  "own",
+  "unreadable"
+];
+function compareText(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function cxModulesArray(configured, added) {
+  const extra = [...new Set(added)].filter((entry) => !configured.includes(entry)).toSorted(compareText);
+  if (extra.length === 0) return void 0;
+  return `[${[...configured, ...extra].map((entry) => `'${entry}'`).join(", ")}]`;
+}
+function cut(text, limit = 40) {
+  const oneLine = text.replaceAll(/\s+/g, " ");
+  return oneLine.length > limit ? `${oneLine.slice(0, limit)}...` : oneLine;
+}
+
+// src/vite-class-map-message.ts
+var CLASS_MAP_NOT_PARSED = "the module could not be read, so the atoms it names would not ship: it is a CSS Module, and the JavaScript Vite wrote for its class map did not parse. A plugin that runs after Vite's CSS step has changed that JavaScript: have that plugin leave a CSS Module's JavaScript valid.";
+
+// src/vite-used-take-lines.ts
+var IDENTIFIER = /^[$\p{ID_Start}_][$\p{ID_Continue}]*$/u;
+function takenName(name) {
+  if (name === "default") return "the default export";
+  if (IDENTIFIER.test(name)) return name;
+  return `'${name.replaceAll("\\", String.raw`\\`).replaceAll("'", String.raw`\'`)}'`;
+}
+function takeWhat(take) {
+  const names = take.names.map((name) => takenName(name)).join(", ");
+  switch (take.shape) {
+    case "dynamic-import": {
+      return names === "" ? "import()" : `import() reading ${names}`;
+    }
+    case "names": {
+      return names;
+    }
+    case "namespace": {
+      return names === "" ? "a namespace import" : `a namespace import reading ${names}`;
+    }
+    case "star": {
+      return "export *";
+    }
+    case "unreadable": {
+      return "a require() or other import the build cannot read";
+    }
+  }
+}
+var FIX = " The lasting fix is upstream: import cx from @navecss/core/cx where it is called, and re-export it from there, only under the name cx, in each module that gives it out.";
+function clausesOf(takes) {
+  const entries = takes.map((take) => ({
+    taker: take.taker,
+    text: `${take.taker} (${takeWhat(take)})`,
+    shape: take.shape
+  })).toSorted((a, b) => compareText(a.taker, b.taker) || compareText(a.text, b.text));
+  const listed = [...new Set(entries.map((entry) => entry.text))].join(", ");
+  const files = new Set(entries.map((entry) => entry.taker)).size === 1 ? "in that file" : "in each of those files";
+  const isWhole = entries.some((entry) => entry.shape !== "names");
+  const wholeClause = isWhole ? "; where a file takes a module whole (a namespace import, export *, import() or an import the build cannot read), import by name what it uses from that module, and cx from @navecss/core/cx" : "";
+  const passedOn = takes.some((take) => take.isPassedOn === true) ? "; where a file re-exports what it takes, import cx from @navecss/core/cx in the files that call it, call cx there in its place, and drop the re-export" : "";
+  return { files, listed, whole: `${wholeClause}${passedOn}` };
+}
+function takenLine(pkg, takes, hasPackageFix) {
+  const { files, listed, whole } = clausesOf(takes);
+  const fix = hasPackageFix ? FIX : "";
+  return `${pkg} re-exports cx, and your code takes that cx, from the package or through another package that re-exports it, in ${listed}. The build does not read calls made through what your code takes there, and the keepFor entry stands in only for the package's own calls: ${files}, import cx from @navecss/core/cx instead and call cx in its place${whole}. The build prints no cxModules entry for this, since it found none of these takes made, by an import it can read and a specifier that resolves from Vite's root, from a module that re-exports cx from @navecss/core/cx itself and only under the name cx. Once your code makes none of these takes, the keepFor entry clears this.${fix}`;
+}
+function forwardLine(pkg, takes) {
+  const { files, listed, whole } = clausesOf(takes);
+  return `${pkg} re-exports the cx of a module listed in cxModules, and your code takes that cx, from ${pkg} or through another package that re-exports it, in ${listed}. The build follows a listed module one step, so it does not read calls made through what your code takes there: ${files}, import cx from @navecss/core/cx instead and call cx in its place${whole}.${FIX}`;
+}
+function callsThroughLine(pkg, callers, home) {
+  const [make, owner, its] = callers.length === 1 ? ["makes", "a dependency's", "its"] : ["make", "dependencies'", "their"];
+  return `${pkg} re-exports the cx of a module listed in cxModules, and the build follows a listed module one step, so it does not read the calls that ${callers.join(", ")} ${make} through that re-export. That code is ${owner}, not yours to change: list the atoms those calls can produce, from ${its} documentation, under the name of ${pkg}, which holds the re-export, in ${home}: keepFor: { '${pkg}': ['<atom>'] }. The lasting fix is upstream: ${pkg} can re-export cx from @navecss/core/cx itself, or the code that calls through it can import cx from there.`;
+}
+
+// src/vite-used-package-lines.ts
+function isListableReexport(problem2) {
+  return problem2.kind === "reexport" && problem2.isListable !== false;
+}
+function isRenamedOrReached(problem2) {
+  return problem2.isRenamed === true || problem2.kind === "reexport" && !isListableReexport(problem2);
+}
+function isSecondHop(problem2) {
+  return problem2.kind === "reexport" && problem2.isListable === false && problem2.pkg !== void 0;
+}
+function callsLine(pkg, problems, entry) {
+  if (problems.every((problem2) => problem2.kind === "own")) {
+    return `${pkg} names atoms of your own, which have no class, so a keepFor entry cannot make its calls produce a Nave class. The fix is the package's: it must name atoms Nave ships.`;
+  }
+  const isOnlyDynamic = problems.every((problem2) => problem2.kind === "dynamic");
+  if (isOnlyDynamic) {
+    const count = problems.length;
+    const places = count === 1 ? "1 place" : `${count} places`;
+    return `${pkg} calls cx.dynamic() in ${places}, and keepFor lists no atoms for it, so none of them applies a class. List the atoms those calls can take, from its documentation, under its name in ${entry}.`;
+  }
+  return `${pkg} is a dependency, so its code is not yours to change. List the atoms its calls can produce, from its documentation, under its name in ${entry}. The lasting fix is the package's: names chosen at run time go through cx.dynamic().`;
+}
+var LASTING_FIX = "The lasting fix is the package's: import cx from @navecss/core/cx where it is called, or re-export it from the package's entry.";
+function listedLine(pkg, specifiers, configured, home) {
+  const array = cxModulesArray(configured, specifiers);
+  const named = specifiers.map((specifier) => `'${specifier}'`).join(", ");
+  const it = specifiers.length === 1 ? "it" : "them";
+  return array === void 0 ? void 0 : `${pkg} re-exports cx in ${named}. List ${it} in ${home}: cxModules: ${array}.`;
+}
+function internalLine(pkg, count, entry, hasKeepFor) {
+  if (hasKeepFor) {
+    return `${pkg} also re-exports cx in a file that only the package itself imports; the keepFor entry above clears that too. The build does not read calls made through that cx: where your code imports cx from ${pkg} or one of its subpaths, import it from @navecss/core/cx instead. The lasting fix there is the package's: import cx from @navecss/core/cx where it is called, or re-export it from the package's entry.`;
+  }
+  const [file, them] = count === 1 ? ["a file that only", "it"] : ["files that only", "them"];
+  return `${pkg} re-exports cx in ${file} the package itself imports, so your code has no specifier for ${them} to list in cxModules, and the build does not read calls made through that cx. Where your code imports cx from ${pkg} or one of its subpaths, import it from @navecss/core/cx instead. For the package's own calls, list the atoms they can produce, from its documentation, under its name in ${entry}. ${LASTING_FIX}`;
+}
+var RENAMED_FIX = "import cx from @navecss/core/cx where it is called, and re-export it only under the name cx.";
+var RENAMED_FORM = "other than under the name cx (renamed, as a default or inside a namespace)";
+function renamedLine(pkg, count, entry, hasKeepFor) {
+  const [those, them, its] = count === 1 ? ["that export", "it", "its"] : ["those exports", "them", "their"];
+  const act = `import cx from @navecss/core/cx instead and call cx in ${its} place`;
+  if (hasKeepFor) {
+    return `${pkg} also re-exports cx ${RENAMED_FORM}, and no cxModules entry clears an export of cx from a module that does, under the name cx or another; the keepFor entry above clears ${those} too. The build does not read calls made through ${them}: where your code imports ${them} from ${pkg} or one of its subpaths, ${act}. The lasting fix there is the package's: ${RENAMED_FIX}`;
+  }
+  return `${pkg} re-exports cx ${RENAMED_FORM}, which the build does not follow even from a module listed in cxModules. Listing a module that does fails the build, so no entry there clears an export of cx from it, under the name cx or another, and the build does not read calls made through ${those}. Where your code imports ${those} from ${pkg} or one of its subpaths, ${act}. For the package's own calls, list the atoms they can produce, from its documentation, under its name in ${entry}. The lasting fix is the package's: ${RENAMED_FIX}`;
+}
+function declaredLine(pkg, entries, hasInternal, home) {
+  const named = entries.map((entry) => `'${entry}'`).join(", ");
+  const [is, it, module] = entries.length === 1 ? ["is", "it", "the module"] : ["are", "them", "each module"];
+  const reader = hasInternal ? "" : `, and where your code imports cx from ${it}, import cx from @navecss/core/cx instead`;
+  return `${pkg} exports a cx the build does not follow from ${named}, which ${is} listed in cxModules. Remove ${it} from cxModules in ${home}${reader}. The lasting fix is the package's: make export { cx } from '@navecss/core/cx' the only export of cx in ${module} you list.`;
+}
+function withoutRemoved(problems, configured) {
+  const removed = new Set(
+    problems.flatMap(
+      (problem2) => problem2.pkg !== void 0 && problem2.kind === "declared" ? problem2.entries ?? [] : []
+    )
+  );
+  return configured.filter((entry) => !removed.has(entry));
+}
+function takeLines(pkg, all, home) {
+  const isTaken = (problem2) => (problem2.takes?.length ?? 0) > 0;
+  const taken = all.filter((problem2) => isTaken(problem2));
+  const plain = taken.filter((problem2) => !isSecondHop(problem2));
+  const hops = taken.filter((problem2) => isSecondHop(problem2));
+  const takes = plain.flatMap((problem2) => problem2.takes);
+  const lines = [];
+  if (takes.length > 0) {
+    const hasPackageFix = plain.some((problem2) => isRenamedOrReached(problem2)) || takes.some((take) => take.isReached);
+    lines.push(takenLine(pkg, takes, hasPackageFix));
+  }
+  if (hops.length > 0)
+    lines.push(
+      forwardLine(
+        pkg,
+        hops.flatMap((problem2) => problem2.takes)
+      )
+    );
+  const callers = all.flatMap((problem2) => problem2.callers ?? []);
+  if (callers.length > 0)
+    lines.push(callsThroughLine(pkg, [...new Set(callers)].toSorted(compareText), home));
+  return lines;
+}
+function packageLines(pkg, all, configured, home) {
+  const isTaken = (problem2) => (problem2.takes?.length ?? 0) > 0;
+  const problems = all.filter((problem2) => !isTaken(problem2) && problem2.callers === void 0);
+  const entry = `${home}: keepFor: { '${pkg}': ['<atom>'] }`;
+  const reexports = problems.filter((problem2) => isListableReexport(problem2));
+  const internal = reexports.filter(
+    (problem2) => problem2.specifier === void 0 && problem2.isRenamed !== true
+  );
+  const renamed = reexports.filter((problem2) => problem2.isRenamed === true);
+  const declared = problems.filter((problem2) => problem2.kind === "declared");
+  const rest = problems.filter(
+    (problem2) => !isListableReexport(problem2) && problem2.kind !== "declared" && problem2.text !== CLASS_MAP_NOT_PARSED
+  );
+  const named = [...new Set(reexports.flatMap((problem2) => problem2.specifier ?? []))].toSorted(
+    compareText
+  );
+  const lines = [];
+  if (declared.length > 0) {
+    const entries = [...new Set(declared.flatMap((problem2) => problem2.entries ?? []))];
+    lines.push(declaredLine(pkg, entries.toSorted(compareText), internal.length > 0, home));
+  }
+  if (rest.length > 0) lines.push(callsLine(pkg, rest, entry));
+  const listed = named.length > 0 ? listedLine(pkg, named, configured, home) : void 0;
+  if (listed !== void 0) lines.push(listed);
+  if (internal.length > 0) {
+    const files = new Set(internal.map((problem2) => problem2.file)).size;
+    const hasKeepFor = rest.some((problem2) => problem2.kind !== "own");
+    lines.push(internalLine(pkg, files, entry, hasKeepFor));
+  }
+  if (renamed.length > 0) {
+    const hasKeepFor = rest.some((problem2) => problem2.kind !== "own") || internal.length > 0;
+    lines.push(renamedLine(pkg, renamed.length, entry, hasKeepFor));
+  }
+  lines.push(...takeLines(pkg, all, home));
+  return lines;
+}
+
+// src/vite-used-report.ts
+var LINE_UNKNOWN_WITHOUT_MAP = " (line unknown: this file's compiled code has no source map in this build; with build.sourcemap set in the Vite config, the report gives the line if the source maps then lead back to it)";
+var LINE_UNKNOWN_UNMAPPED = " (line unknown: no source map leads from the compiled code to this file)";
+var REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
+var remedies = (home) => ({
+  argument: [
+    "Name the atoms at the call: a string literal, a const in the same file, or a condition choosing between them, as in cx(on ? 'flex' : 'grid').",
+    "To choose by a value, call cx() once per case and pick between the results: ({ row: cx('flex'), grid: cx('grid') })[variant].",
+    `If the name comes from data the build never sees, write cx.dynamic(name) and list every atom it can take in keep in ${home}.`
+  ],
+  reference: [
+    "Call cx() where the classes are applied, with the atom names as its arguments: the build reads calls, not a cx that is assigned, passed or spread."
+  ],
+  // Printed by `reexportRemedy`, which names the modules a `cxModules` entry would clear.
+  reexport: [],
+  declared: [
+    "In a module listed in cxModules, make export { cx } from '@navecss/core/cx' its only export of cx, or remove the module from cxModules and import cx from @navecss/core/cx where it is called."
+  ],
+  concatenation: [
+    "Write cx() with the atom name, or cx.dynamic() with keep for a name chosen at run time."
+  ],
+  dynamic: [`List the atoms those calls can take in keep in ${home}.`],
+  unknown: [],
+  own: [],
+  unreadable: []
+});
+function problemLine(problem2) {
+  const where = problem2.unknownLine === void 0 ? `${problem2.file}:${problem2.line}:${problem2.column}: ` : `${problem2.file}: `;
+  const ending = problem2.unknownLine ?? "";
+  if (problem2.construct === "") return `${where}${problem2.text}${ending}`;
+  const construct = cut(problem2.construct);
+  return problem2.text === "" ? `${where}${construct}${ending}` : `${where}${construct}: ${problem2.text}${ending}`;
+}
+function reexportRemedy(problems, configured, home) {
+  const modules = problems.filter((problem2) => isListableReexport(problem2)).map((problem2) => problem2.file.startsWith(".") ? problem2.file : `./${problem2.file}`);
+  const array = cxModulesArray(configured, modules);
+  const lines = array === void 0 ? [] : [
+    `To keep a module that re-exports cx, list it in ${home} by its path from the project root: cxModules: ${array}. Files that import cx from it are then read as if they imported it from @navecss/core/cx. Or import cx from @navecss/core/cx directly where it is called.`
+  ];
+  if (problems.some((problem2) => problem2.kind === "reexport" && !isListableReexport(problem2))) {
+    lines.push(
+      "Import cx where it is called, from @navecss/core/cx or from a module listed in cxModules, instead of re-exporting the cx of a listed module."
+    );
+  }
+  return lines;
+}
+function applicationLines(application, configured, home) {
+  const fixed = remedies(home);
+  const lines = [];
+  for (const kind of PROBLEM_KINDS) {
+    if (application.every((problem2) => problem2.kind !== kind)) continue;
+    lines.push(
+      ...kind === "reexport" ? reexportRemedy(application, configured, home) : fixed[kind]
+    );
+  }
+  return lines;
+}
+function remedyBlock(problems, listed, home, hostRemedies) {
+  const configured = withoutRemoved(problems, listed);
+  const application = problems.filter((problem2) => problem2.pkg === void 0);
+  const lines = [
+    ...applicationLines(application, configured, home),
+    ...hostRemedies?.(application) ?? []
+  ];
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const problem2 of problems) {
+    if (problem2.pkg !== void 0)
+      byPackage.set(problem2.pkg, [...byPackage.get(problem2.pkg) ?? [], problem2]);
+  }
+  for (const pkg of byPackage.keys().toArray().toSorted(compareText)) {
+    lines.push(...packageLines(pkg, byPackage.get(pkg), configured, home));
+  }
+  if (application.some((problem2) => problem2.needsAvailable)) lines.push(availableLine());
+  return lines;
+}
+function inReportOrder(problems) {
+  const rank = (problem2) => problem2.pkg === void 0 ? 0 : 1;
+  return problems.toSorted(
+    (a, b) => rank(a) - rank(b) || compareText(a.file, b.file) || Number(a.unknownLine !== void 0) - Number(b.unknownLine !== void 0) || a.line - b.line || a.column - b.column
+  );
+}
+function problemLines(problems) {
+  const ordered = inReportOrder(problems);
+  const isApplicationDynamic = (problem2) => problem2.kind === "dynamic" && problem2.pkg === void 0;
+  const application = ordered.filter(
+    (problem2) => problem2.pkg === void 0 && !isApplicationDynamic(problem2)
+  );
+  const dynamic = ordered.filter((problem2) => isApplicationDynamic(problem2));
+  const dependencies = ordered.filter((problem2) => problem2.pkg !== void 0);
+  const lines = application.map((problem2) => problemLine(problem2));
+  if (dynamic.length > 0) {
+    const places = dynamic.length === 1 ? "1 place" : `${dynamic.length} places`;
+    lines.push(
+      `cx.dynamic() is called in ${places} in your code, but keep is empty, so none of them applies a class.`,
+      ...dynamic.map((problem2) => problemLine(problem2))
+    );
+  }
+  return [...lines, ...dependencies.map((problem2) => problemLine(problem2))];
+}
+function noun(count, word) {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function buildReport(problems, configured, home, hostRemedies) {
+  const files = new Set(problems.map((problem2) => problem2.file)).size;
+  const first2 = `${noun(problems.length, "problem")} in ${noun(files, "file")}: ${REPORT_CAUSE}`;
+  return [
+    first2,
+    ...problemLines(problems),
+    ...remedyBlock(problems, configured, home, hostRemedies)
+  ].join("\n");
+}
+function moduleReport(problems, configured, home) {
+  return [...problemLines(problems), ...remedyBlock(problems, configured, home)].join("\n");
+}
+
+export { CLASS_MAP_NOT_PARSED, CX_SOURCE, LINE_UNKNOWN_UNMAPPED, LINE_UNKNOWN_WITHOUT_MAP, REPORT_CAUSE, analyze, applyEdits, assertOptions, atomOfClass, atomsWrittenIn, buildReport, childrenOf, combinedMapOf, compareText, cxModulesArray, exportNameOf, inspectAtomicLayer, isListableReexport, isNode, isSecondHop, keptAtoms, memberReadOf, moduleReport, nodeAt, nodesAt, patternDestructuring, placerFor, propertyNameOf, pruneAtomicLayer, pushAll, readModule, resolveUsedOptions, staticStringOf, stringAt, toSourceMap, unprunedAtoms, withRestorers, withoutRemoved };