vite-plugin-spiral 0.1.0

package/dist/index.js

@@ -0,0 +1,1111 @@
+import {
+  familyToSlug
+} from "./chunk-VHEBKNM2.js";
+
+// src/index.ts
+import { createHash as createHash2 } from "crypto";
+import fsSync2 from "fs";
+import { promises as fs2 } from "fs";
+import os from "os";
+import path2 from "path";
+import colors from "picocolors";
+import { glob as glob2 } from "tinyglobby";
+import { loadEnv } from "vite";
+import fullReload from "vite-plugin-full-reload";
+
+// src/fonts/plugin.ts
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import fsSync from "fs";
+import { promises as fs } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { glob } from "tinyglobby";
+
+// src/fonts/types.ts
+var FORMAT_MIME = {
+  woff2: "font/woff2",
+  woff: "font/woff",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject"
+};
+
+// src/fonts/plugin.ts
+var remoteCssUrls = {
+  google: "https://fonts.googleapis.com/css2",
+  bunny: "https://fonts.bunny.net/css2"
+};
+var fontExtensions = {
+  ".woff2": "woff2",
+  ".woff": "woff",
+  ".ttf": "ttf",
+  ".otf": "otf",
+  ".eot": "eot"
+};
+var formatPreference = ["woff2", "woff", "ttf", "otf", "eot"];
+var supportedGlob = "*.{woff2,woff,ttf,otf,eot}";
+function resolveFontsPlugin(fonts, hotFile, buildDirectory) {
+  if (fonts.length === 0) {
+    return [];
+  }
+  validateFonts(fonts);
+  let config;
+  let cacheDir;
+  let hotManifestPath;
+  let families = [];
+  let refs = /* @__PURE__ */ new Map();
+  return [{
+    name: "vite-plugin-spiral:fonts",
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      cacheDir = path.resolve(config.root, "node_modules/.cache/vite-plugin-spiral/fonts");
+      hotManifestPath = path.resolve(config.root, path.dirname(hotFile), "fonts-manifest.dev.json");
+    },
+    async buildStart() {
+      if (config.command !== "build") {
+        return;
+      }
+      families = await resolveFontFamilies(fonts, config.root, cacheDir);
+      refs = emitFontAssets(families, (asset) => this.emitFile(asset));
+    },
+    generateBundle() {
+      if (config.command !== "build" || families.length === 0) {
+        return;
+      }
+      const fileMap = /* @__PURE__ */ new Map();
+      for (const [source, ref] of refs) {
+        fileMap.set(source, this.getFileName(ref));
+      }
+      const publicBase = normalizePublicBase(config.base, buildDirectory);
+      const css = generateFontCss(families, fileMap, (file) => `${publicBase}${file}`);
+      const cssRef = this.emitFile({
+        type: "asset",
+        name: "fonts.css",
+        source: css
+      });
+      const cssFile = this.getFileName(cssRef);
+      const manifest = buildFontManifest(families, fileMap, cssFile, (file) => file);
+      this.emitFile({
+        type: "asset",
+        fileName: "fonts-manifest.json",
+        source: `${JSON.stringify(manifest, null, 2)}
+`
+      });
+    },
+    configureServer(server) {
+      const middleware = createFontMiddleware();
+      server.middlewares.use(middleware);
+      server.httpServer?.once("listening", async () => {
+        try {
+          families = await resolveFontFamilies(fonts, config.root, cacheDir);
+          const devUrl = fsSync.existsSync(path.resolve(config.root, hotFile)) ? fsSync.readFileSync(path.resolve(config.root, hotFile), "utf8").trim() : `http://localhost:${server.config.server.port ?? 5173}`;
+          const urlMap = /* @__PURE__ */ new Map();
+          for (const family of families) {
+            for (const variant of family.variants) {
+              for (const file of variant.files) {
+                const urlPath = `/@spiral-vite-fonts/${encodeURIComponent(createHash("sha1").update(file.source).digest("hex"))}.${file.format}`;
+                middleware.files.set(urlPath, file);
+                urlMap.set(file.source, `${devUrl}${urlPath}`);
+              }
+            }
+          }
+          const css = generateFontCss(families, urlMap, (file) => file);
+          const manifest = buildFontManifest(families, urlMap, void 0, (file) => file, css);
+          fsSync.mkdirSync(path.dirname(hotManifestPath), { recursive: true });
+          fsSync.writeFileSync(hotManifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+        } catch (error) {
+          server.config.logger.error(`[vite-plugin-spiral:fonts] ${error.message}`);
+        }
+      });
+      const cleanup = () => {
+        fsSync.rmSync(hotManifestPath, { force: true });
+      };
+      process.on("exit", cleanup);
+      server.httpServer?.once("close", () => {
+        cleanup();
+        process.removeListener("exit", cleanup);
+      });
+    }
+  }];
+}
+async function resolveFontFamilies(fonts, root, cacheDir) {
+  const families = [];
+  for (const font of fonts) {
+    let family;
+    if (font.provider === "local") {
+      family = await resolveLocalFont(font, root);
+    } else if (font.provider === "fontsource") {
+      family = resolveFontsourceFont(font, root);
+    } else {
+      family = await resolveRemoteFont(font, cacheDir, remoteCssUrls[font.provider]);
+    }
+    families.push(await withOptimizedFallbacks(family));
+  }
+  return families;
+}
+async function resolveLocalFont(font, root) {
+  if (!font._local) {
+    throw new Error(`vite-plugin-spiral: Local font "${font.family}" requires src or variants.`);
+  }
+  if ("variants" in font._local) {
+    return buildResolvedFamily(font, font._local.variants.map((variant) => {
+      const src = Array.isArray(variant.src) ? variant.src : [variant.src];
+      const files2 = src.map((file) => resolveFontFile(path.resolve(root, file)));
+      return {
+        weight: variant.weight ?? inferWeight(src[0]),
+        style: variant.style ?? inferStyle(src[0]),
+        files: sortFiles(files2)
+      };
+    }));
+  }
+  const files = await discoverLocalFiles(font.family, font._local.src, root);
+  if (files.some(isVariableFontFilename)) {
+    throw new Error(`vite-plugin-spiral: Local variable font "${font.family}" must use explicit variants instead of src shorthand.`);
+  }
+  return buildResolvedFamily(font, groupByVariant(files));
+}
+function resolveFontsourceFont(font, root) {
+  const packageName = font._fontsource?.package ?? `@fontsource/${familyToSlug(font.family)}`;
+  const require2 = createRequire(path.resolve(root, "package.json"));
+  let packageDirectory;
+  try {
+    packageDirectory = path.dirname(require2.resolve(`${packageName}/package.json`));
+  } catch {
+    throw new Error(`vite-plugin-spiral: Fontsource package "${packageName}" was not found. Install it with npm install ${packageName}.`);
+  }
+  const variants = [];
+  for (const weight of font.weights) {
+    for (const style of font.styles) {
+      for (const subset of font.subsets) {
+        const fileName = style === "italic" ? `${subset}-${weight}-italic.css` : `${subset}-${weight}.css`;
+        const cssPath = path.resolve(packageDirectory, fileName);
+        if (!fsSync.existsSync(cssPath)) {
+          throw new Error(`vite-plugin-spiral: Fontsource CSS file "${fileName}" was not found in "${packageName}".`);
+        }
+        const faces = parseFontFaceCss(fsSync.readFileSync(cssPath, "utf8"));
+        for (const face of faces) {
+          variants.push({
+            weight: face.weight,
+            style: face.style,
+            files: sortFiles(face.src.map((src) => ({
+              source: path.resolve(path.dirname(cssPath), src.url),
+              format: src.format,
+              unicodeRange: face.unicodeRange
+            })))
+          });
+        }
+      }
+    }
+  }
+  if (variants.length === 0) {
+    throw new Error(`vite-plugin-spiral: Fontsource package "${packageName}" resolved no variants for "${font.family}".`);
+  }
+  return buildResolvedFamily(font, variants);
+}
+async function resolveRemoteFont(font, cacheDir, cssBaseUrl) {
+  if (!cssBaseUrl) {
+    throw new Error(`vite-plugin-spiral: Unsupported remote font provider "${font.provider}".`);
+  }
+  await fs.mkdir(cacheDir, { recursive: true });
+  const css = await fetchTextAndCache(buildCss2Url(cssBaseUrl, font), cacheDir, {
+    "User-Agent": "Mozilla/5.0 AppleWebKit/537.36 Chrome/131 Safari/537.36"
+  });
+  const faces = parseFontFaceCss(css);
+  if (faces.length === 0) {
+    throw new Error(`vite-plugin-spiral: ${font.provider} returned no @font-face rules for "${font.family}".`);
+  }
+  const variants = [];
+  for (const face of faces) {
+    const files = [];
+    for (const src of face.src) {
+      files.push({
+        source: await fetchFileAndCache(src.url, cacheDir),
+        format: src.format,
+        unicodeRange: face.unicodeRange
+      });
+    }
+    variants.push({ weight: face.weight, style: face.style, files: sortFiles(files) });
+  }
+  return buildResolvedFamily(font, variants);
+}
+function buildCss2Url(baseUrl, font) {
+  const family = font.family.replace(/ /g, "+");
+  const hasItalic = font.styles.includes("italic");
+  const axes = hasItalic ? ["ital", "wght"] : ["wght"];
+  const tuples = /* @__PURE__ */ new Set();
+  for (const weight of font.weights) {
+    for (const style of font.styles) {
+      tuples.add(hasItalic ? `${style === "italic" ? "1" : "0"},${weight}` : `${weight}`);
+    }
+  }
+  return `${baseUrl}?family=${family}:${axes.join(",")}@${[...tuples].sort().join(";")}&display=${font.display}&subset=${font.subsets.join(",")}`;
+}
+async function discoverLocalFiles(family, src, root) {
+  const absolute = path.isAbsolute(src) ? src : path.resolve(root, src);
+  if (/[*?{]/.test(src)) {
+    const files = await glob(src, { cwd: root, absolute: true });
+    const supported = files.filter(isSupportedFontFile);
+    if (supported.length === 0) {
+      throw new Error(`vite-plugin-spiral: Local font "${family}" glob "${src}" matched no supported font files.`);
+    }
+    return supported.sort();
+  }
+  if (fsSync.existsSync(absolute) && fsSync.statSync(absolute).isDirectory()) {
+    const files = await glob(`**/${supportedGlob}`, { cwd: absolute, absolute: true });
+    if (files.length === 0) {
+      throw new Error(`vite-plugin-spiral: Local font "${family}" directory "${src}" contains no supported font files.`);
+    }
+    return files.sort();
+  }
+  if (fsSync.existsSync(absolute) && fsSync.statSync(absolute).isFile()) {
+    return [absolute];
+  }
+  throw new Error(`vite-plugin-spiral: Local font "${family}" source "${src}" does not exist.`);
+}
+function groupByVariant(files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const weight = inferWeight(file);
+    const style = inferStyle(file);
+    const key = `${weight}:${style}`;
+    const group = groups.get(key) ?? { weight, style, files: [] };
+    group.files.push(resolveFontFile(file));
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((variant) => ({ ...variant, files: sortFiles(variant.files) })).sort((a, b) => Number(a.weight) - Number(b.weight) || a.style.localeCompare(b.style));
+}
+function parseFontFaceCss(css) {
+  return [...css.matchAll(/@font-face\s*{([^}]+)}/g)].map((match) => {
+    const body = match[1];
+    const src = [...body.matchAll(/url\((?:'|")?([^'")]+)(?:'|")?\)\s*format\((?:'|")?([^'")]+)(?:'|")?\)/g)].map((srcMatch) => ({
+      url: srcMatch[1],
+      format: normalizeFormat(srcMatch[2])
+    }));
+    return {
+      family: property(body, "font-family")?.replace(/^['"]|['"]$/g, "") ?? "",
+      style: property(body, "font-style") ?? "normal",
+      weight: property(body, "font-weight") ?? 400,
+      src,
+      unicodeRange: property(body, "unicode-range"),
+      display: property(body, "font-display")
+    };
+  }).filter((face) => face.src.length > 0);
+}
+function generateFontCss(families, fileMap, urlResolver) {
+  const rules = [];
+  for (const family of families) {
+    for (const variant of family.variants) {
+      const src = variant.files.map((file) => `url("${urlResolver(fileMap.get(file.source) ?? file.source)}") format("${file.format}")`).join(", ");
+      const unicodeRange = variant.files.find((file) => file.unicodeRange)?.unicodeRange;
+      rules.push([
+        "@font-face {",
+        `  font-family: "${family.family}";`,
+        `  font-style: ${variant.style};`,
+        `  font-weight: ${variant.weight};`,
+        `  font-display: ${family.display};`,
+        `  src: ${src};`,
+        unicodeRange ? `  unicode-range: ${unicodeRange};` : void 0,
+        "}"
+      ].filter(Boolean).join("\n"));
+    }
+    if (family.fallbackCss) {
+      rules.push(family.fallbackCss.trim());
+    }
+  }
+  return `${rules.join("\n\n")}
+`;
+}
+function buildFontManifest(families, fileMap, cssFile, urlResolver, inlineCss) {
+  const manifest = {
+    version: 1,
+    style: {
+      file: cssFile,
+      inline: inlineCss,
+      familyStyles: {},
+      variables: {}
+    },
+    preloads: [],
+    families: {}
+  };
+  for (const family of families) {
+    const familyStack = [`"${family.family}"`];
+    if (family.fallbackFamily) {
+      familyStack.push(`"${family.fallbackFamily}"`);
+    }
+    manifest.style.familyStyles[family.alias] = `font-family: var(${family.variable});`;
+    manifest.style.variables[family.variable] = [...familyStack, ...family.fallbacks].join(", ");
+    if (family.fallbackCss) {
+      manifest.style.fallbackCss = [manifest.style.fallbackCss, family.fallbackCss].filter(Boolean).join("\n");
+    }
+    manifest.families[family.alias] = {
+      family: family.family,
+      variable: family.variable,
+      fallbackFamily: family.fallbackFamily,
+      fallbacks: family.fallbacks,
+      variants: {}
+    };
+    for (const variant of family.variants) {
+      const key = `${variant.weight}:${variant.style}`;
+      manifest.families[family.alias].variants[key] = {
+        files: variant.files.map((file) => {
+          const resolved = fileMap.get(file.source);
+          return {
+            file: resolved && !resolved.startsWith("http") ? resolved : void 0,
+            url: resolved?.startsWith("http") ? resolved : void 0,
+            format: file.format,
+            unicodeRange: file.unicodeRange
+          };
+        })
+      };
+      for (const file of variant.files) {
+        if (!shouldPreload(family, variant, file)) {
+          continue;
+        }
+        const resolved = fileMap.get(file.source);
+        manifest.preloads.push({
+          alias: family.alias,
+          family: family.family,
+          weight: variant.weight,
+          style: variant.style,
+          file: resolved && !resolved.startsWith("http") ? resolved : void 0,
+          url: resolved?.startsWith("http") ? urlResolver(resolved) : void 0,
+          as: "font",
+          type: FORMAT_MIME[file.format],
+          crossorigin: "anonymous"
+        });
+      }
+    }
+  }
+  return manifest;
+}
+function emitFontAssets(families, emitFile) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const family of families) {
+    for (const variant of family.variants) {
+      for (const file of variant.files) {
+        if (refs.has(file.source)) {
+          continue;
+        }
+        const name = `${familyToSlug(family.family)}-${variant.weight}-${variant.style}.${file.format}`;
+        refs.set(file.source, emitFile({ type: "asset", name, source: fsSync.readFileSync(file.source) }));
+      }
+    }
+  }
+  return refs;
+}
+function createFontMiddleware() {
+  const files = /* @__PURE__ */ new Map();
+  const middleware = ((req, res, next) => {
+    const pathname = req.url?.split("?")[0] ?? "";
+    const file = files.get(pathname);
+    if (!file) {
+      next();
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", FORMAT_MIME[file.format]);
+    res.end(fsSync.readFileSync(file.source));
+  });
+  middleware.files = files;
+  return middleware;
+}
+function validateFonts(fonts) {
+  for (const font of fonts) {
+    if (font.family.trim() === "") {
+      throw new Error("vite-plugin-spiral: Font family must be a non-empty string.");
+    }
+    if (font.alias.trim() === "") {
+      throw new Error(`vite-plugin-spiral: Font "${font.family}" alias must be a non-empty string.`);
+    }
+  }
+}
+async function withOptimizedFallbacks(family) {
+  if (!family.optimizedFallbacks) {
+    return family;
+  }
+  const fontaine = await loadFontaine();
+  const fallbackFamily = fontaine.generateFallbackName(family.family);
+  const fallbackCss = [];
+  for (const variant of family.variants) {
+    const metrics = await readVariantMetrics(fontaine, variant);
+    if (!metrics) {
+      throw new Error(`vite-plugin-spiral: Could not read font metrics for "${family.family}" ${variant.weight} ${variant.style}.`);
+    }
+    const fallbackFonts = family.fallbacks.length > 0 ? family.fallbacks : fontaine.resolveCategoryFallbacks({
+      fontFamily: family.family,
+      fallbacks: {},
+      metrics
+    });
+    let generated = false;
+    for (const fallbackFont of [...fallbackFonts].reverse()) {
+      const fallbackMetrics = await fontaine.getMetricsForFamily(unquoteFontFamily(fallbackFont));
+      if (!fallbackMetrics) {
+        continue;
+      }
+      fallbackCss.push(fontaine.generateFontFace(metrics, {
+        name: fallbackFamily,
+        font: unquoteFontFamily(fallbackFont),
+        metrics: fallbackMetrics,
+        "font-weight": String(variant.weight),
+        "font-style": variant.style
+      }).trim());
+      generated = true;
+    }
+    if (!generated && fallbackFonts.length > 0) {
+      fallbackCss.push(fontaine.generateFontFace(metrics, {
+        name: fallbackFamily,
+        font: unquoteFontFamily(fallbackFonts[0]),
+        "font-weight": String(variant.weight),
+        "font-style": variant.style
+      }).trim());
+    }
+  }
+  return {
+    ...family,
+    fallbackFamily,
+    fallbackCss: `${fallbackCss.join("\n\n")}
+`
+  };
+}
+async function loadFontaine() {
+  try {
+    return await import("fontaine");
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+      throw new Error('vite-plugin-spiral: optimizedFallbacks requires the optional peer dependency "fontaine". Install it with npm install -D fontaine, or set optimizedFallbacks: false.');
+    }
+    throw error;
+  }
+}
+async function readVariantMetrics(fontaine, variant) {
+  for (const file of variant.files) {
+    if (!["woff2", "woff", "ttf"].includes(file.format)) {
+      continue;
+    }
+    try {
+      const metrics = await fontaine.readMetrics(pathToFileURL(file.source));
+      if (metrics) {
+        return metrics;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function buildResolvedFamily(font, variants) {
+  return {
+    family: font.family,
+    alias: font.alias,
+    variable: font.variable,
+    display: font.display,
+    optimizedFallbacks: font.optimizedFallbacks,
+    fallbacks: font.fallbacks,
+    preload: font.preload,
+    provider: font.provider,
+    variants
+  };
+}
+function shouldPreload(family, variant, file) {
+  if (file.format !== "woff2") {
+    return false;
+  }
+  if (family.preload === true) {
+    return true;
+  }
+  if (family.preload === false) {
+    return false;
+  }
+  return family.preload.some((selector) => selector.weight === variant.weight && (selector.style ?? "normal") === variant.style);
+}
+function resolveFontFile(file) {
+  return {
+    source: file,
+    format: inferFormat(file)
+  };
+}
+function isVariableFontFilename(file) {
+  const stem = path.basename(file, path.extname(file)).toLowerCase();
+  return stem.includes("variable") || stem.includes("-vf") || stem.includes("_vf") || /\[[^\]]+\]/.test(stem);
+}
+function unquoteFontFamily(family) {
+  return family.trim().replace(/^['"]|['"]$/g, "");
+}
+function inferFormat(file) {
+  const format = fontExtensions[path.extname(file).toLowerCase()];
+  if (!format) {
+    throw new Error(`vite-plugin-spiral: Unsupported font file "${file}".`);
+  }
+  return format;
+}
+function isSupportedFontFile(file) {
+  return path.extname(file).toLowerCase() in fontExtensions;
+}
+function sortFiles(files) {
+  return [...files].sort((a, b) => formatPreference.indexOf(a.format) - formatPreference.indexOf(b.format));
+}
+function inferWeight(file) {
+  const stem = path.basename(file, path.extname(file)).toLowerCase();
+  const named = [
+    ["thin", 100],
+    ["extralight", 200],
+    ["light", 300],
+    ["regular", 400],
+    ["normal", 400],
+    ["medium", 500],
+    ["semibold", 600],
+    ["bold", 700],
+    ["extrabold", 800],
+    ["black", 900]
+  ];
+  const match = named.find(([name]) => stem.includes(name));
+  const numeric = stem.match(/(?:^|[^\d])([1-9]00)(?:[^\d]|$)/);
+  return match?.[1] ?? (numeric ? Number.parseInt(numeric[1], 10) : 400);
+}
+function inferStyle(file) {
+  const stem = path.basename(file, path.extname(file)).toLowerCase();
+  if (stem.includes("italic") || stem.endsWith("it")) {
+    return "italic";
+  }
+  if (stem.includes("oblique")) {
+    return "oblique";
+  }
+  return "normal";
+}
+function normalizeFormat(format) {
+  const normalized = format.toLowerCase().replace(/^font\//, "");
+  if (normalized in FORMAT_MIME) {
+    return normalized;
+  }
+  throw new Error(`vite-plugin-spiral: Unsupported font format "${format}".`);
+}
+function property(body, propertyName) {
+  const match = body.match(new RegExp(`${propertyName}\\s*:\\s*([^;]+)`, "i"));
+  return match?.[1]?.trim();
+}
+async function fetchTextAndCache(url, cacheDir, headers) {
+  const file = cachePath(url, cacheDir, ".css");
+  if (fsSync.existsSync(file)) {
+    return fsSync.readFileSync(file, "utf8");
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`vite-plugin-spiral: Failed to fetch font CSS from "${url}" (${response.status}).`);
+  }
+  const text = await response.text();
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, text, "utf8");
+  return text;
+}
+async function fetchFileAndCache(url, cacheDir) {
+  const extension = path.extname(new URL(url).pathname) || ".woff2";
+  const file = cachePath(url, cacheDir, extension);
+  if (fsSync.existsSync(file)) {
+    return file;
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`vite-plugin-spiral: Failed to fetch font file from "${url}" (${response.status}).`);
+  }
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, Buffer.from(await response.arrayBuffer()));
+  return file;
+}
+function cachePath(url, cacheDir, extension) {
+  return path.resolve(cacheDir, `${createHash("sha1").update(url).digest("hex")}${extension}`);
+}
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+function normalizePublicBase(base, buildDirectory) {
+  const resolved = base === "" ? `/${trimSlashes(buildDirectory)}/` : base;
+  return resolved.endsWith("/") ? resolved : `${resolved}/`;
+}
+
+// src/index.ts
+var defaultRefreshPaths = [
+  "app/views/**/*.php",
+  "app/config/**/*.php",
+  "app/locale/**/*.php",
+  "app/src/Endpoint/**/*.php"
+];
+var imageExtensions = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".svg", ".ico"]);
+var fontExtensions2 = /* @__PURE__ */ new Set([".woff", ".woff2", ".ttf", ".otf", ".eot"]);
+var placeholderOrigin = "http://__spiral_vite_placeholder__.test";
+var exitHandlersBound = false;
+function spiral(config) {
+  const resolved = resolveOptions(config);
+  return [
+    resolveSpiralPlugin(resolved),
+    ...resolveAssetPlugins(resolved),
+    ...resolveFontsPlugin(resolved.fonts, resolved.hotFile, resolved.buildDirectory),
+    ...resolveRefreshPlugins(resolved.refresh)
+  ];
+}
+function resolveSpiralPlugin(resolved) {
+  let viteConfig;
+  let userConfig = {};
+  let devServerUrl;
+  return {
+    name: "vite-plugin-spiral",
+    config(config, env) {
+      userConfig = config;
+      const buildConfig = config.build;
+      const modeEnv = loadEnv(env.mode, config.envDir || process.cwd(), "");
+      const assetUrl = resolved.assetUrl ?? modeEnv.SPIRAL_VITE_ASSET_URL ?? modeEnv.ASSET_URL ?? "";
+      const appUrl = modeEnv.SPIRAL_APP_URL ?? modeEnv.APP_URL;
+      const isSsrBuild = env.isSsrBuild === true;
+      const output = resolved.output;
+      const bundlerInput = resolveBuildInput(buildConfig, isSsrBuild ? resolved.ssr : resolved.input);
+      const serverConfig = env.command === "serve" ? resolveDevelopmentEnvironmentServerConfig(resolved.detectTls) ?? resolveEnvironmentServerConfig(modeEnv) : void 0;
+      ensureCommandShouldRunInEnvironment(env.command, modeEnv);
+      return {
+        base: config.base ?? (env.command === "build" ? resolveBase(resolved.buildDirectory, assetUrl) : ""),
+        publicDir: config.publicDir ?? false,
+        build: {
+          manifest: config.build?.manifest ?? (isSsrBuild ? false : "manifest.json"),
+          ssrManifest: config.build?.ssrManifest ?? (isSsrBuild ? "ssr-manifest.json" : false),
+          outDir: config.build?.outDir ?? (isSsrBuild ? resolved.ssrOutputDirectory : posixJoin(resolved.publicDirectory, resolved.buildDirectory)),
+          assetsInlineLimit: config.build?.assetsInlineLimit ?? 0,
+          rolldownOptions: {
+            ...buildConfig?.rolldownOptions,
+            input: buildConfig?.rolldownOptions?.input ?? bundlerInput,
+            output: resolveBundlerOutput(buildConfig?.rolldownOptions?.output ?? buildConfig?.rollupOptions?.output, output)
+          }
+        },
+        server: {
+          ...config.server,
+          origin: resolved.server?.origin ?? config.server?.origin ?? placeholderOrigin,
+          cors: config.server?.cors ?? {
+            origin: resolved.server?.corsOrigin ?? resolveAllowedOrigins(modeEnv, appUrl)
+          },
+          ...modeEnv.SPIRAL_VITE_PORT || modeEnv.VITE_PORT ? { port: config.server?.port ?? Number.parseInt(modeEnv.SPIRAL_VITE_PORT ?? modeEnv.VITE_PORT, 10), strictPort: config.server?.strictPort ?? true } : {},
+          ...serverConfig ? {
+            host: config.server?.host ?? serverConfig.host,
+            hmr: config.server?.hmr === false ? false : {
+              ...serverConfig.hmr,
+              ...config.server?.hmr === true ? {} : config.server?.hmr
+            },
+            https: config.server?.https ?? serverConfig.https
+          } : {}
+        },
+        resolve: {
+          ...config.resolve,
+          alias: resolveAliases(config)
+        }
+      };
+    },
+    configResolved(config) {
+      viteConfig = config;
+    },
+    transform(code) {
+      if (viteConfig?.command !== "serve" || devServerUrl === void 0) {
+        return;
+      }
+      return resolved.transformOnServe(code.replaceAll(placeholderOrigin, devServerUrl), devServerUrl);
+    },
+    configureServer(server) {
+      const cleanHotFile = () => {
+        fsSync2.rmSync(resolveRootPath(server.config.root, resolved.hotFile), { force: true });
+      };
+      const writeHotFile = () => {
+        const address = server.httpServer?.address();
+        if (typeof address === "object" && address !== null) {
+          devServerUrl = resolved.server?.origin ? stripTrailingSlash(resolved.server.origin) : resolveDevServerUrl(address, server.config, userConfig);
+        } else {
+          devServerUrl = resolved.server?.origin ? stripTrailingSlash(resolved.server.origin) : stripTrailingSlash(server.resolvedUrls?.local[0] ?? "http://localhost:5173");
+        }
+        const hotFile = resolveRootPath(server.config.root, resolved.hotFile);
+        fsSync2.mkdirSync(path2.dirname(hotFile), { recursive: true });
+        fsSync2.writeFileSync(hotFile, `${devServerUrl}${server.config.base.replace(/\/$/, "")}`, "utf8");
+        logDevServer(server, resolved, devServerUrl);
+      };
+      if (server.httpServer) {
+        server.httpServer.once("listening", writeHotFile);
+        server.httpServer.once("close", cleanHotFile);
+      } else {
+        writeHotFile();
+      }
+      if (!exitHandlersBound) {
+        const clean = () => {
+          if (viteConfig) {
+            fsSync2.rmSync(resolveRootPath(viteConfig.root, resolved.hotFile), { force: true });
+          }
+        };
+        process.on("exit", clean);
+        process.on("SIGINT", () => process.exit());
+        process.on("SIGTERM", () => process.exit());
+        process.on("SIGHUP", () => process.exit());
+        exitHandlersBound = true;
+      }
+      return () => {
+        server.middlewares.use((req, res, next) => {
+          if (req.url !== "/index.html" && req.url !== "/") {
+            next();
+            return;
+          }
+          const env = loadEnv(server.config.mode, server.config.envDir || process.cwd(), "");
+          const appUrl = env.SPIRAL_APP_URL ?? env.APP_URL ?? "http://127.0.0.1:8080";
+          res.statusCode = 404;
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+          res.end(devServerIndexHtml(appUrl));
+        });
+      };
+    },
+    async closeBundle() {
+      if (viteConfig === void 0 || viteConfig.command !== "build") {
+        return;
+      }
+      await fs2.rm(resolveRootPath(viteConfig.root, resolved.hotFile), { force: true });
+      if (resolved.integrity !== false) {
+        await writeIntegrityManifest(viteConfig, resolved);
+      }
+    }
+  };
+}
+function resolveOptions(config) {
+  const options = typeof config === "string" || Array.isArray(config) ? { input: config } : Object.prototype.hasOwnProperty.call(config, "input") ? config : { input: config };
+  if (options.input === void 0 || Array.isArray(options.input) && options.input.length === 0) {
+    throw new Error("vite-plugin-spiral requires at least one input file.");
+  }
+  return {
+    input: options.input,
+    publicDirectory: trimSlashes2(options.publicDirectory ?? "public", "publicDirectory"),
+    buildDirectory: trimSlashes2(options.buildDirectory ?? "build", "buildDirectory"),
+    hotFile: normalizePath(options.hotFile ?? "runtime/vite.hot"),
+    refresh: resolveRefreshConfig(options.refresh),
+    ssr: options.ssr ?? options.input,
+    ssrOutputDirectory: trimSlashes2(options.ssrOutputDirectory ?? "runtime/vite-ssr", "ssrOutputDirectory"),
+    integrity: options.integrity === true ? "sha384" : options.integrity ?? false,
+    assetUrl: options.assetUrl,
+    detectTls: options.detectTls ?? options.valetTls ?? null,
+    assets: typeof options.assets === "string" ? [options.assets] : options.assets ?? [],
+    fonts: options.fonts ?? [],
+    transformOnServe: options.transformOnServe ?? ((code) => code),
+    server: options.server,
+    output: {
+      jsDirectory: trimSlashes2(options.output?.jsDirectory ?? "js", "output.jsDirectory"),
+      cssDirectory: trimSlashes2(options.output?.cssDirectory ?? "css", "output.cssDirectory"),
+      imageDirectory: trimSlashes2(options.output?.imageDirectory ?? "images", "output.imageDirectory"),
+      fontDirectory: trimSlashes2(options.output?.fontDirectory ?? "fonts", "output.fontDirectory"),
+      assetDirectory: trimSlashes2(options.output?.assetDirectory ?? "assets", "output.assetDirectory")
+    }
+  };
+}
+function resolveBuildInput(buildConfig, defaultInput) {
+  return buildConfig?.rolldownOptions?.input ?? buildConfig?.rollupOptions?.input ?? defaultInput;
+}
+function resolveBundlerOutput(userOutput, output) {
+  const spiralOutput = {
+    entryFileNames: `${output.jsDirectory}/[name]-[hash].js`,
+    chunkFileNames: `${output.jsDirectory}/chunks/[name]-[hash].js`,
+    assetFileNames: (assetInfo) => assetFileName(assetInfo.name, output)
+  };
+  if (Array.isArray(userOutput)) {
+    return userOutput;
+  }
+  if (typeof userOutput === "object" && userOutput !== null) {
+    return { ...spiralOutput, ...userOutput };
+  }
+  return spiralOutput;
+}
+function resolveAssetPlugins(options) {
+  if (options.assets.length === 0) {
+    return [];
+  }
+  let root = process.cwd();
+  return [{
+    name: "vite-plugin-spiral:assets",
+    apply: "build",
+    configResolved(config) {
+      root = config.root;
+    },
+    async buildStart() {
+      const files = await glob2(options.assets, {
+        cwd: root,
+        absolute: true
+      });
+      for (const file of files.sort()) {
+        const stats = await fs2.stat(file);
+        if (!stats.isFile()) {
+          continue;
+        }
+        this.emitFile({
+          type: "asset",
+          name: path2.basename(file),
+          originalFileName: normalizePath(path2.relative(root, file)),
+          source: await fs2.readFile(file)
+        });
+      }
+    }
+  }];
+}
+function resolveRefreshPlugins(refresh) {
+  return refresh.flatMap((config) => fullReload(config.paths, config.config));
+}
+function resolveRefreshConfig(refresh) {
+  if (refresh === false) {
+    return [];
+  }
+  if (refresh === void 0 || refresh === true) {
+    return [{ paths: defaultRefreshPaths }];
+  }
+  if (typeof refresh === "string") {
+    return [{ paths: [normalizePath(refresh)] }];
+  }
+  if (Array.isArray(refresh)) {
+    if (refresh.every((item) => typeof item === "string")) {
+      return [{ paths: refresh.map((item) => normalizePath(item)) }];
+    }
+    return refresh.map((item) => ({
+      ...item,
+      paths: item.paths.map(normalizePath)
+    }));
+  }
+  return [{ ...refresh, paths: refresh.paths.map(normalizePath) }];
+}
+function resolveBase(buildDirectory, assetUrl) {
+  const normalizedBuildDirectory = trimSlashes2(buildDirectory, "buildDirectory");
+  if (assetUrl === "") {
+    return `/${normalizedBuildDirectory}/`;
+  }
+  return `${stripTrailingSlash(assetUrl)}/${normalizedBuildDirectory}/`;
+}
+function resolveAliases(config) {
+  const defaults = {
+    "@": path2.resolve(config.root ?? process.cwd(), "app/resources/js"),
+    "@resources": path2.resolve(config.root ?? process.cwd(), "app/resources")
+  };
+  if (Array.isArray(config.resolve?.alias)) {
+    return [
+      ...config.resolve.alias,
+      ...Object.entries(defaults).map(([find, replacement]) => ({ find, replacement }))
+    ];
+  }
+  return {
+    ...defaults,
+    ...config.resolve?.alias
+  };
+}
+function resolveAllowedOrigins(env, appUrl) {
+  const configuredOrigins = (env.SPIRAL_VITE_ALLOWED_ORIGINS ?? "").split(",").map((origin) => origin.trim()).filter(Boolean);
+  return [
+    /^https?:\/\/localhost(:\d+)?$/,
+    /^https?:\/\/127\.0\.0\.1(:\d+)?$/,
+    /^https?:\/\/\[::1\](:\d+)?$/,
+    /^https?:\/\/.*\.test(:\d+)?$/,
+    ...appUrl ? [appUrl] : [],
+    ...configuredOrigins
+  ];
+}
+function resolveEnvironmentServerConfig(env) {
+  const key = env.SPIRAL_VITE_DEV_SERVER_KEY;
+  const cert = env.SPIRAL_VITE_DEV_SERVER_CERT;
+  if (!key && !cert) {
+    return;
+  }
+  if (!key || !cert || !fsSync2.existsSync(key) || !fsSync2.existsSync(cert)) {
+    throw new Error(`vite-plugin-spiral could not find certificate files from SPIRAL_VITE_DEV_SERVER_KEY [${key ?? ""}] and SPIRAL_VITE_DEV_SERVER_CERT [${cert ?? ""}].`);
+  }
+  const host = resolveHostFromEnv(env);
+  if (!host) {
+    throw new Error(`vite-plugin-spiral could not determine the dev server host from SPIRAL_APP_URL or APP_URL.`);
+  }
+  return {
+    host,
+    hmr: { host },
+    https: {
+      key: fsSync2.readFileSync(key),
+      cert: fsSync2.readFileSync(cert)
+    }
+  };
+}
+function resolveDevelopmentEnvironmentServerConfig(host) {
+  if (host === false) {
+    return;
+  }
+  const configPath = determineDevelopmentEnvironmentConfigPath();
+  if (configPath === void 0 && host === null) {
+    return;
+  }
+  if (configPath === void 0) {
+    throw new Error("vite-plugin-spiral could not find a Herd or Valet configuration directory.");
+  }
+  const resolvedHost = host === true || host === null ? `${path2.basename(process.cwd())}.${resolveDevelopmentEnvironmentTld(configPath)}` : host;
+  const key = path2.resolve(configPath, "Certificates", `${resolvedHost}.key`);
+  const cert = path2.resolve(configPath, "Certificates", `${resolvedHost}.crt`);
+  if (!fsSync2.existsSync(key) || !fsSync2.existsSync(cert)) {
+    if (host === null) {
+      return;
+    }
+    throw new Error(`vite-plugin-spiral could not find TLS certificate files for [${resolvedHost}] in [${configPath}/Certificates].`);
+  }
+  return {
+    host: resolvedHost,
+    hmr: { host: resolvedHost },
+    https: { key, cert }
+  };
+}
+function resolveHostFromEnv(env) {
+  const appUrl = env.SPIRAL_APP_URL ?? env.APP_URL;
+  try {
+    return appUrl ? new URL(appUrl).host : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function ensureCommandShouldRunInEnvironment(command, env) {
+  if (command === "build" || env.SPIRAL_VITE_BYPASS_ENV_CHECK === "1") {
+    return;
+  }
+  if (env.CI !== void 0) {
+    throw new Error("vite-plugin-spiral refuses to run the Vite dev server in CI. Run npm run build instead or set SPIRAL_VITE_BYPASS_ENV_CHECK=1.");
+  }
+  if (env.APP_ENV === "production" || env.SPIRAL_ENV === "production") {
+    throw new Error("vite-plugin-spiral refuses to run the Vite dev server in production. Run npm run build instead or set SPIRAL_VITE_BYPASS_ENV_CHECK=1.");
+  }
+}
+function assetFileName(assetName, output) {
+  const extension = path2.extname(assetName ?? "").toLowerCase();
+  if (extension === ".css") {
+    return `${output.cssDirectory}/[name]-[hash][extname]`;
+  }
+  if (imageExtensions.has(extension)) {
+    return `${output.imageDirectory}/[name]-[hash][extname]`;
+  }
+  if (fontExtensions2.has(extension)) {
+    return `${output.fontDirectory}/[name]-[hash][extname]`;
+  }
+  return `${output.assetDirectory}/[name]-[hash][extname]`;
+}
+async function writeIntegrityManifest(config, options) {
+  if (options.integrity === false) {
+    return;
+  }
+  const outDir = path2.resolve(config.root, config.build.outDir);
+  const manifestPath = path2.join(outDir, "manifest.json");
+  const algorithm = options.integrity;
+  let manifest;
+  try {
+    manifest = JSON.parse(await fs2.readFile(manifestPath, "utf8"));
+  } catch {
+    return;
+  }
+  for (const chunk of Object.values(manifest)) {
+    if (typeof chunk.file === "string") {
+      chunk.integrity = await integrityForFile(path2.join(outDir, chunk.file), algorithm);
+    }
+    if (Array.isArray(chunk.css) && chunk.css.length > 0) {
+      chunk.cssIntegrity = {};
+      for (const cssFile of chunk.css) {
+        chunk.cssIntegrity[cssFile] = await integrityForFile(path2.join(outDir, cssFile), algorithm);
+      }
+    }
+  }
+  await fs2.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+async function integrityForFile(file, algorithm) {
+  const contents = await fs2.readFile(file);
+  return `${algorithm}-${createHash2(algorithm).update(contents).digest("base64")}`;
+}
+function resolveDevServerUrl(address, config, rawConfig) {
+  const hmr = typeof config.server.hmr === "object" ? config.server.hmr : void 0;
+  const protocol = hmr?.protocol ? hmr.protocol === "wss" ? "https" : "http" : config.server.https ? "https" : "http";
+  const host = hmr?.host ?? (typeof config.server.host === "string" && config.server.host !== "0.0.0.0" && config.server.host !== "::" ? config.server.host : void 0) ?? (rawConfig.server?.host === "0.0.0.0" ? "localhost" : void 0) ?? (isIpv6(address) ? `[${address.address}]` : address.address);
+  const port = hmr?.clientPort ?? address.port;
+  return `${protocol}://${host}:${port}`;
+}
+function isIpv6(address) {
+  return address.family === "IPv6" || address.family === 6;
+}
+function logDevServer(server, options, devServerUrl) {
+  const env = loadEnv(server.config.mode, server.config.envDir || process.cwd(), "");
+  const appUrl = env.SPIRAL_APP_URL ?? env.APP_URL ?? "undefined";
+  setTimeout(() => {
+    server.config.logger.info(`
+  ${colors.cyan(`${colors.bold("SPIRAL")} Vite`)} ${colors.dim("plugin")} ${colors.bold(`v${pluginVersion()}`)}`);
+    server.config.logger.info(`  ${colors.green("\u279C")}  APP_URL: ${colors.cyan(appUrl)}`);
+    server.config.logger.info(`  ${colors.green("\u279C")}  VITE_URL: ${colors.cyan(devServerUrl)}`);
+    server.config.logger.info(`  ${colors.green("\u279C")}  HOT_FILE: ${colors.dim(options.hotFile)}`);
+    if (server.config.server.https) {
+      server.config.logger.info(`  ${colors.green("\u279C")}  TLS: ${colors.cyan("enabled")}`);
+    }
+  }, 100);
+}
+function pluginVersion() {
+  try {
+    const packageJson = JSON.parse(fsSync2.readFileSync(path2.resolve(import.meta.dirname, "../package.json"), "utf8"));
+    return packageJson.version ?? "";
+  } catch {
+    return "";
+  }
+}
+function determineDevelopmentEnvironmentConfigPath() {
+  const paths = [
+    path2.resolve(os.homedir(), "Library", "Application Support", "Herd", "config", "valet"),
+    path2.resolve(os.homedir(), ".config", "herd", "config", "valet"),
+    path2.resolve(os.homedir(), ".config", "valet"),
+    path2.resolve(os.homedir(), ".valet")
+  ];
+  return paths.find((configPath) => fsSync2.existsSync(configPath));
+}
+function resolveDevelopmentEnvironmentTld(configPath) {
+  const configFile = path2.resolve(configPath, "config.json");
+  if (!fsSync2.existsSync(configFile)) {
+    throw new Error(`vite-plugin-spiral could not find Herd or Valet config file [${configFile}].`);
+  }
+  const config = JSON.parse(fsSync2.readFileSync(configFile, "utf8"));
+  if (!config.tld) {
+    throw new Error(`vite-plugin-spiral could not determine the Herd or Valet TLD from [${configFile}].`);
+  }
+  return config.tld;
+}
+function devServerIndexHtml(appUrl) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Spiral Vite</title>
+  <style>body{font-family:system-ui,-apple-system,Segoe UI,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;background:#0f172a;color:#e2e8f0}main{max-width:42rem;padding:2rem}a{color:#67e8f9}</style>
+</head>
+<body>
+  <main>
+    <h1>Spiral Vite dev server</h1>
+    <p>This server provides Vite assets and hot module replacement for a Spiral application.</p>
+    <p>Open the application at <a href="${escapeHtml(appUrl)}">${escapeHtml(appUrl)}</a>.</p>
+  </main>
+</body>
+</html>`;
+}
+function resolveRootPath(root, file) {
+  return path2.resolve(root, file);
+}
+function posixJoin(...segments) {
+  return segments.map((segment) => trimSlashes2(segment, "path segment")).filter(Boolean).join("/");
+}
+function trimSlashes2(value, name) {
+  const normalized = normalizePath(value).replace(/^\/+|\/+$/g, "");
+  if (normalized === "") {
+    throw new Error(`vite-plugin-spiral: ${name} must be a non-empty relative path.`);
+  }
+  return normalized;
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/g, "");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export {
+  spiral as default,
+  spiral
+};