@wular/coder 0.4.6 → 0.4.8

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

@@ -1,1071 +0,0 @@
-// @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-d158y67j.js";
-import {
-  readSourceSync
-} from "./index-fp8r0sqs.js";
-import {
-  build
-} from "./index-cjgqs13g.js";
-import {
-  ensureDir,
-  readText
-} from "./index-4da76t62.js";
-import {
-  outCachePath
-} from "./index-bzd2ef7t.js";
-import {
-  productionRelease
-} from "./index-hdbwtdv2.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-ht868pdc.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 };