@navecss/core 0.4.0 → 0.5.0

package/dist/{chunk-E5F6YF7A.js → chunk-BCUK4M4P.js}

@@ -1,4 +1,5 @@
 import { decodeIncomingMap, MappingsBuilder, formatDiagnostic } from './chunk-SYNQJNVB.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
 import { atomClassMap } from './chunk-GZL2VW7C.js';
 
 // src/vite-ast.ts
@@ -1045,6 +1046,21 @@ function escapedText(node) {
   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();
@@ -1053,8 +1069,9 @@ function refuseParenthesesAndFindEscapedAtoms(program) {
     const node = stack.pop();
     if (node.type === "ParenthesizedExpression") throw new TypeError(PARENTHESES_KEPT);
     const text = escapedText(node);
-    if (text?.raw.includes("\\")) {
-      for (const atom of atomsWrittenIn(text.decoded)) found.add(atom);
+    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));
   }
@@ -2120,6 +2137,312 @@ 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",
@@ -2146,6 +2469,9 @@ function cut(text, limit = 40) {
   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) {
@@ -2295,7 +2621,7 @@ function packageLines(pkg, all, configured, home) {
   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) => !isListableReexport(problem2) && problem2.kind !== "declared" && problem2.text !== CLASS_MAP_NOT_PARSED
   );
   const named = [...new Set(reexports.flatMap((problem2) => problem2.specifier ?? []))].toSorted(
     compareText
@@ -2367,10 +2693,8 @@ function reexportRemedy(problems, configured, home) {
   }
   return lines;
 }
-function remedyBlock(problems, listed, home) {
-  const configured = withoutRemoved(problems, listed);
+function applicationLines(application, configured, home) {
   const fixed = remedies(home);
-  const application = problems.filter((problem2) => problem2.pkg === void 0);
   const lines = [];
   for (const kind of PROBLEM_KINDS) {
     if (application.every((problem2) => problem2.kind !== kind)) continue;
@@ -2378,6 +2702,15 @@ function remedyBlock(problems, listed, home) {
       ...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)
@@ -2416,13 +2749,17 @@ function problemLines(problems) {
 function noun(count, word) {
   return `${count} ${word}${count === 1 ? "" : "s"}`;
 }
-function buildReport(problems, configured, home) {
+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)].join("\n");
+  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 { CX_SOURCE, LINE_UNKNOWN_UNMAPPED, LINE_UNKNOWN_WITHOUT_MAP, REPORT_CAUSE, analyze, applyEdits, assertOptions, atomOfClass, atomsWrittenIn, buildReport, childrenOf, combinedMapOf, compareText, cxModulesArray, exportNameOf, isListableReexport, isSecondHop, keptAtoms, memberReadOf, moduleReport, nodeAt, nodesAt, patternDestructuring, placerFor, propertyNameOf, pushAll, readModule, resolveUsedOptions, staticStringOf, stringAt, toSourceMap, withoutRemoved };
+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 };

package/dist/{chunk-XQQCDUV6.js → chunk-CTFEYJBE.js}

@@ -1,4 +1,4 @@
-import { findingsInText } from './chunk-UANF3FGO.js';
+import { findingsInText } from './chunk-ZNTNLGEC.js';
 import { readFile, stat, realpath, readdir } from 'fs/promises';
 import path from 'path';
 

package/dist/{chunk-2A7IUZBH.js → chunk-KKUYU75D.js}

@@ -1,16 +1,16 @@
-import { foldLocated } from './chunk-LADFXRWQ.js';
+import { foldLocated } from './chunk-MWHZ26S4.js';
 import { formatDiagnostic } from './chunk-SYNQJNVB.js';
 
-// src/byte-order-mark.ts
-var BYTE_ORDER_MARK = "\uFEFF";
-function splitByteOrderMark(raw) {
-  return raw.startsWith(BYTE_ORDER_MARK) ? { bom: BYTE_ORDER_MARK, text: raw.slice(BYTE_ORDER_MARK.length) } : { bom: "", text: raw };
-}
-
 // src/directive/report-text.ts
 function inSourceOrder(diagnostics) {
   return diagnostics.toSorted((a, b) => a.offset - b.offset);
 }
+function framedText(file, line, column, text) {
+  return `${file}:${line}:${column}: ${text}`;
+}
+function orderWarningTexts(warnings, file) {
+  return warnings.map((warning) => framedText(file, warning.line, warning.column, warning.text));
+}
 function warningTexts(diagnostics, file, extend) {
   return inSourceOrder(diagnostics).map(
     (diagnostic) => `${file}:${diagnostic.line}:${diagnostic.column}: ${formatDiagnostic(diagnostic, { extend })}`
@@ -28,4 +28,4 @@ function foldedText(diagnostics, file, extend) {
   return `${file}:${first.line}:${first.column}: ${foldLocated(located)}`;
 }
 
-export { foldedText, splitByteOrderMark, warningTexts };
+export { foldedText, framedText, orderWarningTexts, warningTexts };