@wular/coder 0.4.6 → 0.4.8

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-1y0cesgn.js

@@ -0,0 +1,1071 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  createVerboseLogger
+} from "./index-73z4esab.js";
+import {
+  cssClassNames,
+  cssModuleClassName,
+  cssModuleMapping,
+  hashedAssetName,
+  isCssModuleFile,
+  recordEmittedAsset
+} from "./index-xrsg0041.js";
+import {
+  readSourceSync
+} from "./index-fp8r0sqs.js";
+import {
+  build
+} from "./index-cjgqs13g.js";
+import {
+  ensureDir,
+  readText
+} from "./index-4qsce64w.js";
+import {
+  outCachePath
+} from "./index-bzd2ef7t.js";
+import {
+  productionRelease
+} from "./index-fpghsgb4.js";
+import {
+  resolveImport
+} from "./index-d1jsmhhk.js";
+import {
+  extraPageExtensions,
+  getCssExtensions
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/css/build.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile, rename, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/css/postcss.ts
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { writeFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var postcssProcessors = new Map;
+var tailwindScannerPatch = Symbol.for("pnext.tailwind-scanner-v1");
+var tailwindCandidateSchema = 1;
+var warnedTailwindScannerVersions = new Set;
+function postcssConfigFile(root) {
+  for (const file of ["postcss.config.cjs", "postcss.config.js", "postcss.config.mjs"]) {
+    const full = path.join(root, file);
+    if (existsSync(full))
+      return full;
+  }
+  return;
+}
+function loadPostcss(root, options) {
+  const key = `${root}\x00${options.dev ? "dev" : "build"}\x00${options.outDir ?? ""}`;
+  let processor = postcssProcessors.get(key);
+  if (!processor) {
+    processor = createPostcssProcessor(root, options).catch((error) => {
+      postcssProcessors.delete(key);
+      throw error;
+    });
+    postcssProcessors.set(key, processor);
+  }
+  return processor;
+}
+async function runPostcss(root, cssFile, options, fromSource) {
+  const loaded = await loadPostcss(root, options);
+  if (!loaded)
+    return;
+  const from = fromSource ?? cssFile;
+  const css = await readText(cssFile);
+  const result = await loaded.processor.process(css + keptExclusions(loaded.sources, css, from, loaded.partitionedTailwindScan), { from, to: cssFile });
+  await writeFile(cssFile, result.css);
+}
+async function createPostcssProcessor(root, options) {
+  const configFile = postcssConfigFile(root);
+  if (!configFile)
+    return;
+  const loaded = await import(pathToFileURL(configFile).href);
+  const config = "default" in loaded && loaded.default ? loaded.default : loaded;
+  const { plugins, partitionedTailwindScan } = postcssPlugins(root, config, options);
+  if (plugins.length === 0)
+    return;
+  const appRequire = createRequire(path.join(root, "package.json"));
+  const postcss = interopDefault(resolvePostcss(appRequire));
+  const tailwind = pluginEntries(config).some(([specifier, pluginOptions]) => specifier === "@tailwindcss/postcss" && pluginOptions !== false);
+  return {
+    processor: postcss(plugins),
+    sources: tailwind ? scanExclusions(root, appRequire, options) : "",
+    partitionedTailwindScan
+  };
+}
+function keptExclusions(exclusions, css, fromFile, partitionedTailwindScan = false) {
+  if (!exclusions || partitionedTailwindScan)
+    return exclusions;
+  const dir = path.dirname(fromFile);
+  const globs = [...css.matchAll(/@source\s+(?!not\s)['"]([^'"]+)['"]/g)].map((match) => path.resolve(dir, match[1].replace(/[*{[].*$/, "")));
+  if (globs.length === 0)
+    return exclusions;
+  const kept = exclusions.split(`
+`).filter((line) => {
+    const match = /@source not "([^"]+)"/.exec(line);
+    return !match || !globs.some((glob) => glob === match[1] || glob.startsWith(match[1] + "/"));
+  }).join(`
+`);
+  return kept.includes("@source not") ? kept : "";
+}
+function scanExclusions(root, appRequire, options) {
+  if (process.env.PNEXT_TAILWIND_SCAN_ALL)
+    return "";
+  const [major, minor] = packageVersion(appRequire, "@tailwindcss/postcss");
+  if (major < 4 || major === 4 && minor < 1)
+    return "";
+  const dirs = ["node_modules", ".next", options.outDir ?? ".pnext"];
+  const excluded = [...new Set(dirs.map((dir) => path.resolve(root, dir)))].filter((dir) => dir.startsWith(root + path.sep));
+  if (excluded.length === 0)
+    return "";
+  return `
+${excluded.map((dir) => `@source not ${JSON.stringify(dir.split(path.sep).join("/"))};`).join(`
+`)}
+`;
+}
+function packageVersion(req, name) {
+  try {
+    const pkg = JSON.parse(readFileSync(req.resolve(`${name}/package.json`), "utf8"));
+    const [major, minor] = (pkg.version ?? "").split(".");
+    return [Number.parseInt(major ?? "", 10) || 0, Number.parseInt(minor ?? "", 10) || 0];
+  } catch {
+    return [0, 0];
+  }
+}
+function pluginEntries(config) {
+  return Array.isArray(config.plugins) ? config.plugins.map((entry) => Array.isArray(entry) ? [entry[0], entry[1]] : [entry, undefined]) : Object.entries(config.plugins ?? {});
+}
+function postcssPlugins(root, config, options) {
+  const appRequire = createRequire(path.join(root, "package.json"));
+  const entries = pluginEntries(config);
+  const plugins = [];
+  let partitionedTailwindScan = false;
+  for (const [specifier, pluginOptions] of entries) {
+    if (pluginOptions === false)
+      continue;
+    if (typeof specifier !== "string") {
+      if (specifier)
+        plugins.push(specifier);
+      continue;
+    }
+    const patchedScanner = specifier === "@tailwindcss/postcss" ? configureTailwindScanner(appRequire, root, options) : undefined;
+    const factory = interopDefault(appRequire(specifier));
+    if (patchedScanner) {
+      assertTailwindScannerPatch(appRequire, patchedScanner);
+      partitionedTailwindScan = true;
+    }
+    const resolvedOptions = pluginOptionsFor(root, specifier, pluginOptions, options);
+    plugins.push(typeof factory === "function" ? factory(resolvedOptions) : factory);
+  }
+  return { plugins, partitionedTailwindScan };
+}
+function configureTailwindScanner(appRequire, root, options) {
+  const pluginPackage = appRequire.resolve("@tailwindcss/postcss/package.json");
+  const pluginRequire = createRequire(pluginPackage);
+  const oxide = pluginRequire("@tailwindcss/oxide");
+  const versions = ["@tailwindcss/postcss", "tailwindcss", "@tailwindcss/oxide"].map((name) => ({
+    name,
+    version: packageVersionText(pluginRequire, name),
+    tuple: packageVersion(pluginRequire, name)
+  }));
+  if (!versions.every(({ tuple: [major, minor] }) => major === 4 && minor === 3)) {
+    const label = versions.map(({ name, version }) => `${name}@${version}`).join(", ");
+    if (!warnedTailwindScannerVersions.has(label)) {
+      warnedTailwindScannerVersions.add(label);
+      console.warn(`PNext: unsupported Tailwind scanner versions (${label}); using native Scanner.`);
+    }
+    return;
+  }
+  const registration = {
+    root: path.resolve(root),
+    cacheDir: path.join(path.resolve(root, options.outDir ?? ".pnext"), "cache/tailwind/candidates/v1"),
+    versions: ["@tailwindcss/postcss", "tailwindcss", "@tailwindcss/oxide", "postcss"].map((name) => `${name}@${packageVersionText(pluginRequire, name)}`).join("\x00")
+  };
+  const installed = oxide[tailwindScannerPatch];
+  if (installed) {
+    if (oxide.Scanner !== installed.Scanner)
+      throw tailwindScannerPatchError();
+    const index = installed.registrations.findIndex((item) => item.root === registration.root);
+    if (index === -1)
+      installed.registrations.push(registration);
+    else
+      installed.registrations[index] = registration;
+    return installed.Scanner;
+  }
+  const NativeScanner = oxide.Scanner;
+  const registrations = [registration];
+
+  class PnextTailwindScanner {
+    scanners;
+    registration;
+    constructor({ sources = [] }) {
+      this.registration = tailwindRegistration(registrations, sources);
+      this.scanners = partitionTailwindSources(sources).map((partition) => ({
+        scanner: new NativeScanner({ sources: partition }),
+        inventory: new NativeScanner({ sources: partition }),
+        sources: partition
+      }));
+    }
+    scan() {
+      return sortedUnique(this.scanners.flatMap(({ scanner, inventory, sources }) => this.registration ? cachedTailwindCandidates(inventory, sources, this.registration, () => new NativeScanner({ sources }).scan()) : scanner.scan()));
+    }
+    scanFiles(input) {
+      return sortedUnique(this.scanners.flatMap(({ scanner }) => scanner.scanFiles(input)));
+    }
+    getCandidatesWithPositions(input) {
+      return this.scanners.flatMap(({ scanner }) => scanner.getCandidatesWithPositions(input));
+    }
+    get files() {
+      return sortedUnique(this.scanners.flatMap(({ inventory }) => inventory.files));
+    }
+    get scannedFiles() {
+      return sortedUnique(this.scanners.flatMap(({ scanner }) => scanner.scannedFiles));
+    }
+    get globs() {
+      return uniqueTailwindGlobs(this.scanners.flatMap(({ scanner }) => scanner.globs));
+    }
+    get normalizedSources() {
+      return uniqueTailwindGlobs(this.scanners.flatMap(({ scanner }) => scanner.normalizedSources));
+    }
+  }
+  oxide.Scanner = PnextTailwindScanner;
+  oxide[tailwindScannerPatch] = { registrations, Scanner: PnextTailwindScanner };
+  return PnextTailwindScanner;
+}
+function assertTailwindScannerPatch(appRequire, expected) {
+  const pluginPackage = appRequire.resolve("@tailwindcss/postcss/package.json");
+  const oxide = createRequire(pluginPackage)("@tailwindcss/oxide");
+  if (oxide.Scanner !== expected || oxide[tailwindScannerPatch]?.Scanner !== expected) {
+    throw tailwindScannerPatchError();
+  }
+}
+function tailwindScannerPatchError() {
+  return new Error("PNext could not install its Tailwind Scanner integration. The loaded @tailwindcss/postcss module does not observe the patched @tailwindcss/oxide Scanner; refusing to drop explicit @source utilities.");
+}
+function partitionTailwindSources(sources) {
+  const broadExclusions = sources.filter((source) => source.negated && !/[*?{[]/.test(source.pattern));
+  const dependencySources = sources.filter((source) => !source.negated && broadExclusions.some((exclusion) => isInside(sourcePrefix(exclusion), sourcePrefix(source))));
+  if (dependencySources.length === 0)
+    return [sources];
+  const dependencySet = new Set(dependencySources);
+  const appSources = sources.filter((source) => !dependencySet.has(source));
+  return [appSources].concat(dependencySources.map((source) => [
+    source,
+    ...sources.filter((exclusion) => exclusion.negated && !broadExclusions.includes(exclusion) && pathsOverlap(sourcePrefix(source), sourcePrefix(exclusion)))
+  ].map(resolveTailwindSource)));
+}
+function resolveTailwindSource(source) {
+  const globAt = source.pattern.search(/[*?{[]/);
+  const literal = (globAt === -1 ? source.pattern : source.pattern.slice(0, globAt)).replace(/[\\/]$/, "");
+  const absolutePattern = path.resolve(source.base, source.pattern);
+  let absolute = path.resolve(source.base, literal || ".");
+  while (!existsSync(absolute)) {
+    const parent = path.dirname(absolute);
+    if (parent === absolute)
+      return source;
+    absolute = parent;
+  }
+  try {
+    const stat = statSync(absolute);
+    if (globAt === -1 && stat.isFile()) {
+      return {
+        ...source,
+        base: realpathSync.native(path.dirname(absolute)),
+        pattern: path.basename(absolute)
+      };
+    }
+    return {
+      ...source,
+      base: realpathSync.native(absolute),
+      pattern: globAt === -1 ? "**/*" : path.relative(absolute, absolutePattern).split(path.sep).join("/")
+    };
+  } catch {
+    return source;
+  }
+}
+function sourcePrefix(source) {
+  const prefix = source.pattern.replace(/[*?{[].*$/, "").replace(/[\\/]$/, "") || ".";
+  return path.resolve(source.base, prefix);
+}
+function pathsOverlap(left, right) {
+  return isInside(left, right) || isInside(right, left);
+}
+function isInside(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function tailwindRegistration(registrations, sources) {
+  return [...registrations].sort((left, right) => right.root.length - left.root.length).find((item) => sources.some((source) => isInside(item.root, path.resolve(source.base))));
+}
+function cachedTailwindCandidates(inventory, sources, registration, scan) {
+  let cache;
+  try {
+    cache = tailwindCacheIdentity(inventory, sources, registration);
+  } catch {
+    return scan();
+  }
+  const stored = readJson(cache.file);
+  if (stored?.schema === tailwindCandidateSchema && stored.fingerprint === cache.fingerprint && Array.isArray(stored.candidates) && stored.candidates.every((candidate) => typeof candidate === "string")) {
+    return stored.candidates;
+  }
+  const candidates = scan();
+  try {
+    mkdirSync(registration.cacheDir, { recursive: true });
+    atomicJsonWrite(cache.file, {
+      schema: tailwindCandidateSchema,
+      fingerprint: cache.fingerprint,
+      candidates,
+      files: cache.files
+    });
+  } catch {}
+  return candidates;
+}
+function tailwindCacheIdentity(scanner, sources, registration) {
+  const identities = sources.map(tailwindSourceIdentity);
+  const sourceKey = createHash("sha256").update(String(tailwindCandidateSchema)).update("\x00").update(registration.versions).update("\x00").update(JSON.stringify(identities)).digest("hex");
+  const files = scanner.files.map((file) => path.resolve(file)).sort();
+  const fingerprint = createHash("sha256").update(sourceKey);
+  for (const file of files) {
+    fingerprint.update("\x00").update(file).update("\x00").update(readFileSync(file));
+  }
+  return {
+    file: path.join(registration.cacheDir, `${sourceKey}.json`),
+    fingerprint: fingerprint.digest("hex"),
+    files: files.length
+  };
+}
+function tailwindSourceIdentity(source) {
+  const prefix = sourcePrefix(source);
+  const real = realExistingPath(prefix);
+  const packageFile = nearestPackageJson(real);
+  let packageIdentity;
+  if (packageFile) {
+    const pkg = readJson(packageFile);
+    if (pkg) {
+      packageIdentity = { name: pkg.name, version: pkg.version };
+    }
+  }
+  return { ...source, base: path.resolve(source.base), real, package: packageIdentity };
+}
+function realExistingPath(input) {
+  let current = input;
+  while (!existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current)
+      return input;
+    current = parent;
+  }
+  try {
+    const stat = statSync(current);
+    return realpathSync.native(stat.isFile() ? path.dirname(current) : current);
+  } catch {
+    return current;
+  }
+}
+function nearestPackageJson(input) {
+  let current = input;
+  while (true) {
+    const file = path.join(current, "package.json");
+    if (existsSync(file))
+      return file;
+    const parent = path.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return;
+}
+function atomicJsonWrite(file, value) {
+  const temporary = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(temporary, JSON.stringify(value));
+  renameSync(temporary, file);
+}
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+function uniqueTailwindGlobs(globs) {
+  const seen = new Set;
+  return globs.filter((glob) => {
+    const key = `${glob.base}\x00${glob.pattern}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function packageVersionText(req, name) {
+  try {
+    return JSON.parse(readFileSync(req.resolve(`${name}/package.json`), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function pluginOptionsFor(root, specifier, userOptions, options) {
+  if (specifier !== "@tailwindcss/postcss")
+    return userOptions;
+  return {
+    base: root,
+    optimize: options.dev ? false : { minify: true },
+    ...typeof userOptions === "object" && userOptions !== null ? userOptions : {}
+  };
+}
+function resolvePostcss(appRequire) {
+  let appPostcss;
+  try {
+    appPostcss = appRequire("postcss");
+    if (packageVersion(appRequire, "postcss")[0] >= 8)
+      return appPostcss;
+  } catch {}
+  const ownPostcss = resolveOwnPostcss();
+  if (ownPostcss)
+    return ownPostcss;
+  try {
+    const pluginPackage = appRequire.resolve("@tailwindcss/postcss/package.json");
+    return createRequire(pluginPackage)("postcss");
+  } catch {
+    if (appPostcss)
+      return appPostcss;
+    throw new Error("Could not resolve a PostCSS installation for the CSS pipeline.");
+  }
+}
+function resolveOwnPostcss() {
+  try {
+    const ownRequire = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/css/postcss.ts").href);
+    if (packageVersion(ownRequire, "postcss")[0] >= 8)
+      return ownRequire("postcss");
+  } catch {}
+  return;
+}
+function interopDefault(mod) {
+  if (typeof mod === "function")
+    return mod;
+  if (mod && typeof mod === "object" && "default" in mod && mod.default)
+    return mod.default;
+  return mod;
+}
+// src/css/build.ts
+var worker;
+var workerFailed = false;
+var nextId = 0;
+var pending = new Map;
+function ensureWorker() {
+  if (worker || workerFailed)
+    return worker;
+  try {
+    worker = new Worker(new URL("./worker.ts", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/css/build.ts").href).href, {
+      type: "module"
+    });
+  } catch {
+    workerFailed = true;
+    return;
+  }
+  worker.unref();
+  worker.onmessage = (event) => {
+    const { id, error } = event.data;
+    const entry = pending.get(id);
+    if (!entry)
+      return;
+    pending.delete(id);
+    if (pending.size === 0)
+      worker?.unref();
+    if (!error)
+      return entry.resolve();
+    const failure = new Error(error.message);
+    failure.name = error.name;
+    if (error.stack)
+      failure.stack = error.stack;
+    entry.reject(failure);
+  };
+  worker.onerror = () => failWorker(new Error("pnext CSS worker crashed"));
+  return worker;
+}
+function failWorker(error) {
+  workerFailed = true;
+  worker = undefined;
+  for (const entry of pending.values())
+    entry.reject(error);
+  pending.clear();
+}
+function send(request) {
+  const active = ensureWorker();
+  if (!active)
+    return;
+  const id = nextId++;
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    active.ref();
+    active.postMessage(request(id));
+  });
+}
+async function stopCssWorker() {
+  const active = worker;
+  worker = undefined;
+  if (active)
+    await Promise.resolve(active.terminate());
+}
+function scanOutDir(config, dev) {
+  return dev ? config.outPath : config.outRootPath;
+}
+async function runPostcssOffThread(config, cssFile, options, from) {
+  const dev = options.dev ?? false;
+  const { root } = config;
+  const outDir = scanOutDir(config, dev);
+  const sent = send((id) => ({ kind: "process", id, root, dev, outDir, cssFile, from }));
+  if (sent)
+    return sent;
+  return runPostcss(root, cssFile, { dev, outDir }, from);
+}
+function warmCssWorker(config, options = {}) {
+  send((id) => ({
+    kind: "warm",
+    id,
+    root: config.root,
+    dev: options.dev ?? false,
+    outDir: scanOutDir(config, options.dev ?? false)
+  }))?.catch(() => {});
+}
+function globalCssSource(config) {
+  return globalCssSources(config)[0];
+}
+function globalCssSources(config) {
+  return productionRelease(config)?.globalCss ?? globalCssSourcesForPaths(config.root, config.appPath, config.workspaceRoot);
+}
+var globalCssSourceCache = new Map;
+var globalCssStore;
+function setGlobalCssSourceStore(store) {
+  globalCssStore = store;
+}
+function globalCssSourcesForPaths(root, appPath, workspaceRoot) {
+  const key = `${root}\x00${appPath}\x00${workspaceRoot ?? ""}`;
+  const cached = globalCssSourceCache.get(key);
+  if (cached)
+    return cached;
+  const stored = globalCssStore?.load(key);
+  if (stored) {
+    globalCssSourceCache.set(key, stored);
+    return stored;
+  }
+  const sources = new Set;
+  const visited = new Set;
+  const missing = new Set;
+  collectGlobalCssSources(root, rootLayoutFile(appPath, missing), sources, visited, missing, workspaceRoot);
+  const resolved = [...sources].map((file) => path2.resolve(file));
+  globalCssSourceCache.set(key, resolved);
+  globalCssStore?.save(key, resolved, [...visited], [...missing]);
+  return resolved;
+}
+function clearGlobalCssSourceCache() {
+  globalCssSourceCache.clear();
+}
+function collectGlobalCssSources(root, file, sources, visited, missing, workspaceRoot) {
+  const resolvedFile = path2.resolve(file);
+  if (visited.has(resolvedFile))
+    return;
+  if (!existsSync2(resolvedFile)) {
+    missing?.add(resolvedFile);
+    return;
+  }
+  visited.add(resolvedFile);
+  for (const specifier of moduleSpecifiers(readSourceSync(resolvedFile))) {
+    const resolved = resolveImport(root, resolvedFile, specifier, workspaceRoot);
+    if (!resolved)
+      continue;
+    if (isCssFile(resolved)) {
+      sources.add(resolved);
+    } else {
+      collectGlobalCssSources(root, resolved, sources, visited, missing, workspaceRoot);
+    }
+  }
+}
+function rootLayoutFile(appPath, missing) {
+  for (const extension of ["tsx", "ts", "jsx", "js", "mjs", ...extraPageExtensions()]) {
+    const file = path2.join(appPath, `layout.${extension}`);
+    if (existsSync2(file))
+      return file;
+    missing?.add(file);
+  }
+  return path2.join(appPath, "layout.tsx");
+}
+function warmCssPipeline(config, options = {}) {
+  if (!hasPostcssConfig(config.root))
+    return;
+  warmCssWorker(config, options);
+}
+async function buildGlobalCss(config, options = {}) {
+  const log = createVerboseLogger(options.verbose ?? false, "css");
+  const sources = globalCssSources(config);
+  if (sources.length === 0) {
+    log.log("global css: no side-effect css imports in root layout, skipping");
+    return;
+  }
+  const outDir = options.dev ? path2.join(outCachePath(config.outPath), "assets") : path2.join(config.outPath, "static", "assets");
+  const outfile = path2.join(outDir, "global.css");
+  await ensureDir(outDir);
+  log.log(`global css: ${sources.length} source${sources.length === 1 ? "" : "s"} \u2014 ${sources.map((file) => path2.relative(config.root, file)).join(", ")}`);
+  const postcss = hasPostcssConfig(config.root);
+  await log.step("global css: esbuild bundle", () => build({
+    stdin: {
+      contents: stdinImports(config.root, sources),
+      loader: "css",
+      resolveDir: config.root,
+      sourcefile: "global.css"
+    },
+    outfile,
+    bundle: true,
+    minify: !options.dev,
+    conditions: ["style", "browser"],
+    assetNames: "files/[name]-[hash]",
+    plugins: [
+      cssPublicUrlPlugin(),
+      ...getCssExtensions().cssChunkPlugins(),
+      ...cssDirectiveOrderPlugins(postcss)
+    ],
+    loader: {
+      ".css": "css",
+      ".module.css": "css",
+      ...cssLoaderEntries(),
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".otf": "file",
+      ".eot": "file",
+      ".png": "file",
+      ".svg": "file",
+      ".ico": "file"
+    }
+  }));
+  if (postcss) {
+    await rewriteTailwindConfigDirectives(outfile, sources);
+    await log.step("global css: postcss", () => runPostcssOffThread(config, outfile, options, sources[0]));
+  }
+  const emitted = await fingerprintAsset(config, outDir, "global.css", options);
+  log.log(`global css \u2192 ${path2.relative(config.root, emitted)}`);
+  return emitted;
+}
+async function fingerprintAsset(config, outDir, assetName, options, file = assetName) {
+  const outfile = path2.join(outDir, file);
+  if (options.dev)
+    return outfile;
+  const emittedName = hashedAssetName(assetName, await readFile(outfile));
+  const emitted = path2.join(outDir, emittedName);
+  if (emitted !== outfile)
+    await rename(outfile, emitted);
+  recordEmittedAsset(config.outPath, assetName, emittedName);
+  return emitted;
+}
+function stdinImports(root, files) {
+  return files.map((file) => {
+    const relative = path2.relative(root, file).split(path2.sep).join("/");
+    const specifier = path2.isAbsolute(relative) || relative.startsWith("../") ? relative : `./${relative}`;
+    return `@import ${JSON.stringify(specifier)};`;
+  }).join(`
+`);
+}
+function moduleSpecifiers(source) {
+  const specifiers = [];
+  const pattern = /(?:import|export)\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    if (match[1])
+      specifiers.push(match[1]);
+  }
+  return specifiers;
+}
+function cssFileExtensions() {
+  return [".css", ...getCssExtensions().extraCssExtensions()];
+}
+function isCssFile(file) {
+  return cssFileExtensions().some((extension) => file.endsWith(extension));
+}
+function cssLoaderEntries() {
+  return Object.fromEntries(getCssExtensions().extraCssExtensions().map((extension) => [extension, "css"]));
+}
+var routeCssPlan = new Map;
+function prepareRouteCssChunks(routes) {
+  routeCssPlan.clear();
+  const plan = getCssExtensions().planRouteCssChunks(routes.map((route) => ({ id: route.id, cssImports: route.cssImports })));
+  for (const [id, segments] of plan)
+    routeCssPlan.set(id, segments);
+}
+function routeCssChunks(route) {
+  if (route.cssImports.length === 0)
+    return;
+  const segments = routeCssPlan.get(route.id);
+  if (segments && segments.length > 1) {
+    const cssAssets = segments.map((_, index) => `${route.id}-${index}.css`);
+    const chunks2 = segments.map((imports, index) => ({
+      imports,
+      name: cssAssets[index],
+      label: `route css ${route.route} #${index + 1}`
+    }));
+    return { cssAssets, chunks: chunks2 };
+  }
+  const chunks = [
+    { imports: route.cssImports, name: `${route.id}.css`, label: `route css ${route.route}` }
+  ];
+  return { cssAssets: undefined, chunks };
+}
+function clientReferenceCssChunks(reference) {
+  if (!reference.cssImports || reference.cssImports.length === 0)
+    return [];
+  return [
+    {
+      imports: reference.cssImports,
+      name: `${reference.id}.css`,
+      label: `island css ${reference.id}`
+    }
+  ];
+}
+async function buildRouteCss(config, route, options = {}) {
+  const css = routeCssChunks(route);
+  if (!css)
+    return;
+  route.cssAssets = css.cssAssets;
+  const files = [];
+  for (const chunk of css.chunks) {
+    files.push(await bundleCssChunk(config, chunk.imports, chunk.name, chunk.label, options));
+  }
+  return css.cssAssets ? files : files[0];
+}
+var DOCUMENT_CSS = new Set([
+  "global.css",
+  "not-found.css",
+  "global-not-found.css",
+  "global-error.css"
+]);
+function buildRouteStylesheets(config, routes, documentCss, options = {}) {
+  const builds = new Map;
+  const taken = new Set;
+  const publish = new Map;
+  for (const route of routes) {
+    const css = routeCssChunks(route);
+    const chunks = [
+      ...css?.chunks ?? [],
+      ...route.clientReferences.flatMap(clientReferenceCssChunks)
+    ];
+    const own = chunks.map((chunk) => {
+      const key = `${chunk.name}\x00${chunk.imports.join("\x00")}`;
+      let build2 = builds.get(key);
+      if (!build2) {
+        const file = taken.has(chunk.name) ? `.${builds.size}-${chunk.name}` : chunk.name;
+        taken.add(chunk.name);
+        const write = () => writeCssChunk(config, chunk.imports, file, chunk.label, options);
+        const outDir = DOCUMENT_CSS.has(file) ? documentCss.then(write) : write();
+        outDir.catch(() => {
+          return;
+        });
+        build2 = { file, outDir };
+        builds.set(key, build2);
+      }
+      return { name: chunk.name, build: build2 };
+    });
+    publish.set(route, async () => {
+      if (css)
+        route.cssAssets = css.cssAssets;
+      for (const { name, build: build2 } of own) {
+        if (build2.emitted)
+          recordEmittedAsset(config.outPath, name, build2.emitted);
+        else {
+          const emitted = await fingerprintAsset(config, await build2.outDir, name, options, build2.file);
+          build2.emitted = path2.basename(emitted);
+        }
+      }
+    });
+  }
+  return publish;
+}
+async function buildNotFoundCss(config, options = {}) {
+  const { collectFileCss } = await import("./routes-0x8wjvcj.js");
+  const targets = [
+    {
+      id: "not-found",
+      files: conventionCandidates(config.appPath, "not-found")
+    },
+    {
+      id: "global-not-found",
+      files: conventionCandidates(config.appPath, "global-not-found"),
+      includeGlobalCss: true
+    },
+    {
+      id: "global-error",
+      files: conventionCandidates(config.appPath, "global-error")
+    }
+  ];
+  for (const target of targets) {
+    const cssImports = await collectFileCss(config.appPath, target.files, {
+      includeGlobalCss: target.includeGlobalCss ?? false
+    });
+    if (cssImports.length === 0)
+      continue;
+    await bundleCssChunk(config, cssImports, `${target.id}.css`, `route css /${target.id}`, options);
+  }
+}
+function conventionCandidates(appPath, base) {
+  return ["tsx", "ts", "jsx", "js"].map((ext) => path2.join(appPath, `${base}.${ext}`));
+}
+async function buildClientReferenceCss(config, reference, options = {}) {
+  const [chunk] = clientReferenceCssChunks(reference);
+  if (!chunk)
+    return;
+  return bundleCssChunk(config, chunk.imports, chunk.name, chunk.label, options);
+}
+async function bundleCssChunk(config, cssImports, assetName, label, options) {
+  const outDir = await writeCssChunk(config, cssImports, assetName, label, options);
+  return fingerprintAsset(config, outDir, assetName, options);
+}
+async function writeCssChunk(config, cssImports, assetName, label, options) {
+  const log = createVerboseLogger(options.verbose ?? false, "css");
+  const outDir = options.dev ? path2.join(outCachePath(config.outPath), "assets") : path2.join(config.outPath, "static", "assets");
+  const outfile = path2.join(outDir, assetName);
+  await ensureDir(outDir);
+  log.log(`${label}: ${cssImports.length} import${cssImports.length === 1 ? "" : "s"}`);
+  const postcss = hasPostcssConfig(config.root);
+  await build({
+    stdin: {
+      contents: stdinImports(config.root, cssImports),
+      loader: "css",
+      resolveDir: config.root,
+      sourcefile: assetName
+    },
+    outfile,
+    bundle: true,
+    minifyWhitespace: !options.dev,
+    minifySyntax: !options.dev,
+    minifyIdentifiers: false,
+    conditions: ["style", "browser"],
+    assetNames: "files/[name]-[hash]",
+    plugins: [
+      cssPublicUrlPlugin(),
+      ...getCssExtensions().cssChunkPlugins(),
+      cssModuleBuildPlugin(),
+      ...cssDirectiveOrderPlugins(postcss)
+    ],
+    loader: {
+      ".css": "css",
+      ".module.css": "css",
+      ...cssLoaderEntries(),
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".otf": "file",
+      ".eot": "file",
+      ".png": "file",
+      ".svg": "file",
+      ".ico": "file"
+    }
+  });
+  if (postcss) {
+    await rewriteTailwindConfigDirectives(outfile, cssImports);
+    await log.step(`${label}: postcss`, () => runPostcssOffThread(config, outfile, options));
+  }
+  return outDir;
+}
+function cssPublicUrlPlugin() {
+  return {
+    name: "pnext-css-public-url",
+    setup(plugin) {
+      plugin.onResolve({ filter: /^\// }, (args) => args.kind === "url-token" ? { path: args.path, external: true } : undefined);
+    }
+  };
+}
+function cssModuleClientPlugin() {
+  return {
+    name: "pnext-css-modules",
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.(?:css|scss|sass)$/ }, async ({ path: file }) => ({
+        contents: isCssModuleFile(file) ? `export default ${JSON.stringify(await cssModuleMapping(file))};` : "export default undefined;",
+        loader: "js"
+      }));
+    }
+  };
+}
+function cssDirectiveOrderPlugins(postcss) {
+  return postcss ? [cssDirectiveOrderPlugin()] : [];
+}
+function cssDirectiveOrderPlugin() {
+  return {
+    name: "pnext-css-directive-order",
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.css$/ }, async ({ path: file }) => ({
+        contents: hoistCssImports(await readText(file)),
+        loader: "css",
+        resolveDir: path2.dirname(file)
+      }));
+    }
+  };
+}
+var CSS_CONFIG_AT_RULES = new Set(["source", "plugin", "config"]);
+function hoistCssImports(source) {
+  if (!/@(?:source|plugin|config)\b/.test(source))
+    return source;
+  const imports = [];
+  const others = [];
+  let charset = "";
+  let sawDirective = false;
+  let hoist = false;
+  let index = 0;
+  while (index < source.length) {
+    const code = source.charCodeAt(index);
+    if (code === 32 || code === 9 || code === 10 || code === 13 || code === 12) {
+      index += 1;
+      continue;
+    }
+    const char = source[index];
+    if (char === "/" && source[index + 1] === "*") {
+      const end2 = source.indexOf("*/", index + 2);
+      if (end2 === -1)
+        break;
+      others.push(source.slice(index, end2 + 2));
+      index = end2 + 2;
+      continue;
+    }
+    const name = char === "@" ? /^@([\w-]+)/.exec(source.slice(index))?.[1] : undefined;
+    if (!name)
+      break;
+    if (name !== "import" && name !== "charset" && !CSS_CONFIG_AT_RULES.has(name))
+      break;
+    const end = statementEnd(source, index);
+    if (end === -1)
+      break;
+    const statement = source.slice(index, end);
+    if (name === "charset")
+      charset ||= statement;
+    else if (name === "import") {
+      imports.push(statement);
+      if (sawDirective)
+        hoist = true;
+    } else {
+      others.push(statement);
+      sawDirective = true;
+    }
+    index = end;
+  }
+  if (!hoist)
+    return source;
+  return `${[charset, ...imports, ...others].filter(Boolean).join(`
+`)}
+${source.slice(index)}`;
+}
+function statementEnd(source, start) {
+  for (let index = start;index < source.length; index += 1) {
+    const char = source[index];
+    if (char === ";")
+      return index + 1;
+    if (char === "{" || char === "}")
+      return -1;
+    if (char === '"' || char === "'") {
+      index = skipString(source, index);
+      if (index === -1)
+        return -1;
+    }
+  }
+  return -1;
+}
+function skipString(source, start) {
+  const quote = source[start];
+  for (let index = start + 1;index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "\\")
+      index += 1;
+    else if (char === quote)
+      return index;
+  }
+  return -1;
+}
+function cssModuleBuildPlugin() {
+  return {
+    name: "pnext-css-module-build",
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.module\.css$/ }, async ({ path: file }) => ({
+        contents: transformCssModule(await readText(file), file),
+        loader: "css"
+      }));
+    }
+  };
+}
+function transformCssModule(source, file) {
+  let css = source;
+  for (const className of cssClassNames(source)) {
+    css = rewriteClassSelector(css, cssModuleClassName(file, className), className);
+  }
+  css = scopeKeyframes(css, file);
+  return css;
+}
+function scopeKeyframes(css, file) {
+  const names = keyframeNames(css);
+  if (names.size === 0)
+    return css;
+  let out = css;
+  for (const name of names) {
+    const scoped = cssModuleClassName(file, name);
+    out = out.replace(new RegExp(`(@(?:-webkit-)?keyframes\\s+)${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+    out = out.replace(new RegExp(`(animation-name\\s*:\\s*)${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+    out = out.replace(new RegExp(`(animation\\s*:[^;{}]*?(?<![-_a-zA-Z0-9]))${escapeRegex(name)}(?![-_a-zA-Z0-9])`, "g"), `$1${scoped}`);
+  }
+  return out;
+}
+function keyframeNames(css) {
+  const names = new Set;
+  const pattern = /@(?:-webkit-)?keyframes\s+(-?[_a-zA-Z][\w-]*)/g;
+  let match;
+  while (match = pattern.exec(css)) {
+    if (match[1])
+      names.add(match[1]);
+  }
+  return names;
+}
+function rewriteClassSelector(css, scopedClassName, originalClassName) {
+  const esbuildNamePattern = new RegExp(`\\.${escapeRegex(originalClassName)}(?![-_a-zA-Z0-9])`, "g");
+  return css.replace(esbuildNamePattern, `.${scopedClassName}`);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasPostcssConfig(root) {
+  return postcssConfigFile(root) !== undefined;
+}
+async function rewriteTailwindConfigDirectives(cssFile, sources) {
+  const candidateDirs = [path2.dirname(cssFile), ...sources.map((file) => path2.dirname(file))];
+  let css = await readText(cssFile);
+  let changed = false;
+  css = css.replace(/@config\s+(['"])([^'"]+)\1\s*;/g, (match, quote, specifier) => {
+    if (!isRelativeSpecifier(specifier))
+      return match;
+    const resolved = candidateDirs.map((dir) => path2.resolve(dir, specifier)).find((file) => existsSync2(file));
+    if (!resolved)
+      return match;
+    changed = true;
+    return `@config ${quote}${resolved.split(path2.sep).join("/")}${quote};`;
+  });
+  if (changed)
+    await writeFile2(cssFile, css);
+}
+function isRelativeSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+
+export { stopCssWorker, runPostcssOffThread, warmCssWorker, globalCssSource, globalCssSources, setGlobalCssSourceStore, globalCssSourcesForPaths, clearGlobalCssSourceCache, warmCssPipeline, buildGlobalCss, isCssFile, prepareRouteCssChunks, buildRouteCss, buildRouteStylesheets, buildNotFoundCss, buildClientReferenceCss, cssModuleClientPlugin, hoistCssImports, rewriteTailwindConfigDirectives };