@zealakit/css-doctor-next 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1318 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  findCssDoctorConfig: () => findCssDoctorConfig,
+  loadCssDoctorConfig: () => loadCssDoctorConfig,
+  withCssDoctor: () => withCssDoctor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_jiti = require("jiti");
+var import_meta = {};
+var CONFIG_FILENAMES = [
+  "cssd.config.ts",
+  "cssd.config.mts",
+  "cssd.config.js",
+  "cssd.config.mjs"
+];
+function findCssDoctorConfig(cwd = process.cwd()) {
+  let directory = (0, import_node_path.resolve)(cwd);
+  while (true) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = (0, import_node_path.resolve)(directory, filename);
+      if ((0, import_node_fs.existsSync)(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(directory);
+    if (parent === directory) {
+      return null;
+    }
+    directory = parent;
+  }
+}
+function loadCssDoctorConfig(options = {}) {
+  const cwd = (0, import_node_path.resolve)(options.cwd ?? process.cwd());
+  const file = options.configFile ? (0, import_node_path.resolve)(cwd, options.configFile) : findCssDoctorConfig(cwd);
+  if (!file) {
+    return { options: {} };
+  }
+  if (!(0, import_node_fs.existsSync)(file)) {
+    return { options: {} };
+  }
+  try {
+    if ((0, import_node_fs.readFileSync)(file, "utf8").trim().length === 0) {
+      return { options: {}, file };
+    }
+    const jiti = (0, import_jiti.createJiti)(import_meta.url, {
+      interopDefault: true,
+      fsCache: false,
+      moduleCache: false
+    });
+    const loaded = jiti(file);
+    return {
+      options: normalizeConfig(loaded),
+      file
+    };
+  } catch (error) {
+    return {
+      options: {},
+      file,
+      error: `failed to load ${file}: ` + (error instanceof Error ? error.message : String(error))
+    };
+  }
+}
+function normalizeConfig(value) {
+  let candidate = value;
+  if (isRecord(candidate) && "default" in candidate) {
+    candidate = candidate.default;
+  }
+  if (isRecord(candidate) && "cssDoctor" in candidate) {
+    candidate = candidate.cssDoctor;
+  }
+  return isRecord(candidate) ? candidate : {};
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/webpack-plugin.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_perf_hooks = require("perf_hooks");
+var import_css_doctor_binding = require("@zealakit/css-doctor-binding");
+
+// src/reporter.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var MATRIX_SELECTOR_MAX = 36;
+function formatDiagnostics(diagnostics, options = {}) {
+  const colors = import_picocolors.default.createColors(
+    options.color ?? import_picocolors.default.isColorSupported
+  );
+  const badge = colors.bgCyan(colors.black("[css-doctor]"));
+  const lines = [];
+  lines.push(
+    `${badge} Next.js ${diagnostics.pages.length} page${diagnostics.pages.length === 1 ? "" : "s"} ${colors.dim("\xB7")} ${diagnostics.analyzedCssAssets}/${diagnostics.totalCssAssets} CSS assets ${colors.dim("\xB7")} ${formatBytes(
+      diagnostics.totalSizeBeforeBytes
+    )} \u2192 ${formatBytes(diagnostics.totalSizeAfterBytes)} common ${colors.dim("\xB7")} ${formatDuration(diagnostics.durationMs)} ${colors.dim("\xB7")} ${diagnostics.minify ? colors.green("Minified: YES") : colors.yellow("Minified: NO")}`
+  );
+  for (const file of diagnostics.files) {
+    lines.push(...formatFile(file, colors));
+  }
+  if (diagnostics.splitApplied) {
+    lines.push("");
+    lines.push(...formatMatrix(diagnostics, colors));
+  }
+  if (diagnostics.emittedPageChunks.length > 0) {
+    lines.push("");
+    lines.push(
+      `  ${colors.bold("Emitted page chunks")} ${colors.dim(
+        `(${diagnostics.emittedPageChunks.length})`
+      )}`
+    );
+    for (const chunk of diagnostics.emittedPageChunks) {
+      lines.push(
+        `    ${colors.magenta(chunk.fileName)} ${colors.dim(
+          formatBytes(chunk.sizeBytes)
+        )}`
+      );
+    }
+  }
+  if (diagnostics.sizeBudget.enabled) {
+    lines.push("");
+    lines.push(...formatSizeBudget(diagnostics, colors));
+  }
+  if (diagnostics.deadCodeCount > 0) {
+    lines.push("");
+    lines.push(
+      `  ${colors.yellow("\u26A0")} ${colors.bold("Dead code eliminated:")} ${diagnostics.deadCodeCount} selector occurrence${diagnostics.deadCodeCount === 1 ? "" : "s"}`
+    );
+  }
+  if (diagnostics.errors.length > 0) {
+    lines.push("");
+    lines.push(`  ${colors.red(colors.bold("Errors"))}`);
+    for (const error of diagnostics.errors) {
+      lines.push(`    ${colors.red("\u2716")} ${error}`);
+    }
+  }
+  return lines.join("\n");
+}
+function printDiagnostics(diagnostics) {
+  console.log(formatDiagnostics(diagnostics));
+}
+function formatFile(file, colors) {
+  const failed = file.error !== void 0;
+  const hasWarnings = file.warnings.length > 0;
+  const icon = failed ? colors.red("\u2716") : hasWarnings ? colors.yellow("\u26A0") : colors.green("\u2713");
+  const size = `${formatBytes(file.sizeBeforeBytes)} \u2192 ${formatBytes(
+    file.sizeAfterBytes
+  )}`;
+  const selectors = failed ? "" : ` \xB7 ${file.selectorCount} selectors`;
+  const pages = file.associatedPages.length > 0 ? ` \xB7 pages: ${file.associatedPages.join(", ")}` : "";
+  const lines = [
+    `  ${icon} ${colors.bold(file.fileName)} ${colors.dim(size)}${selectors}${colors.dim(pages)}`
+  ];
+  if (file.error) {
+    lines.push(`      ${colors.red(file.error)}`);
+    return lines;
+  }
+  if (file.split) {
+    lines.push(
+      `      ${colors.dim("split")} common ${formatBytes(
+        file.split.commonSizeBytes
+      )} ${colors.dim("\xB7")} page-specific ${formatBytes(
+        file.split.pageSpecificSizeBytes
+      )} ${colors.dim("\xB7")} dead ${file.split.deadCodeCount}`
+    );
+  }
+  for (const warning of file.warnings) {
+    lines.push(`      ${formatWarning(warning, colors)}`);
+  }
+  return lines;
+}
+function formatMatrix(diagnostics, colors) {
+  const pageTotal = diagnostics.pages.length;
+  const rows = diagnostics.usageMatrix;
+  const header = [
+    "Selector".padEnd(MATRIX_SELECTOR_MAX),
+    "Total Used".padStart(10),
+    "Page Usage".padStart(10),
+    "Coverage %".padStart(10),
+    "Assigned Chunk"
+  ].join("  ");
+  const lines = [
+    `  ${colors.bold("Usage Matrix")} ${colors.dim(
+      `(${rows.length} selectors \xB7 ${pageTotal} pages)`
+    )}`,
+    `  ${colors.dim(header)}`
+  ];
+  for (const row of rows) {
+    const selector = truncate(row.selector, MATRIX_SELECTOR_MAX).padEnd(
+      MATRIX_SELECTOR_MAX
+    );
+    const totalUsed = String(row.totalOccurrences).padStart(10);
+    const pageUsage = `${row.pageCount}/${pageTotal}`.padStart(10);
+    const coverage = `${(row.coverageRatio * 100).toFixed(1)}%`.padStart(10);
+    const chunk = formatChunk(row.targetChunk, colors);
+    lines.push(
+      `  ${colors.cyan(selector)}  ${totalUsed}  ${pageUsage}  ${colorCoverage(
+        coverage,
+        row.coverageRatio,
+        diagnostics.minPageRatio,
+        colors
+      )}  ${chunk}`
+    );
+  }
+  return lines;
+}
+function formatSizeBudget(diagnostics, colors) {
+  const budget = diagnostics.sizeBudget;
+  const lines = [
+    `  ${colors.bold("Size budget")} ${colors.dim(
+      `(max ${formatBytes(budget.maxChunkSize)} \xB7 variables ${budget.isolateVariables ? "isolated" : "inline"})`
+    )}`
+  ];
+  const chunks = diagnostics.emittedCssChunks;
+  if (chunks.length === 0) {
+    lines.push(`    ${colors.dim("No CSS chunks were emitted.")}`);
+    return lines;
+  }
+  for (const chunk of chunks) {
+    const markers = [];
+    if (chunk.variables) {
+      markers.push("vars");
+    }
+    if (chunk.part !== void 0) {
+      markers.push(`part ${chunk.part}`);
+    }
+    if (chunk.embedded) {
+      markers.push("embedded");
+    }
+    if (chunk.splitDueToSize) {
+      markers.push(colors.yellow("split"));
+    }
+    if (chunk.oversized) {
+      markers.push(colors.red("oversized"));
+    }
+    lines.push(
+      `    ${colors.magenta(chunk.fileName)} ${colors.dim(
+        formatBytes(chunk.sizeBytes)
+      )}${markers.length > 0 ? ` ${colors.dim("\xB7")} ${markers.join(" \xB7 ")}` : ""}`
+    );
+  }
+  if (budget.splitChunks === 0) {
+    lines.push(
+      `    ${colors.dim("No chunk exceeded the configured size budget.")}`
+    );
+  }
+  return lines;
+}
+function formatWarning(warning, colors) {
+  const location = warning.line !== void 0 ? colors.dim(
+    `${warning.line}${warning.column !== void 0 ? `:${warning.column}` : ""} `
+  ) : "";
+  return `${colors.yellow("!")} ${location}${warning.message}`;
+}
+function colorCoverage(coverage, ratio, minPageRatio, colors) {
+  if (ratio === 0) {
+    return colors.red(coverage);
+  }
+  return ratio >= minPageRatio ? colors.green(coverage) : colors.yellow(coverage);
+}
+function formatChunk(chunk, colors) {
+  if (chunk === "common") {
+    return colors.cyan(chunk);
+  }
+  if (chunk === "dead") {
+    return colors.red(chunk);
+  }
+  return colors.magenta(chunk);
+}
+function truncate(value, maxLength) {
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration(milliseconds) {
+  if (!Number.isFinite(milliseconds)) {
+    return "\u2014";
+  }
+  return milliseconds < 1 ? `${milliseconds.toFixed(2)} ms` : `${milliseconds.toFixed(1)} ms`;
+}
+
+// src/webpack-plugin.ts
+var PLUGIN_NAME = "CssDoctorWebpackPlugin";
+var DEFAULT_MIN_PAGE_RATIO = 0.5;
+var DEFAULT_MAX_CHUNK_SIZE = 60 * 1024;
+var LARGE_CSS_ASSET_BYTES = 500 * 1024;
+var CssDoctorWebpackPlugin = class {
+  options;
+  pageCoverage;
+  sizeBudget;
+  minify;
+  include;
+  exclude;
+  configurationErrors = [];
+  constructor(options = {}) {
+    this.options = options;
+    const ratio = options.pageCoverage?.minPageRatio ?? options.minPageRatio ?? DEFAULT_MIN_PAGE_RATIO;
+    const maxChunkSize = options.sizeBudget?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;
+    this.pageCoverage = {
+      enabled: options.pageCoverage?.enabled ?? true,
+      minPageRatio: Number.isFinite(ratio) && ratio >= 0 && ratio <= 1 ? ratio : DEFAULT_MIN_PAGE_RATIO,
+      forceCommon: options.pageCoverage?.forceCommon ?? options.forceCommonSelectors ?? []
+    };
+    if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
+      this.configurationErrors.push(
+        "minPageRatio must be a number between 0 and 1; using 0.5"
+      );
+    }
+    this.sizeBudget = {
+      enabled: options.sizeBudget?.enabled ?? true,
+      maxChunkSize: Number.isInteger(maxChunkSize) && maxChunkSize > 0 ? maxChunkSize : DEFAULT_MAX_CHUNK_SIZE,
+      isolateVariables: options.sizeBudget?.isolateVariables ?? true
+    };
+    if (options.sizeBudget?.enabled !== false && (!Number.isInteger(maxChunkSize) || maxChunkSize <= 0)) {
+      this.configurationErrors.push(
+        "maxChunkSize must be a positive integer; using 61440"
+      );
+    }
+    this.minify = options.minify ?? true;
+    this.include = options.include ?? [];
+    this.exclude = options.exclude ?? [];
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: PLUGIN_NAME,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+        },
+        async () => {
+          try {
+            await this.process(compiler, compilation);
+          } catch (error) {
+            compilation.getLogger(PLUGIN_NAME).warn(
+              `[css-doctor] diagnostics failed without interrupting the build: ${describeError(
+                error
+              )}`
+            );
+          }
+        }
+      );
+    });
+  }
+  async process(compiler, compilation) {
+    const startedAt = import_node_perf_hooks.performance.now();
+    const logger = compilation.getLogger(PLUGIN_NAME);
+    const pagesResult = await collectPages(compilation, this.options.pageUsage);
+    const pageNames = pagesResult.pages.map((page) => page.name);
+    const pageByName = new Map(
+      pagesResult.pages.map((page) => [page.name, page])
+    );
+    const allPages = new Set(pageNames);
+    const pageUsage = {};
+    const pageUsageCounts = {};
+    for (const page of pagesResult.pages) {
+      const classes = [...page.classes].sort();
+      pageUsage[page.name] = classes;
+      pageUsageCounts[page.name] = classes.length;
+    }
+    const pageCoverageApplied = this.pageCoverage.enabled && pageNames.length > 0;
+    const diagnostics = {
+      plugin: "css-doctor-next",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: 0,
+      minPageRatio: this.pageCoverage.minPageRatio,
+      minify: this.minify,
+      pageCoverage: {
+        enabled: this.pageCoverage.enabled,
+        minPageRatio: this.pageCoverage.minPageRatio
+      },
+      sizeBudget: {
+        enabled: this.sizeBudget.enabled,
+        maxChunkSize: this.sizeBudget.maxChunkSize,
+        isolateVariables: this.sizeBudget.isolateVariables,
+        splitChunks: 0,
+        oversizedChunks: 0
+      },
+      pages: pageNames,
+      pageUsage: pageUsageCounts,
+      splitApplied: pageCoverageApplied,
+      totalCssAssets: 0,
+      analyzedCssAssets: 0,
+      failedCssAssets: 0,
+      skippedCssAssets: 0,
+      totalSizeBeforeBytes: 0,
+      totalSizeAfterBytes: 0,
+      totalSelectors: 0,
+      totalRules: 0,
+      commonCssBytes: 0,
+      pageSpecificCssBytes: 0,
+      emittedPageChunks: [],
+      emittedCssChunks: [],
+      usageMatrix: [],
+      deadCodeCount: 0,
+      files: [],
+      errors: []
+    };
+    diagnostics.errors.push(...this.configurationErrors);
+    const matrix = /* @__PURE__ */ new Map();
+    const pageFiles = /* @__PURE__ */ new Map();
+    const usedAssetNames = new Set(
+      compilation.getAssets().map((asset) => asset.name)
+    );
+    const RawSource = compiler.webpack.sources.RawSource;
+    const emitCssChunk = (chunk) => {
+      const hash = (0, import_node_crypto.createHash)("sha256").update(chunk.css).digest("hex").slice(0, 8);
+      const safeName = chunk.name.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "chunk";
+      let fileName = `static/css/${safeName}.${hash}.css`;
+      let index = 2;
+      while (usedAssetNames.has(fileName)) {
+        fileName = `static/css/${safeName}.${hash}-${index}.css`;
+        index += 1;
+      }
+      compilation.emitAsset(fileName, new RawSource(chunk.css));
+      usedAssetNames.add(fileName);
+      return fileName;
+    };
+    for (const asset of compilation.getAssets()) {
+      if (!asset.name.endsWith(".css")) {
+        continue;
+      }
+      diagnostics.totalCssAssets += 1;
+      if (this.shouldSkipAsset(
+        compilation,
+        asset.name,
+        sourceToString(asset.source.source())
+      )) {
+        diagnostics.skippedCssAssets += 1;
+        continue;
+      }
+      const associatedPages = [
+        ...pagesResult.pagesByCss.get(asset.name) ?? allPages
+      ].sort();
+      const file = analyzeAsset(asset.name, asset.source.source());
+      file.associatedPages = associatedPages;
+      if (file.error) {
+        diagnostics.failedCssAssets += 1;
+        diagnostics.errors.push(`${asset.name}: ${file.error}`);
+        diagnostics.files.push(file);
+        logger.warn(`[css-doctor] ${asset.name}: ${file.error}`);
+        continue;
+      }
+      const originalCss = sourceToString(asset.source.source());
+      try {
+        const pipeline = (0, import_css_doctor_binding.optimizeCss)({
+          cssContent: originalCss,
+          pageUsage,
+          pageCoverage: {
+            enabled: this.pageCoverage.enabled,
+            minPageRatio: this.pageCoverage.minPageRatio,
+            forceCommon: this.pageCoverage.forceCommon
+          },
+          sizeBudget: {
+            enabled: this.sizeBudget.enabled,
+            maxChunkSize: this.sizeBudget.maxChunkSize,
+            isolateVariables: this.sizeBudget.isolateVariables
+          },
+          minify: this.minify
+        });
+        const commonChunks = pipeline.chunks.filter(
+          (chunk) => chunk.page === void 0 && chunk.sourceChunk === "common"
+        );
+        const pageChunks = pipeline.chunks.filter(
+          (chunk) => chunk.page !== void 0
+        );
+        const commonWasSplit = commonChunks.length > 1 || commonChunks.some((chunk) => chunk.splitDueToSize);
+        const embeddedCommon = commonWasSplit ? void 0 : commonChunks[0];
+        const commonFileNames = [];
+        let commonSizeBytes = 0;
+        for (const chunk of commonChunks) {
+          const embedded = chunk === embeddedCommon;
+          const fileName = embedded ? asset.name : emitCssChunk(chunk);
+          commonSizeBytes += chunk.sizeBytes;
+          commonFileNames.push(fileName);
+          diagnostics.emittedCssChunks.push({
+            fileName,
+            sourceChunk: chunk.sourceChunk,
+            kind: chunk.kind,
+            page: chunk.page,
+            variables: chunk.variables,
+            part: chunk.part,
+            sizeBytes: chunk.sizeBytes,
+            oversized: chunk.oversized,
+            splitDueToSize: chunk.splitDueToSize,
+            embedded
+          });
+          if (chunk.splitDueToSize) {
+            diagnostics.sizeBudget.splitChunks += 1;
+          }
+          if (chunk.oversized) {
+            diagnostics.sizeBudget.oversizedChunks += 1;
+          }
+        }
+        if (commonWasSplit) {
+          const imports = commonFileNames.map((fileName) => {
+            const relativePath = import_node_path2.posix.relative(
+              import_node_path2.posix.dirname(asset.name),
+              fileName
+            );
+            return `@import "./${relativePath}";`;
+          }).join("\n");
+          compilation.updateAsset(asset.name, new RawSource(imports));
+        } else {
+          compilation.updateAsset(
+            asset.name,
+            new RawSource(embeddedCommon?.css ?? "")
+          );
+        }
+        let pageSpecificSizeBytes = 0;
+        for (const chunk of pageChunks) {
+          const page = chunk.page;
+          if (!page) {
+            continue;
+          }
+          const fileName = emitCssChunk(chunk);
+          pageSpecificSizeBytes += chunk.sizeBytes;
+          const files = pageFiles.get(page) ?? [];
+          files.push(fileName);
+          pageFiles.set(page, files);
+          diagnostics.emittedPageChunks.push({
+            page,
+            fileName,
+            sizeBytes: chunk.sizeBytes
+          });
+          diagnostics.emittedCssChunks.push({
+            fileName,
+            sourceChunk: chunk.sourceChunk,
+            kind: chunk.kind,
+            page,
+            variables: chunk.variables,
+            part: chunk.part,
+            sizeBytes: chunk.sizeBytes,
+            oversized: chunk.oversized,
+            splitDueToSize: chunk.splitDueToSize,
+            embedded: false
+          });
+          if (chunk.splitDueToSize) {
+            diagnostics.sizeBudget.splitChunks += 1;
+          }
+          if (chunk.oversized) {
+            diagnostics.sizeBudget.oversizedChunks += 1;
+          }
+        }
+        file.sizeAfterBytes = commonWasSplit ? commonSizeBytes : Buffer.byteLength(embeddedCommon?.css ?? "", "utf8");
+        file.split = {
+          associatedPages,
+          commonSizeBytes,
+          pageSpecificSizeBytes,
+          deadCodeCount: pipeline.deadCodeCount
+        };
+        for (const stat of pipeline.stats) {
+          const previous = matrix.get(stat.selector);
+          if (!previous || stat.totalOccurrences > previous.totalOccurrences) {
+            matrix.set(stat.selector, stat);
+          }
+        }
+        diagnostics.deadCodeCount += pipeline.deadCodeCount;
+        diagnostics.commonCssBytes += commonSizeBytes;
+        diagnostics.pageSpecificCssBytes += pageSpecificSizeBytes;
+      } catch (error) {
+        const message = `failed to optimize CSS: ${describeError(error)}`;
+        diagnostics.errors.push(`${asset.name}: ${message}`);
+        logger.warn(`[css-doctor] ${asset.name}: ${message}`);
+      }
+      diagnostics.analyzedCssAssets += 1;
+      diagnostics.totalSizeBeforeBytes += file.sizeBeforeBytes;
+      diagnostics.totalSizeAfterBytes += file.sizeAfterBytes;
+      diagnostics.totalSelectors += file.selectorCount;
+      diagnostics.totalRules += file.ruleCount;
+      diagnostics.files.push(file);
+    }
+    if (pageFiles.size > 0) {
+      injectPageJsLoaders(compilation, pageFiles, pageByName, RawSource);
+    }
+    diagnostics.usageMatrix = [...matrix.values()].sort(
+      (left, right) => left.selector.localeCompare(right.selector)
+    );
+    diagnostics.durationMs = roundMs(import_node_perf_hooks.performance.now() - startedAt);
+    if (this.options.onDiagnostics) {
+      try {
+        await this.options.onDiagnostics(diagnostics);
+      } catch (error) {
+        const message = `onDiagnostics callback failed: ${describeError(
+          error
+        )}`;
+        diagnostics.errors.push(message);
+        logger.warn(`[css-doctor] ${message}`);
+      }
+    }
+    if (this.options.report !== false && (diagnostics.totalCssAssets > 0 || diagnostics.errors.length > 0)) {
+      try {
+        printDiagnostics(diagnostics);
+      } catch (error) {
+        logger.warn(`[css-doctor] reporter failed: ${describeError(error)}`);
+      }
+    }
+  }
+  shouldSkipAsset(compilation, assetName, source) {
+    if (isCssModuleAsset(compilation, assetName, source)) {
+      return true;
+    }
+    if (this.include.length > 0 && !matchesPatterns(assetName, this.include)) {
+      return true;
+    }
+    return this.exclude.length > 0 && matchesPatterns(assetName, this.exclude);
+  }
+};
+function injectPageJsLoaders(compilation, cssByPage, pageByName, RawSource) {
+  const publicPath = typeof compilation.options.output.publicPath === "string" && compilation.options.output.publicPath.length > 0 ? compilation.options.output.publicPath : "/_next/";
+  const normalizedBase = publicPath.endsWith("/") ? publicPath : `${publicPath}/`;
+  for (const [page, files] of cssByPage) {
+    const jsFiles = pageByName.get(page)?.jsFiles;
+    if (!jsFiles || files.length === 0) {
+      continue;
+    }
+    const hrefs = files.map((file) => `${normalizedBase}${file}`);
+    const snippet = `(()=>{const __cssDoctorPageStyles=${JSON.stringify(hrefs)};if(typeof document!=="undefined"){for(const __cssDoctorPageHref of __cssDoctorPageStyles){if(!Array.from(document.querySelectorAll("link[data-css-doctor-page]")).some((link)=>link.dataset.cssDoctorPage===__cssDoctorPageHref)){const __cssDoctorPageLink=document.createElement("link");__cssDoctorPageLink.rel="stylesheet";__cssDoctorPageLink.href=__cssDoctorPageHref;__cssDoctorPageLink.dataset.cssDoctorPage=__cssDoctorPageHref;document.head.append(__cssDoctorPageLink);}}}})();
+`;
+    for (const jsFile of jsFiles) {
+      const asset = compilation.getAsset(jsFile);
+      if (!asset) {
+        continue;
+      }
+      const source = sourceToString(asset.source.source());
+      compilation.updateAsset(jsFile, new RawSource(snippet + source));
+    }
+  }
+}
+function matchesPatterns(value, patterns) {
+  return patterns.some(
+    (pattern) => typeof pattern === "string" ? value.includes(pattern) : pattern.test(value)
+  );
+}
+function isCssModuleAsset(compilation, assetName, source) {
+  if (/\.module\.(css|scss|sass|less|styl|stylus)$/i.test(assetName)) {
+    return true;
+  }
+  if (/\.[A-Za-z0-9_-]+_[A-Za-z0-9_-]+__[A-Za-z0-9_-]+/.test(source)) {
+    return true;
+  }
+  for (const chunk of compilation.chunks) {
+    if (!chunk.files.has(assetName) && !chunk.auxiliaryFiles.has(assetName)) {
+      continue;
+    }
+    for (const module2 of compilation.chunkGraph.getChunkModulesIterable(
+      chunk
+    )) {
+      if (moduleHasCssModule(module2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function moduleHasCssModule(module2) {
+  const nested = module2.modules;
+  if (nested) {
+    for (const child of nested) {
+      if (moduleHasCssModule(child)) {
+        return true;
+      }
+    }
+  }
+  const resource = module2.resource;
+  return typeof resource === "string" && /\.module\.(css|scss|sass|less|styl|stylus)(\?|$)/i.test(resource);
+}
+function analyzeAsset(fileName, source) {
+  try {
+    const css = sourceToString(source);
+    const sizeBeforeBytes = Buffer.byteLength(css, "utf8");
+    const analysis = (0, import_css_doctor_binding.analyzeCss)(css);
+    const warnings = collectSyntaxWarnings(analysis);
+    if (sizeBeforeBytes >= LARGE_CSS_ASSET_BYTES) {
+      warnings.push({
+        kind: "large-asset",
+        message: `CSS asset is larger than ${formatBytes2(
+          LARGE_CSS_ASSET_BYTES
+        )}; consider route-level code splitting.`
+      });
+    }
+    return {
+      fileName,
+      sizeBeforeBytes,
+      sizeAfterBytes: sizeBeforeBytes,
+      selectorCount: analysis.stats.selectorCount,
+      ruleCount: analysis.stats.ruleCount,
+      associatedPages: [],
+      warnings,
+      analysis
+    };
+  } catch (error) {
+    return {
+      fileName,
+      sizeBeforeBytes: 0,
+      sizeAfterBytes: 0,
+      selectorCount: 0,
+      ruleCount: 0,
+      associatedPages: [],
+      warnings: [],
+      error: describeError(error)
+    };
+  }
+}
+async function collectPages(compilation, directPageUsage) {
+  const entries = [...compilation.entrypoints.values()];
+  const pageEntries = [];
+  const sharedEntries = [];
+  const fallbackEntries = [];
+  for (const entry of entries) {
+    const name = entryName(entry);
+    if (!name) {
+      continue;
+    }
+    if (isPageEntry(name)) {
+      const route = routeNameForEntry(name) ?? name;
+      pageEntries.push({ entry, name: route, sourceName: name });
+    } else if (isSharedEntry(name)) {
+      sharedEntries.push(entry);
+    } else if (!isInternalEntry(name)) {
+      fallbackEntries.push({
+        entry,
+        name: routeNameForEntry(name) ?? name,
+        sourceName: name
+      });
+    }
+  }
+  const selectedPages = pageEntries.length > 0 ? pageEntries : fallbackEntries;
+  const direct = directPageUsage ? Object.keys(directPageUsage).length > 0 : false;
+  const pages = /* @__PURE__ */ new Map();
+  const pagesByCss = /* @__PURE__ */ new Map();
+  if (direct && directPageUsage) {
+    for (const [rawName, classes] of Object.entries(directPageUsage)) {
+      const name = rawName.trim();
+      if (!name) {
+        continue;
+      }
+      pages.set(name, {
+        name,
+        classes: new Set(classes.map((className) => className.toLowerCase())),
+        cssFiles: /* @__PURE__ */ new Set(),
+        jsFiles: /* @__PURE__ */ new Set()
+      });
+    }
+  } else {
+    const sourceCache = /* @__PURE__ */ new Map();
+    const sharedClasses = /* @__PURE__ */ new Set();
+    const projectRoot = process.cwd();
+    for (const entry of sharedEntries) {
+      for (const className of await collectEntryClasses(
+        compilation,
+        entry,
+        sourceCache
+      )) {
+        sharedClasses.add(className);
+      }
+      const name = entryName(entry);
+      if (name) {
+        for (const className of await collectNameSourceClasses(
+          name,
+          projectRoot,
+          sourceCache
+        )) {
+          sharedClasses.add(className);
+        }
+      }
+    }
+    for (const { entry, name, sourceName } of selectedPages) {
+      const page = pages.get(name) ?? {
+        name,
+        classes: /* @__PURE__ */ new Set(),
+        cssFiles: /* @__PURE__ */ new Set(),
+        jsFiles: collectEntryJsFiles(entry)
+      };
+      for (const jsFile of collectEntryJsFiles(entry)) {
+        page.jsFiles.add(jsFile);
+      }
+      for (const className of sharedClasses) {
+        page.classes.add(className);
+      }
+      for (const className of await collectEntryClasses(
+        compilation,
+        entry,
+        sourceCache
+      )) {
+        page.classes.add(className);
+      }
+      for (const className of await collectPageSourceClasses(
+        sourceName,
+        projectRoot,
+        sourceCache
+      )) {
+        page.classes.add(className);
+      }
+      pages.set(name, page);
+    }
+  }
+  const targetPages = [...pages.keys()];
+  for (const { entry, name } of selectedPages) {
+    const cssFiles = collectEntryCssFiles(entry);
+    if (direct) {
+      const directPage = pages.get(name);
+      if (directPage) {
+        for (const cssFile of cssFiles) {
+          directPage.cssFiles.add(cssFile);
+        }
+      }
+    } else {
+      const page = pages.get(name);
+      if (page) {
+        for (const cssFile of cssFiles) {
+          page.cssFiles.add(cssFile);
+        }
+      }
+    }
+  }
+  const sharedCssFiles = /* @__PURE__ */ new Set();
+  for (const entry of sharedEntries) {
+    for (const cssFile of collectEntryCssFiles(entry)) {
+      sharedCssFiles.add(cssFile);
+    }
+  }
+  for (const page of pages.values()) {
+    for (const cssFile of page.cssFiles) {
+      addCssOwner(pagesByCss, cssFile, page.name);
+    }
+  }
+  for (const cssFile of sharedCssFiles) {
+    for (const page of targetPages) {
+      addCssOwner(pagesByCss, cssFile, page);
+    }
+  }
+  return {
+    pages: [...pages.values()],
+    pagesByCss
+  };
+}
+async function collectPageSourceClasses(entryName2, projectRoot, sourceCache) {
+  const classes = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const normalized = normalizeSlashes(entryName2);
+  const candidates = [];
+  if (normalized.startsWith("app/")) {
+    const path = normalized.slice(4);
+    if (path === "page" || path.endsWith("/page")) {
+      const pagePath = path === "page" ? "app/page" : `app/${path}`;
+      candidates.push((0, import_node_path2.resolve)(projectRoot, pagePath));
+      if (path === "_not-found/page") {
+        candidates.push((0, import_node_path2.resolve)(projectRoot, "app/not-found"));
+      }
+      const directories = path.split("/").slice(0, -1).filter(Boolean);
+      const layoutPaths = ["app"];
+      for (let index = 0; index < directories.length; index += 1) {
+        layoutPaths.push(`app/${directories.slice(0, index + 1).join("/")}`);
+      }
+      for (const layoutPath of layoutPaths) {
+        candidates.push((0, import_node_path2.resolve)(projectRoot, `${layoutPath}/layout`));
+      }
+    } else {
+      candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
+    }
+  } else if (normalized.startsWith("pages/")) {
+    candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
+    candidates.push((0, import_node_path2.resolve)(projectRoot, "pages/_app"));
+  } else {
+    candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
+  }
+  for (const candidate of candidates) {
+    const file = findSourceFile(candidate);
+    if (file) {
+      await scanSourceFile(file, classes, projectRoot, sourceCache, visited);
+    }
+  }
+  return classes;
+}
+async function collectNameSourceClasses(entryName2, projectRoot, sourceCache) {
+  const classes = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const candidate = (0, import_node_path2.resolve)(projectRoot, normalizeSlashes(entryName2));
+  const file = findSourceFile(candidate);
+  if (file) {
+    await scanSourceFile(file, classes, projectRoot, sourceCache, visited);
+  }
+  return classes;
+}
+async function scanSourceFile(filePath, classes, projectRoot, sourceCache, visited) {
+  const absolutePath = (0, import_node_path2.resolve)(filePath);
+  if (visited.has(absolutePath)) {
+    return;
+  }
+  visited.add(absolutePath);
+  let pending = sourceCache.get(absolutePath);
+  if (!pending) {
+    pending = (0, import_promises.readFile)(absolutePath, "utf8").catch(() => void 0);
+    sourceCache.set(absolutePath, pending);
+  }
+  const source = await pending;
+  if (!source) {
+    return;
+  }
+  scanClasses(source, classes);
+  for (const specifier of extractImportSpecifiers(source)) {
+    const resolved = resolveImportSpecifier(
+      specifier,
+      absolutePath,
+      projectRoot
+    );
+    if (resolved && !visited.has(resolved)) {
+      await scanSourceFile(
+        resolved,
+        classes,
+        projectRoot,
+        sourceCache,
+        visited
+      );
+    }
+  }
+}
+var SOURCE_EXTENSIONS = [
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".mdx"
+];
+function findSourceFile(basePath) {
+  if (isStyleFile(basePath)) {
+    return null;
+  }
+  if ((0, import_node_path2.extname)(basePath) && (0, import_node_fs2.existsSync)(basePath)) {
+    return basePath;
+  }
+  for (const extension of SOURCE_EXTENSIONS) {
+    const candidate = `${basePath}${extension}`;
+    if ((0, import_node_fs2.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  for (const extension of SOURCE_EXTENSIONS) {
+    const candidate = (0, import_node_path2.resolve)(basePath, `index${extension}`);
+    if ((0, import_node_fs2.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function extractImportSpecifiers(source) {
+  const specifiers = /* @__PURE__ */ new Set();
+  const patterns = [
+    /(?:import|export)\s+(?:type\s+)?(?:[^'"]*?\s+from\s+)?['"]([^'"]+)['"]/g,
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) {
+      const specifier = match[1];
+      if (specifier) {
+        specifiers.add(specifier);
+      }
+    }
+  }
+  return [...specifiers];
+}
+function resolveImportSpecifier(specifier, fromFile, projectRoot) {
+  let basePath;
+  if (specifier.startsWith("@/")) {
+    basePath = (0, import_node_path2.resolve)(projectRoot, specifier.slice(2));
+  } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    basePath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(fromFile), specifier);
+  } else {
+    return null;
+  }
+  if (isStyleFile(basePath)) {
+    return null;
+  }
+  return findSourceFile(basePath);
+}
+async function collectEntryClasses(compilation, entry, sourceCache) {
+  const classes = /* @__PURE__ */ new Set();
+  const visitedModules = /* @__PURE__ */ new Set();
+  for (const chunk of entry.chunks) {
+    for (const module2 of compilation.chunkGraph.getChunkModulesIterable(
+      chunk
+    )) {
+      await scanModule(module2, classes, sourceCache, visitedModules);
+    }
+  }
+  return classes;
+}
+async function scanModule(module2, classes, sourceCache, visited) {
+  if (visited.has(module2)) {
+    return;
+  }
+  visited.add(module2);
+  const nested = module2.modules;
+  if (nested) {
+    for (const child of nested) {
+      await scanModule(child, classes, sourceCache, visited);
+    }
+  }
+  const resource = module2.resource;
+  if (typeof resource !== "string" || isStyleFile(resource)) {
+    return;
+  }
+  const source = readModuleSource(module2);
+  if (source) {
+    scanClasses(source, classes);
+    return;
+  }
+  if (!isScannableSource(resource)) {
+    return;
+  }
+  const filePath = resource.split("?")[0] ?? resource;
+  if (!filePath) {
+    return;
+  }
+  let pending = sourceCache.get(filePath);
+  if (!pending) {
+    pending = (0, import_promises.readFile)(filePath, "utf8").catch(() => void 0);
+    sourceCache.set(filePath, pending);
+  }
+  const fresh = await pending;
+  if (fresh) {
+    scanClasses(fresh, classes);
+  }
+}
+function readModuleSource(module2) {
+  try {
+    const source = module2.originalSource();
+    if (!source) {
+      return void 0;
+    }
+    return sourceToString(source.source());
+  } catch {
+    return void 0;
+  }
+}
+function collectEntryJsFiles(entry) {
+  const files = /* @__PURE__ */ new Set();
+  for (const file of entry.getFiles()) {
+    if (file.endsWith(".js")) {
+      files.add(file);
+    }
+  }
+  return files;
+}
+function collectEntryCssFiles(entry) {
+  const cssFiles = /* @__PURE__ */ new Set();
+  for (const file of entry.getFiles()) {
+    if (file.endsWith(".css")) {
+      cssFiles.add(file);
+    }
+  }
+  for (const chunk of entry.chunks) {
+    for (const file of chunk.files) {
+      if (file.endsWith(".css")) {
+        cssFiles.add(file);
+      }
+    }
+    for (const file of chunk.auxiliaryFiles) {
+      if (file.endsWith(".css")) {
+        cssFiles.add(file);
+      }
+    }
+  }
+  return cssFiles;
+}
+function entryName(entry) {
+  if (entry.name) {
+    return entry.name;
+  }
+  const chunk = entry.getEntrypointChunk();
+  return chunk.name ?? void 0;
+}
+function isPageEntry(name) {
+  const normalized = normalizeSlashes(name);
+  if (normalized.startsWith("app/")) {
+    const path = normalized.slice(4);
+    return path === "page" || path.endsWith("/page");
+  }
+  if (normalized.startsWith("pages/")) {
+    const path = normalized.slice(6);
+    return path.length > 0 && !path.split("/").some((segment) => segment.startsWith("_"));
+  }
+  return false;
+}
+function isSharedEntry(name) {
+  const normalized = normalizeSlashes(name);
+  return normalized.startsWith("app/") && (normalized === "app/layout" || normalized.endsWith("/layout")) || normalized === "pages/_app" || normalized === "pages/_document";
+}
+function isInternalEntry(name) {
+  const normalized = normalizeSlashes(name);
+  const base = normalized.split("/").pop() ?? normalized;
+  return base === "main" || base === "main-app" || base === "polyfills" || base === "webpack" || base === "app-pages-internals" || base === "middleware" || base === "instrumentation";
+}
+function routeNameForEntry(name) {
+  const normalized = normalizeSlashes(name).replace(/^\.\//, "");
+  if (normalized.startsWith("app/")) {
+    let path = normalized.slice(4);
+    if (path === "page") {
+      return "/";
+    }
+    if (path.endsWith("/page")) {
+      path = path.slice(0, -"/page".length);
+    }
+    if (!path || path.endsWith("layout")) {
+      return null;
+    }
+    return `/${path}`;
+  }
+  if (normalized.startsWith("pages/")) {
+    let path = normalized.slice(6);
+    if (!path || path.startsWith("_")) {
+      return null;
+    }
+    path = path.replace(/\/?index$/, "");
+    return path.length > 0 ? `/${path}` : "/";
+  }
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeSlashes(value) {
+  return value.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isStyleFile(resource) {
+  return /\.(css|scss|sass|less|styl|stylus)(\?|$)/i.test(resource);
+}
+function isScannableSource(resource) {
+  return /\.(js|jsx|ts|tsx|mjs|cjs|mts|cts|html?|vue|svelte|mdx)(\?|$)/i.test(
+    resource
+  );
+}
+function scanClasses(source, classes) {
+  const patterns = [
+    /(?:class|className)\s*=\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)/g,
+    /(?:^|[,{;\s])(?:class|className)\s*:\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)/g,
+    /classList\.(?:add|remove|toggle|contains)\(\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) {
+      const value = match[1] ?? match[2] ?? match[3];
+      if (!value) {
+        continue;
+      }
+      for (const token of value.split(/\s+/)) {
+        if (/^-?[_a-zA-Z][\w-]*$/.test(token)) {
+          classes.add(token.toLowerCase());
+        }
+      }
+    }
+  }
+}
+function addCssOwner(pagesByCss, cssFile, page) {
+  const owners = pagesByCss.get(cssFile) ?? /* @__PURE__ */ new Set();
+  owners.add(page);
+  pagesByCss.set(cssFile, owners);
+}
+function collectSyntaxWarnings(analysis) {
+  return analysis.warnings.map((warning) => ({
+    kind: "syntax",
+    message: warning.message,
+    ...warning.location ? {
+      line: warning.location.line,
+      column: warning.location.column
+    } : {}
+  }));
+}
+function sourceToString(source) {
+  return typeof source === "string" ? source : Buffer.from(source).toString("utf8");
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function roundMs(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/index.ts
+function withCssDoctor(nextConfig = {}, options = {}) {
+  const pluginOptions = resolvePluginOptions(options);
+  const originalWebpack = nextConfig.webpack;
+  const webpack = (config, context) => {
+    const result = originalWebpack ? originalWebpack(config, context) : config;
+    if (isPromiseLike(result)) {
+      return result.then(
+        (resolvedConfig) => enableCssDoctor(resolvedConfig, context, pluginOptions)
+      );
+    }
+    return enableCssDoctor(result, context, pluginOptions);
+  };
+  return {
+    ...nextConfig,
+    webpack
+  };
+}
+function enableCssDoctor(config, context, options) {
+  if (!isRecord2(config)) {
+    return config;
+  }
+  if (context.dev === true || context.isServer === true) {
+    return config;
+  }
+  const webpackConfig = config;
+  const plugins = Array.isArray(webpackConfig.plugins) ? [...webpackConfig.plugins] : [];
+  const alreadyInstalled = plugins.some(
+    (plugin) => plugin instanceof CssDoctorWebpackPlugin
+  );
+  if (!alreadyInstalled) {
+    plugins.push(new CssDoctorWebpackPlugin(options));
+  }
+  webpackConfig.plugins = plugins;
+  if (options.minify === false) {
+    disableNextCssMinifier(webpackConfig);
+  }
+  return webpackConfig;
+}
+function disableNextCssMinifier(config) {
+  const optimization = config.optimization;
+  if (!optimization || !Array.isArray(optimization.minimizer)) {
+    return;
+  }
+  optimization.minimizer = optimization.minimizer.filter((plugin) => {
+    const source = typeof plugin === "function" ? Function.prototype.toString.call(plugin) : String(plugin);
+    return !source.includes("CssMinimizerPlugin") && !source.includes("css-minimizer-plugin");
+  });
+}
+function resolvePluginOptions(options) {
+  const { configFile, ...inlineOptions } = options;
+  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
+  let loadedOptions = {};
+  let configError;
+  if (configFile) {
+    const loaded = loadCssDoctorConfig({ configFile });
+    loadedOptions = loaded.options;
+    configError = loaded.error;
+  } else if (!hasInlineOptions) {
+    const loaded = loadCssDoctorConfig();
+    loadedOptions = loaded.options;
+    configError = loaded.error;
+  }
+  if (configError) {
+    console.warn(
+      `[css-doctor] ${configError}. Continuing with inline/default options.`
+    );
+  }
+  const merged = {
+    ...loadedOptions,
+    ...inlineOptions
+  };
+  const { configFile: _ignored, ...pluginOptions } = merged;
+  return pluginOptions;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findCssDoctorConfig,
+  loadCssDoctorConfig,
+  withCssDoctor
+});
+//# sourceMappingURL=index.cjs.map