@navecss/core 0.5.0 → 0.6.0

package/dist/{chunk-MWHZ26S4.js → chunk-KDLLTOAM.js}

@@ -1938,7 +1938,6 @@ function recordRun(state, walk) {
     canReorder: follows !== void 0 && !walk.isNestedBefore && firstAtomWithBlock(walk)?.atomIndex === follows.atom.atomIndex && !hasBlockOfOwn,
     directive,
     follows,
-    isWrappedBefore: state.hasOwnNested,
     nested
   });
 }
@@ -1969,10 +1968,7 @@ function emitAtom(state, walk, index) {
   noteAbove(state, walk);
   const last = planned.blocks.at(-1);
   walk.follows = { atom, where: blockWhere(last) };
-  state.lastNested = {
-    text: `the block of "${atom.name}" ${blockWhere(last)}`,
-    block: { atom, directive: walk.directive }
-  };
+  state.lastNested = { text: `the block of "${atom.name}" ${blockWhere(last)}` };
   state.isNested = true;
 }
 function emitAtoms(state, directive, atoms2) {
@@ -2588,18 +2584,6 @@ function overriddenLonghands(pairs2) {
   return [...new Set(all)];
 }
 
-// src/directive/migration.ts
-var MIGRATION_VERSION = "0.5.0";
-function overriderSentence(atom) {
-  return `Before @navecss/core ${MIGRATION_VERSION} "${atom}" won, because an atom's blocks were placed last in the rule.`;
-}
-function wrappedSpecificitySentence() {
-  return `Before @navecss/core ${MIGRATION_VERSION} they were left outside \`& { }\`, so they matched with each selector's own specificity.`;
-}
-function wrappedPseudoElementSentence() {
-  return `Before @navecss/core ${MIGRATION_VERSION} they did, because they were left outside \`& { }\`.`;
-}
-
 // src/directive/order-focus.ts
 var RING_CLAUSE = 'This hides the keyboard focus indicator that "focusRing" draws.';
 var REVEAL_CLAUSE = 'This hides again what "srOnlyFocusable" reveals on focus, such as a skip link.';
@@ -2812,19 +2796,12 @@ function markerSentence(finding, context) {
   const target = isSameDirective ? "mark the directive" : `mark the directive that names "${unit.atom.name}"`;
   return `If "${overrider.atom.name}" is meant to win, ${target}: ${printed}`;
 }
-function migrationSentence(finding) {
-  const { overrider } = finding.candidate;
-  const isBlock = overrider.kind === "atom" && overrider.isBlock;
-  if (isBlock || finding.outward !== void 0) return void 0;
-  return overriderSentence(finding.unit.atom.name);
-}
 function findingText(finding, context) {
   const opening = `${overriderName(finding)} comes after "${finding.unit.atom.name}"`;
   const reason = `so ${placeClause(finding)} ${valueClause(finding)}.`;
   const sentences = [
     `@nave: ${opening}, ${reason}`,
     focusClauseOf(finding),
-    migrationSentence(finding),
     fixSentence(finding, context),
     markerSentence(finding, context)
   ];
@@ -2916,7 +2893,6 @@ function createState(input) {
     directives: [],
     dropped: [],
     directiveTotal: input.nodes.filter((node) => node.kind === "directive").length,
-    hasOwnNested: false,
     input,
     isNested: false,
     isPseudoElementRule: isPseudoElementOnlyList(input.selector),
@@ -2949,19 +2925,17 @@ function anchorOf2(run) {
 function pseudoElementText(run, pseudo) {
   const other = `Or move ${pseudo} to a separate rule, with or without them.`;
   if (run.kind === "own") {
-    return `@nave: the declarations after ${run.nested} are written inside ${WRAP}, which cannot match a pseudo-element, so they do not apply to ${pseudo}. ${wrappedPseudoElementSentence()} To apply them there too, move them above ${run.above}. ${other}`;
+    return `@nave: the declarations after ${run.nested} are written inside ${WRAP}, which cannot match a pseudo-element, so they do not apply to ${pseudo}. To apply them there too, move them above ${run.above}. ${other}`;
   }
   const atoms2 = quoted(run.atoms.map((atom) => atom.name));
-  const sentence = run.isWrappedBefore ? "" : ` ${wrappedPseudoElementSentence()}`;
   const separate = `Move ${pseudo} to a separate rule, with or without them.`;
-  if (run.follows) return followsText(run, { atoms: atoms2, pseudo, sentence, separate, other });
-  const nestedSentence = run.nested.block && !run.isWrappedBefore ? sentence : "";
+  if (run.follows) return followsText(run, { atoms: atoms2, pseudo, separate, other });
   const move = run.canMoveDirective ? ` To apply them there too, move the directive above ${run.above}. ${other}` : ` ${separate}`;
-  return `@nave: this directive comes after ${run.nested.text}, so the declarations of ${atoms2} are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${pseudo}.${nestedSentence}${move}`;
+  return `@nave: this directive comes after ${run.nested.text}, so the declarations of ${atoms2} are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${pseudo}.${move}`;
 }
 function followsText(run, parts) {
   const { follows } = run;
-  const head = `@nave: the declarations of ${parts.atoms} follow the block of "${follows.atom.name}" ${follows.where}, so they are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${parts.pseudo}.${parts.sentence}`;
+  const head = `@nave: the declarations of ${parts.atoms} follow the block of "${follows.atom.name}" ${follows.where}, so they are written inside ${WRAP}, which cannot match a pseudo-element: they do not apply to ${parts.pseudo}.`;
   if (!run.canReorder) return `${head} ${parts.separate}`;
   const printed = directiveWithAtomsBefore(run.directive.prelude, run.directive.atoms, {
     moving: run.atoms.map((atom) => atom.atomIndex),
@@ -2991,8 +2965,7 @@ function wrapText(run, selectors) {
   const list = selectors.others.join(", ");
   const wholeList = [`:is(${list})`, ...selectors.pseudoElements].join(", ");
   const subject = run.kind === "own" ? `the declarations after ${run.nested}` : `the declarations of ${quoted(run.atoms.map((atom) => atom.name))}`;
-  const sentence = run.kind === "directive" && run.isWrappedBefore ? "" : ` ${wrappedSpecificitySentence()}`;
-  return `@nave: ${subject} are written inside ${WRAP}, which under the selector list ${list} matches with the specificity of ${most}, so where ${joinList(less, "or")} matches they can win over a rule elsewhere that is more specific than ${joinList(less, "or")}.${sentence} To give each selector its own specificity, write the rule once for each of ${groupsText(selectors, specificities)}. To give the whole rule the specificity of ${most}, write the list as \`${wholeList}\`.`;
+  return `@nave: ${subject} are written inside ${WRAP}, which under the selector list ${list} matches with the specificity of ${most}, so where ${joinList(less, "or")} matches they can win over a rule elsewhere that is more specific than ${joinList(less, "or")}. To give each selector its own specificity, write the rule once for each of ${groupsText(selectors, specificities)}. To give the whole rule the specificity of ${most}, write the list as \`${wholeList}\`.`;
 }
 function isUnequal(selectors) {
   const [first, ...rest] = selectors.others.map((selector) => ampersandSpecificity(selector));
@@ -3099,7 +3072,6 @@ function keepNested(state, node) {
   flushRun(state);
   state.items.push({ kind: "keep", ref: node.ref });
   state.isNested = true;
-  state.hasOwnNested = true;
   state.lastNested = { text: nestedText(node) };
   state.above ??= nestedText(node);
 }

package/dist/{chunk-KKUYU75D.js → chunk-R6R5DSTT.js}

@@ -1,4 +1,4 @@
-import { foldLocated } from './chunk-MWHZ26S4.js';
+import { foldLocated } from './chunk-KDLLTOAM.js';
 import { formatDiagnostic } from './chunk-SYNQJNVB.js';
 
 // src/directive/report-text.ts

package/dist/collect.d.ts

@@ -55,6 +55,13 @@ interface Problem {
      * export), so a build-end check can tell whether an importer takes it.
      */
     readonly exportedAs?: readonly string[];
+    /**
+     * For a use in a dependency that hands Nave's `cx` out of its module where the build cannot
+     * follow it to an export (it is assigned to something other than a name of the module, passed
+     * as a value, bound, or imported in a form the build does not read). A hand-out the build can
+     * follow carries `exportedAs` instead.
+     */
+    readonly isUnboundHandOut?: boolean;
     /**
      * For a problem in a module listed in `cxModules`: whether the module also exports Nave's own
      * `cx`. An importer's `cx` is then Nave's, so what the build says of its calls is not an echo of
@@ -193,20 +200,16 @@ declare function inspectAtomicLayer(css: string): LayerReading;
  */
 declare function unprunedAtoms(css: string, emitted: ReadonlySet<string>): string[];
 
-/**
- * `atoms` with the atoms added that restore what an atom in it removes: `srOnlyFocusable` shows
- * again on focus what `srOnly` hides, so a set that holds `srOnly` holds it too. This adds to the
- * emitted set only, not to `keep` or to what `cx.dynamic()` accepts.
- */
-declare function withRestorers(atoms: Set<string>): Set<string>;
-
 /**
  * What an importer takes from a module that gives out Nave's `cx`: which of its `cx` exports it
  * imports, re-exports or reads off a namespace. The test is by name, not by file: an importer that
  * takes only `Button` from a module which also exports `cx` as `cn` takes no `cx` from it, so
  * nothing of its own routes calls through `cn`. A take the parse cannot tell apart (a namespace
  * passed on, a computed key, a rest element, an `import()` used any other way) counts as taken, and
- * so does an importer whose text names the module in no way the build reads (a `require()`).
+ * so does an importer whose text names the module in no way the build reads (a `require()`). A
+ * declaration written for the types only (`import type`, `export type`, a `type` specifier), and a
+ * named import that is referenced only in type positions, take nothing: TypeScript leaves them out
+ * of the compiled module.
  */
 
 /**
@@ -235,6 +238,12 @@ interface Taken {
      * Whether the take comes from what an earlier server command left in the cache directory.
      */
     readonly isRecorded?: boolean;
+    /**
+     * For a dependency's take: whether the build reads it neither as calls only nor as a forward, so
+     * it cannot tell where what is taken goes. `form` says what the dependency does, in words.
+     */
+    readonly isHeld?: boolean;
+    readonly form?: string;
 }
 interface Take extends Taken {
     /**
@@ -248,6 +257,46 @@ interface Take extends Taken {
     readonly isReached: boolean;
 }
 
+/**
+ * `cxModules`: the modules a consumer lists as re-exporting Nave's `cx`, and what the post-order
+ * half does with them. An import is from a listed module when its specifier resolves, from the
+ * importing module, to a listed module's file, or, for an entry that is not relative, when it
+ * equals the entry as written (a relative specifier names a file relative to the module that
+ * writes it, so its text alone names nothing). An entry that is, or resolves to, Nave's own `cx`
+ * module is no entry: that module is always followed. A module is parsed only when its text can
+ * name a listed one (a text test, so an application of thousands of modules parses the importers
+ * and no more), and a build-end check compares the importers it recognised with the module
+ * graph's, so an import through a spelling the text test cannot see fails the build instead of
+ * shipping every call made through it with no rule.
+ */
+
+interface DeclaredModules {
+    /**
+     * The entries a specifier may equal as written: every entry but a relative one.
+     */
+    readonly entries: ReadonlySet<string>;
+    /**
+     * The module id each entry resolves to from the project root; an entry that resolves to nothing
+     * has none.
+     */
+    readonly ids: ReadonlyMap<string, string>;
+    /**
+     * The files the entries resolve to.
+     */
+    readonly files: ReadonlySet<string>;
+    /**
+     * The names a specifier's last segment may carry to name a listed file: its name without its
+     * extension, and its directory's when it is an `index` file.
+     */
+    readonly names: ReadonlySet<string>;
+    /**
+     * Finds, in a module's text, a quoted specifier that can name a listed file: one whose last
+     * segment is one of `names`, or a directory specifier that writes no name when a listed file
+     * is an `index` file. `undefined` when no listed file resolved.
+     */
+    readonly textTest: RegExp | undefined;
+}
+
 /**
  * The report a build fails with when it meets a use it cannot read: a first line counting the
  * problems and stating the cause, one line per problem with a 1-based, root-relative position,
@@ -292,12 +341,23 @@ interface LocatedProblem extends Problem {
      * application modules that take one of its `cx` exports, which `keepFor` does not clear.
      */
     readonly takes?: readonly Take[] | undefined;
+    /**
+     * For a problem with `takes`: how the host names the root a `cxModules` specifier resolves from,
+     * in the words the remedy line for those takes uses.
+     */
+    readonly rootName?: string | undefined;
     /**
      * For a dependency module that re-exports the `cx` of a module `cxModules` lists: the modules of
      * other dependencies that call through it, root-relative, which only the package's `keepFor`
      * entry can stand in for.
      */
     readonly callers?: readonly string[] | undefined;
+    /**
+     * For a dependency's problem that stays an error whatever the application imports, and that no
+     * `keepFor` entry clears: a hand-out of `cx` the build cannot follow to an export, or a take of a
+     * module that gives `cx` out that the build reads neither as calls only nor as a forward.
+     */
+    readonly isHeld?: boolean;
 }
 declare const REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
 /**
@@ -305,13 +365,249 @@ declare const REPORT_CAUSE = "the build cannot tell which atoms these apply, and
  * lines of the application's kinds and before any package's line.
  */
 type HostRemedies = (application: readonly LocatedProblem[]) => readonly string[];
+/**
+ * What a host adds to the report besides where its options are written: the remedy lines only it
+ * can write, and where its own documentation says how to ship every atom, which is the Vite
+ * plugin's README section when it names none.
+ */
+interface ReportHost {
+    readonly remedies?: HostRemedies;
+    readonly everyAtom?: string;
+}
 /**
  * The build report for every problem of an environment. `configured` is the `cxModules` list the
  * remedies that print one extend, and `home` is how the host spells where the options are written,
- * the call of its plugin or its wrapper: the one place the report names its host. `hostRemedies`
- * adds the lines only the host can write.
+ * the call of its plugin or its wrapper: the one place the report names its host. `host` adds
+ * what only the host can write, given as a {@link ReportHost} or, as before, as its remedy lines
+ * alone.
  */
-declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string, hostRemedies?: HostRemedies): string;
+declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string, host?: HostRemedies | ReportHost): string;
+
+/**
+ * One import a server module of the consumer's makes of a listed package: the module, root
+ * relative, the specifier it writes, what it takes from it (any name counting as a `cx` export),
+ * and the file the server loads for it when that is known.
+ */
+interface ServerImport {
+    readonly file?: string;
+    /**
+     * Whether the module imports the package in a way the build cannot read, such as `require()`.
+     */
+    readonly isUnreadable?: boolean;
+    /**
+     * Whether an earlier server command recorded it, not a server environment of this process.
+     */
+    readonly isRecorded?: boolean;
+    readonly specifier: string;
+    readonly takes: readonly Taken[];
+    readonly taker: string;
+}
+/**
+ * A server import whose target the client graph holds: the file it resolves to.
+ */
+interface ResolvedServerImport extends ServerImport {
+    readonly file: string;
+}
+
+/**
+ * What the build-end read of who takes a `cx` that a dependency gives out needs of its host: the
+ * module graph (who imports a module, the text of a module, what a specifier resolves to, how to
+ * parse a module) and a few lookups that need the file system, which a host supplies so this
+ * code imports no Node module. The Vite plugin supplies them from its `RenderContext` and
+ * `UsedContext`; another host supplies them from its own graph.
+ */
+
+/**
+ * What a host's module graph holds about one module.
+ */
+interface ModuleInfo {
+    readonly code: string | null;
+    readonly importers: readonly string[];
+    readonly dynamicImporters: readonly string[];
+}
+/**
+ * The module graph of a build, as the read of the takes asks it.
+ */
+interface ModuleHost {
+    /**
+     * The environment the build-end read runs for, which keys what it resolves once.
+     */
+    readonly environment: {
+        readonly name: string;
+    };
+    /**
+     * What the graph holds about the module `id`, or `null` when it holds none.
+     */
+    getModuleInfo?(id: string): ModuleInfo | null;
+    /**
+     * Resolves `source` as imported from `importer`.
+     */
+    resolve?(source: string, importer?: string): Promise<{
+        readonly id: string;
+    } | null>;
+    /**
+     * Every file id the host's build may resolve `source` to, for a host whose build resolves one
+     * specifier to different files (by condition, or by mode). Used instead of `resolve`, which
+     * answers one of them, wherever a resolution is compared to a file.
+     */
+    resolveAll?(source: string, importer?: string): Promise<readonly string[]>;
+    /**
+     * The host's parse of `code`, an ESTree.
+     */
+    parse?(code: string): unknown;
+    /**
+     * The host's parse of the module `id` whose text is `code`, for a host that reads authored
+     * sources whose language follows from the file. Used instead of `parse` when the host has it.
+     */
+    parseModule?(code: string, id: string): unknown;
+}
+/**
+ * What the read of the takes needs of the build: the project root, the options that decide which
+ * packages are listed, the modules `cxModules` lists (resolved once per environment and kept in
+ * `state.declared`), and the two lookups that need the file system.
+ */
+interface TakesContext {
+    readonly root: string;
+    /**
+     * How the host's messages name `root`, completing the phrase a specifier that resolves from
+     * <rootName>.
+     */
+    readonly rootName: string;
+    readonly options: {
+        readonly cxModules: readonly string[];
+        readonly keepFor: Readonly<Record<string, readonly string[]>>;
+    };
+    readonly state: {
+        readonly declared: Map<string, Promise<DeclaredModules>>;
+    };
+    /**
+     * The name of the package the module `id` belongs to, when it lies under `node_modules`.
+     */
+    packageOf(id: string): Promise<string | undefined>;
+    /**
+     * The path a message names the module `id` by: relative to the project root, forward slashes.
+     */
+    labelOf(id: string): string;
+}
+
+/**
+ * The modules that give out `cx` through one of its `cx` exports: the module that exports Nave's
+ * `cx`, and every module of a dependency, of the same package or of another, that only re-exports
+ * one of those exports (a forward, by `export ... from` or by one of the CommonJS forms
+ * `vite-require-takes.ts` reads), however many modules away. A module that takes `cx` from any of
+ * them takes it from the first. A dependency's other takes (a call, an assignment, a wrapper, a
+ * take the build cannot read) end the walk: they are the package's own calls.
+ */
+
+/**
+ * A module that gives out `cx`: the `cx` exports it holds, and whether it holds them by forwarding
+ * another module's rather than by exporting Nave's itself.
+ */
+interface Holder {
+    readonly id: string;
+    readonly names: ReadonlySet<string>;
+    readonly isReached: boolean;
+}
+
+/**
+ * A dependency's take of a module that gives out `cx` that the build reads neither as calls only
+ * nor as a forward: the importer's module, the package it belongs to and what it does, in words.
+ */
+interface Held {
+    readonly form: string;
+    readonly importer: string;
+    readonly pkg: string;
+    readonly taker: string;
+}
+interface Routes {
+    readonly entry: Take[];
+    readonly told: Take[];
+    /**
+     * The takes a dependency makes of the module that do more than re-export it: its calls.
+     */
+    readonly calls: Take[];
+    /**
+     * The takes a dependency makes of the module that the build reads neither as calls only nor as a
+     * forward, whatever the dependency is: they stay errors whatever the application imports.
+     */
+    readonly held: Held[];
+}
+
+/**
+ * One module that gives out `cx` with what the build read of its takes: the holders of its `cx`
+ * exports and the takes the importers of the build make of each. The imports a server environment
+ * makes are added when they are known, which can be after the environment that read the rest has
+ * ended.
+ */
+interface Prepared {
+    readonly holders: readonly Holder[];
+    readonly isHop: boolean;
+    readonly isListed: boolean;
+    /**
+     * Whether the module has a clearing specifier: a take of the module itself by an application
+     * module or a calling dependency is then on the `cxModules` route.
+     */
+    readonly hasEntry: boolean;
+    readonly problems: readonly LocatedProblem[];
+    /**
+     * How the host names its root, for the remedy line of the takes.
+     */
+    readonly rootName: string;
+    readonly routed: readonly Routes[];
+}
+
+/**
+ * The build-end judgement of the re-exports of `cx` that a package `keepFor` lists gives out: which
+ * of them stay errors because a module of the consumer takes a `cx` export through them, with the
+ * line that clears each. The Vite plugin calls it at build end, and a host with another module
+ * graph (see `ModuleHost`) calls it over its own, so both say the same thing about the same code.
+ */
+
+/**
+ * What reading one module found: its problems, those a `keepFor` entry stands in for set aside
+ * (`suppressed`), and the listed files it reads a `cx` from when it reads no other (`onlyVia`).
+ */
+interface ModuleOutcome {
+    readonly onlyVia?: ReadonlySet<string> | undefined;
+    readonly problems: readonly LocatedProblem[];
+    readonly suppressed: readonly LocatedProblem[];
+}
+/**
+ * The problems the build fails with, given what each module's reading found: those of a package
+ * `keepFor` lists are only the ones its listing does not stand in for, a listed module that
+ * exports a `cx` the build does not follow and a `cx` export that a module the consumer can
+ * change takes. `serverImports` are the imports a server environment makes of a listed package it
+ * leaves external, when the host has such environments.
+ * @param host The module graph of the build.
+ * @param context The project root, the options, and the lookups that need the file system.
+ * @param modules What each module's reading found.
+ * @param serverImports What the server environments imported of a listed package.
+ * @returns The problems to report, and what was read of the takes of each re-exporting module.
+ */
+declare function judgeReexports(host: ModuleHost, context: TakesContext, modules: readonly ModuleOutcome[], serverImports?: readonly ResolvedServerImport[]): Promise<{
+    prepared: Prepared[];
+    problems: LocatedProblem[];
+}>;
+
+/**
+ * Whether a module of a dependency hands out the Nave `cx` it imports in a form the build does not
+ * bind: see `isImportedCxHandedOut`.
+ */
+
+/**
+ * Whether a module of a dependency hands out the Nave `cx` it imports in a form the build does not
+ * bind (a `require()`, a dynamic import, or a specifier other than the package's own), the string
+ * naming it starting at `offset`: its result is used for more than calls, or the build cannot find
+ * the import. A `cx` that is only called is the package's own call.
+ */
+declare function isImportedCxHandedOut(program: AstNode, offset: number): boolean;
+
+/**
+ * `atoms` with the atoms added that restore what an atom in it removes: `srOnlyFocusable` shows
+ * again on focus what `srOnly` hides, so a set that holds `srOnly` holds it too. This adds to the
+ * emitted set only, not to `keep` or to what `cx.dynamic()` accepts.
+ */
+declare function withRestorers(atoms: Set<string>): Set<string>;
 
-export { CX_SOURCE, REPORT_CAUSE, buildReport, inspectAtomicLayer, pruneAtomicLayer, readModule, unprunedAtoms, withRestorers };
-export type { AstNode, HostRemedies, LayerReading, LocatedProblem, ModuleReading, Problem, ProblemKind, ReadOptions };
+export { CX_SOURCE, REPORT_CAUSE, buildReport, inspectAtomicLayer, isImportedCxHandedOut, judgeReexports, pruneAtomicLayer, readModule, unprunedAtoms, withRestorers };
+export type { AstNode, HostRemedies, LayerReading, LocatedProblem, ModuleHost, ModuleInfo, ModuleOutcome, ModuleReading, Problem, ProblemKind, ReadOptions, ReportHost, TakesContext };

package/dist/collect.js

@@ -1,5 +1,41 @@
-export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, inspectAtomicLayer, keptAtoms, pruneAtomicLayer, readModule, resolveUsedOptions, unprunedAtoms, withRestorers } from './chunk-BCUK4M4P.js';
+import { analyze, isUsedAsCallsOnly, CX_ONLY, nodesAt, nodeAt, pushAll, childrenOf, staticStringOf, flowOf } from './chunk-EYMFWE3A.js';
+export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, inspectAtomicLayer, judgeReexports, keptAtoms, pruneAtomicLayer, readModule, resolveUsedOptions, unprunedAtoms, withRestorers } from './chunk-EYMFWE3A.js';
 import './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
 import './chunk-2K5EBBF2.js';
 import './chunk-GZL2VW7C.js';
+
+// src/vite-require-handed-out.ts
+function allNodes(program) {
+  const found = [];
+  const stack = [program];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    found.push(node);
+    pushAll(stack, childrenOf(node));
+  }
+  return found;
+}
+function importAt(nodes, offset) {
+  return nodes.find((node) => {
+    const literal = node.type === "CallExpression" ? nodesAt(node, "arguments")[0] : nodeAt(node, "source") ?? nodeAt(nodeAt(node, "moduleReference") ?? node, "expression");
+    return literal?.start === offset && node.type !== "Literal";
+  });
+}
+function isDeclarationHandedOut(analysis, declaration) {
+  const source = staticStringOf(nodeAt(declaration, "source"));
+  return analysis.references.filter(({ binding }) => binding?.kind === "import" && binding.source === source).some(({ node }) => {
+    const flow = flowOf(analysis, node);
+    return flow.isUnbound || flow.names.size > 0;
+  });
+}
+function isImportedCxHandedOut(program, offset) {
+  const analysis = analyze(program);
+  const node = importAt(allNodes(program), offset);
+  if (!node) return true;
+  if (node.type === "ImportDeclaration") return isDeclarationHandedOut(analysis, node);
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") return true;
+  return !isUsedAsCallsOnly(analysis, node, CX_ONLY);
+}
+
+export { isImportedCxHandedOut };

package/dist/lightningcss.js

@@ -1,7 +1,7 @@
 import { splitByteOrderMark } from './chunk-2TNTYI4L.js';
-import { orderWarningTexts, warningTexts, foldedText } from './chunk-KKUYU75D.js';
-import { validateExtendAtomsHostFree } from './chunk-63H2FLGU.js';
-import { snapshotExtendMap, expandText } from './chunk-MWHZ26S4.js';
+import { orderWarningTexts, warningTexts, foldedText } from './chunk-R6R5DSTT.js';
+import { validateExtendAtomsHostFree } from './chunk-B5CWZIBK.js';
+import { snapshotExtendMap, expandText } from './chunk-KDLLTOAM.js';
 import './chunk-UVHGEVMV.js';
 import './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';

package/dist/postcss.js

@@ -1,6 +1,6 @@
-import { framedText } from './chunk-KKUYU75D.js';
+import { framedText } from './chunk-R6R5DSTT.js';
 import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
-import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, planRule, DirectiveFailure, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-MWHZ26S4.js';
+import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, planRule, DirectiveFailure, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-KDLLTOAM.js';
 import './chunk-UVHGEVMV.js';
 import { formatDiagnostic } from './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';