@navecss/core 0.4.0 → 0.5.0

package/dist/postcss.js

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

package/dist/standalone.css

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

package/dist/{vite-options-D1-hGA9L.d.ts → vite-options-sOCeGn9B.d.ts}

@@ -1,4 +1,4 @@
-import { A as AtomName } from './atom-names-2OreuBx9.js';
+import { A as AtomName } from './atom-names-B8Ud-7zD.js';
 
 /**
  * The options that choose which atoms the Vite plugin ships, and their validation. A value a
@@ -83,4 +83,5 @@ declare function resolveUsedOptions(options: UsedAtomOptions): ResolvedUsedOptio
  */
 declare function keptAtoms(options: ResolvedUsedOptions): string[];
 
-export { type ResolvedUsedOptions as R, type UsedAtomOptions as U, assertOptions as a, keptAtoms as k, resolveUsedOptions as r };
+export { assertOptions as a, keptAtoms as k, resolveUsedOptions as r };
+export type { ResolvedUsedOptions as R, UsedAtomOptions as U };

package/dist/vite.d.ts

@@ -1,6 +1,6 @@
 import { AtomDefinition } from './atoms.js';
-import { U as UsedAtomOptions } from './vite-options-D1-hGA9L.js';
-import './atom-names-2OreuBx9.js';
+import { UsedAtomOptions } from './collect.js';
+import './atom-names-B8Ud-7zD.js';
 
 /**
  * The few shapes of Vite's (and Rollup's) own objects the plugin touches, declared here rather
@@ -70,6 +70,9 @@ interface BuilderLike {
 interface EnvironmentLike {
     readonly name: string;
     readonly config: {
+        readonly build?: {
+            readonly emitAssets?: boolean;
+        };
         readonly command?: string;
         readonly consumer: string;
         readonly inlineConfig?: object;
@@ -215,6 +218,19 @@ interface BundleEntry {
     readonly type: string;
     readonly fileName: string;
     readonly source?: string | Uint8Array;
+    /**
+     * The names an asset was emitted under, and the files it was made from: they survive a
+     * renaming of the file.
+     */
+    readonly names?: readonly string[];
+    readonly originalFileNames?: readonly string[];
+    /**
+     * What a chunk holds, and the stylesheets it imports.
+     */
+    readonly modules?: Readonly<Record<string, unknown>>;
+    readonly viteMetadata?: {
+        readonly importedCss?: ReadonlySet<string>;
+    };
 }
 interface TransformResultLike {
     readonly code: string;
@@ -234,6 +250,10 @@ interface NaveCollectPlugin {
     readonly transformIndexHtml: HtmlHook;
     buildStart(this: RenderContext): Promise<void>;
     buildEnd(this: RenderContext, error?: unknown): Promise<void>;
+    readonly generateBundle: {
+        handler(this: BundleContext, options: unknown, bundle: Record<string, BundleEntry>): void;
+        readonly order: 'pre';
+    };
 }
 
 /**
@@ -365,4 +385,5 @@ type NavePlugins = [NaveVitePlugin, NaveCollectPlugin];
  */
 declare function navePlugin(options?: NaveViteOptions): NavePlugins;
 
-export { type NavePlugins, type NaveViteOptions, type NaveVitePlugin, navePlugin as default, navePlugin };
+export { navePlugin as default, navePlugin };
+export type { NavePlugins, NaveViteOptions, NaveVitePlugin };