@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-X3XUZWRB.mjs

@@ -0,0 +1,141 @@
+import {
+  normalizeFarmRouteRuntimeConfig
+} from "./chunk-EVMXPJCB.mjs";
+import {
+  validateConfigRouteSource
+} from "./chunk-ONG4RDW3.mjs";
+import {
+  isFarmRedirectStatus
+} from "./chunk-JNYFXL7X.mjs";
+
+// src/route-rules.ts
+function normalizeRouteRules(routeRules) {
+  if (!routeRules) return {};
+  const normalized = {};
+  const normalizedSources = /* @__PURE__ */ new Map();
+  for (const [source, rule] of Object.entries(routeRules)) {
+    if (!rule) continue;
+    const normalizedSource = normalizeRuleSource(source);
+    validateConfigRouteSource(normalizedSource, `Route rule "${source}" source`);
+    const existingSource = normalizedSources.get(normalizedSource);
+    if (existingSource !== void 0) {
+      throw new Error(
+        `Route rules "${existingSource}" and "${source}" both normalize to "${normalizedSource}".`
+      );
+    }
+    normalizedSources.set(normalizedSource, source);
+    if (typeof rule.redirect === "object" && rule.redirect.statusCode !== void 0 && !isFarmRedirectStatus(rule.redirect.statusCode)) {
+      throw new RangeError(
+        `Route rule "${normalizedSource}" redirect.statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+    normalized[normalizedSource] = {
+      ...rule,
+      ...normalizeFarmRouteRuntimeConfig(rule, `Route rule "${normalizedSource}"`)
+    };
+  }
+  return normalized;
+}
+function routeRulesToRedirects(routeRules) {
+  return Object.entries(routeRules).filter(
+    (entry) => Boolean(entry[1].redirect)
+  ).map(([source, rule]) => {
+    const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+    return {
+      source,
+      destination: redirect.to,
+      permanent: redirect.permanent,
+      statusCode: redirect.statusCode ?? (redirect.permanent === true ? 308 : void 0)
+    };
+  });
+}
+function routeRulesToHeaders(routeRules) {
+  const configs = [];
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const headers = {
+      ...normalizeCorsHeaders(rule.cors),
+      ...rule.headers
+    };
+    const entries = Object.entries(headers);
+    if (entries.length === 0) continue;
+    configs.push({
+      source,
+      headers: entries.map(([key, value]) => ({ key, value }))
+    });
+  }
+  return configs;
+}
+function routeRulesToNitroRouteRules(routeRules) {
+  const nitroRules = {};
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const nitroRule = { ...rule };
+    if (rule.render === "static") {
+      nitroRule.prerender = true;
+    } else if (rule.render === "dynamic") {
+      nitroRule.prerender = false;
+    }
+    if (rule.redirect) {
+      const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+      if (hasExplicitQuery(redirect.to)) {
+        delete nitroRule.redirect;
+      } else {
+        nitroRule.redirect = {
+          to: redirect.to,
+          status: redirect.statusCode ?? (redirect.permanent === true ? 308 : 307)
+        };
+      }
+    }
+    if (rule.cors) {
+      nitroRule.cors = true;
+      nitroRule.headers = {
+        ...normalizeCorsHeaders(rule.cors),
+        ...rule.headers
+      };
+    }
+    delete nitroRule.render;
+    delete nitroRule.runtime;
+    delete nitroRule.regions;
+    delete nitroRule.maxDuration;
+    nitroRules[source] = nitroRule;
+  }
+  return nitroRules;
+}
+function normalizeCorsHeaders(cors) {
+  if (!cors) return {};
+  if (cors === true) {
+    return {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "*",
+      "Access-Control-Allow-Headers": "*"
+    };
+  }
+  return {
+    "Access-Control-Allow-Origin": cors.origin ?? "*",
+    "Access-Control-Allow-Methods": normalizeList(cors.methods) ?? "*",
+    "Access-Control-Allow-Headers": normalizeList(cors.headers) ?? "*"
+  };
+}
+function normalizeList(value) {
+  if (!value || typeof value === "string") return value;
+  return value.join(", ");
+}
+function normalizeRuleSource(source) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    throw new TypeError("Route rule source must be a non-empty pathname pattern.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function hasExplicitQuery(destination) {
+  const queryIndex = destination.indexOf("?");
+  if (queryIndex === -1) return false;
+  const hashIndex = destination.indexOf("#");
+  return hashIndex === -1 || queryIndex < hashIndex;
+}
+
+export {
+  normalizeRouteRules,
+  routeRulesToRedirects,
+  routeRulesToHeaders,
+  routeRulesToNitroRouteRules
+};

package/dist/chunk-XGJVRPYL.cjs

@@ -0,0 +1,141 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkTVCFY3KKcjs = require('./chunk-TVCFY3KK.cjs');
+
+
+
+
+
+var _chunkCQL5ZGFUcjs = require('./chunk-CQL5ZGFU.cjs');
+
+
+
+var _chunk3BIASUGRcjs = require('./chunk-3BIASUGR.cjs');
+
+// src/client/island-values.ts
+var FARM_VALUE_MIN_LENGTH = 512;
+function hashFarmValue(json) {
+  let h1 = 3735928559 ^ json.length;
+  let h2 = 1103547991 ^ json.length;
+  for (let index = 0; index < json.length; index++) {
+    const code = json.charCodeAt(index);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(36).padStart(7, "0") + (h1 >>> 0).toString(36).padStart(7, "0");
+}
+function addressFarmValues(props, minLength = FARM_VALUE_MIN_LENGTH) {
+  const values = /* @__PURE__ */ new Map();
+  const reference = (json2, children, parent) => {
+    const key = hashFarmValue(json2);
+    if (!values.has(key)) values.set(key, { key, json: json2, children });
+    parent.push(key);
+    return `{"$":"${_chunkCQL5ZGFUcjs.FARM_REFERENCE_TAG}","v":"${key}"}`;
+  };
+  const encode = (value, parent) => {
+    if (value === null || typeof value !== "object") {
+      const json3 = JSON.stringify(value);
+      return [
+        typeof value === "string" && json3.length >= minLength ? reference(json3, [], parent) : json3,
+        json3.length
+      ];
+    }
+    const own = [];
+    let length = 2;
+    const parts = [];
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        const [json3, entryLength] = encode(entry, own);
+        parts.push(json3);
+        length += entryLength + 1;
+      }
+    } else {
+      for (const [key, entry] of Object.entries(value)) {
+        const [json3, entryLength] = encode(entry, own);
+        const name = JSON.stringify(key);
+        parts.push(`${name}:${json3}`);
+        length += name.length + entryLength + 2;
+      }
+    }
+    const json2 = Array.isArray(value) ? `[${parts.join(",")}]` : `{${parts.join(",")}}`;
+    const wrapper = own.length === 1 && json2.length < minLength / 4;
+    if (length >= minLength && !wrapper) return [reference(json2, own, parent), length];
+    parent.push(...own);
+    return [json2, length];
+  };
+  const roots = [];
+  const json = `{${Object.entries(props).map(([key, entry]) => `${JSON.stringify(key)}:${encode(entry, roots)[0]}`).join(",")}}`;
+  return { json, values, roots };
+}
+function selectFarmValuesToSend(addressed, held) {
+  const send = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (key) => {
+    if (seen.has(key)) return;
+    seen.add(key);
+    if (_optionalChain([held, 'optionalAccess', _ => _.has, 'call', _2 => _2(key)])) return;
+    const value = addressed.values.get(key);
+    send.push(value);
+    value.children.forEach(visit);
+  };
+  addressed.roots.forEach(visit);
+  return send;
+}
+function parseFarmHeldValues(header) {
+  const held = /* @__PURE__ */ new Set();
+  if (!header) return held;
+  for (const key of header.split(",", _chunkCQL5ZGFUcjs.FARM_MAX_HELD_VALUES * 2)) {
+    const trimmed = key.trim();
+    if (_chunkCQL5ZGFUcjs.FARM_VALUE_KEY_PATTERN.test(trimmed)) held.add(trimmed);
+    if (held.size === _chunkCQL5ZGFUcjs.FARM_MAX_HELD_VALUES) break;
+  }
+  return held;
+}
+var heldByRequest = /* @__PURE__ */ new WeakMap();
+var ignoredRequests = /* @__PURE__ */ new WeakSet();
+function ignoreFarmHeldValues() {
+  const request = _chunk3BIASUGRcjs._resolveCurrentRequest.call(void 0, );
+  if (request) ignoredRequests.add(request);
+}
+function readFarmHeldValues() {
+  const request = _chunk3BIASUGRcjs._resolveCurrentRequest.call(void 0, );
+  if (!request || ignoredRequests.has(request)) return null;
+  let held = heldByRequest.get(request);
+  if (!held) {
+    held = parseFarmHeldValues(request.headers.get(_chunkCQL5ZGFUcjs.FARM_VALUES_HEADER));
+    heldByRequest.set(request, held);
+    if (held.size > 0) void _optionalChain([_chunk3BIASUGRcjs._resolveCurrentRequestForApp.call(void 0, ), 'optionalAccess', _3 => _3.headers]);
+  }
+  return held.size > 0 ? held : null;
+}
+var SERVER_KEY = /* @__PURE__ */ Symbol.for("farm.island-values.server");
+var sentByRequest = /* @__PURE__ */ new WeakMap();
+function resolveFarmIslandRenderState() {
+  const request = _chunk3BIASUGRcjs._resolveCurrentRequest.call(void 0, );
+  if (!request) return null;
+  let sent = sentByRequest.get(request);
+  if (!sent) sentByRequest.set(request, sent = /* @__PURE__ */ new Set());
+  return { held: readFarmHeldValues(), sent };
+}
+function installFarmIslandValues() {
+  globalThis[SERVER_KEY] = {
+    address: addressFarmValues,
+    select: selectFarmValuesToSend,
+    held: readFarmHeldValues,
+    encodeLeaf: _chunkTVCFY3KKcjs.encodeFarmLeaf,
+    decode: _chunkTVCFY3KKcjs.decodeFarmTagged
+  };
+}
+function uninstallFarmIslandValues() {
+  delete globalThis[SERVER_KEY];
+}
+
+
+
+
+
+
+exports.ignoreFarmHeldValues = ignoreFarmHeldValues; exports.resolveFarmIslandRenderState = resolveFarmIslandRenderState; exports.installFarmIslandValues = installFarmIslandValues; exports.uninstallFarmIslandValues = uninstallFarmIslandValues;

package/dist/chunk-XLLVWLWO.mjs

@@ -0,0 +1,100 @@
+import {
+  formatOptionalPeerInstallHint,
+  isMissingPackageError
+} from "./chunk-NR63PD3P.mjs";
+import {
+  logger
+} from "./chunk-2SVJGOAX.mjs";
+
+// src/build/tailwind.ts
+import path from "path";
+
+// src/build/vite-plugin-compat.ts
+function adaptTailwindVitePlugin(pluginOption, builder) {
+  if (builder !== "rolldown") return pluginOption;
+  return adaptPluginOption(pluginOption);
+}
+function adaptPluginOption(pluginOption) {
+  if (Array.isArray(pluginOption)) return pluginOption.map(adaptPluginOption);
+  if (!pluginOption || typeof pluginOption !== "object") return pluginOption;
+  const plugin = pluginOption;
+  if (!plugin.name?.startsWith("@tailwindcss/vite:generate:")) return pluginOption;
+  if (isVitePluginHook(plugin.transform)) {
+    return {
+      ...plugin,
+      transform: withVite5TransformContext(plugin.transform)
+    };
+  }
+  if (plugin.transform && typeof plugin.transform === "object" && "handler" in plugin.transform && isVitePluginHook(plugin.transform.handler)) {
+    return {
+      ...plugin,
+      transform: {
+        ...plugin.transform,
+        handler: withVite5TransformContext(plugin.transform.handler)
+      }
+    };
+  }
+  return pluginOption;
+}
+function isVitePluginHook(value) {
+  return typeof value === "function";
+}
+function withVite5TransformContext(handler) {
+  return function(...args) {
+    const context = new Proxy(this, {
+      get(target, property, receiver) {
+        if (property === "environment") return void 0;
+        return Reflect.get(target, property, receiver);
+      }
+    });
+    return handler.apply(context, args);
+  };
+}
+
+// src/build/tailwind.ts
+var TAILWIND_CSS_IMPORT = /@import\s+["']tailwindcss["']/;
+var TAILWIND_VITE_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@tailwindcss/vite",
+  "enable built-in Tailwind CSS support",
+  { dev: true }
+);
+var warnedMissingTailwind = false;
+async function loadTailwindVitePlugin(options = {}, importTailwind = () => import("@tailwindcss/vite")) {
+  try {
+    const tailwindVite = (await importTailwind()).default;
+    const plugin = options.builder ? adaptTailwindVitePlugin(tailwindVite(), options.builder) : tailwindVite();
+    if (options.announce) logger.info("\u{1F4E6} Enabled built-in Tailwind support (@tailwindcss/vite)");
+    return plugin;
+  } catch (error) {
+    if (isMissingPackageError(error, "@tailwindcss/vite")) return createMissingTailwindPlugin();
+    logger.warn(
+      `Tailwind plugin auto-enable failed${options.label ? ` ${options.label}` : ""}; continuing without it: ${error.message}`
+    );
+    return void 0;
+  }
+}
+function createMissingTailwindPlugin() {
+  let root = process.cwd();
+  return {
+    name: "farm:tailwind-missing",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root;
+    },
+    transform(code, id) {
+      if (warnedMissingTailwind || !/\.css(?:\?.*)?$/.test(id) || !TAILWIND_CSS_IMPORT.test(code)) {
+        return null;
+      }
+      warnedMissingTailwind = true;
+      const file = path.relative(root, id.split("?", 1)[0]).replace(/\\/g, "/");
+      logger.warn(
+        `${file} imports Tailwind CSS, but @tailwindcss/vite is not installed; continuing without Tailwind. ${TAILWIND_VITE_INSTALL_HINT}`
+      );
+      return null;
+    }
+  };
+}
+
+export {
+  loadTailwindVitePlugin
+};

package/dist/chunk-XLYXG73A.mjs

@@ -0,0 +1,87 @@
+// src/react-refresh.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var REACT_REFRESH_PLUGIN = "vite:react-refresh";
+var FARM_REACT_REFRESH_PREAMBLE_ID = "/@farm/react-refresh-preamble";
+var FARM_OWNED = /* @__PURE__ */ Symbol.for("farm.react-refresh.owned");
+function isFarmReactRefreshActive(config) {
+  return config.command === "serve" && !config.isProduction && config.server.hmr !== false && config.plugins.some((plugin) => plugin.name === REACT_REFRESH_PLUGIN);
+}
+function isFarmClientEntryId(id) {
+  const pathname = id.split("?", 1)[0];
+  return pathname === "/@farm/client" || pathname === "/@farm/client.js";
+}
+function hasAppReactPlugin(plugins) {
+  const pending = [...plugins ?? []];
+  while (pending.length > 0) {
+    const entry = pending.pop();
+    if (Array.isArray(entry)) {
+      pending.push(...entry);
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || "then" in entry) continue;
+    if (entry.name === REACT_REFRESH_PLUGIN && !(FARM_OWNED in entry)) return true;
+  }
+  return false;
+}
+function createFarmReactRefreshPreamblePlugin() {
+  let active = false;
+  return {
+    name: "farm:react-refresh-preamble",
+    apply: "serve",
+    configResolved(config) {
+      active = isFarmReactRefreshActive(config);
+    },
+    resolveId(id) {
+      if (id === FARM_REACT_REFRESH_PREAMBLE_ID) return id;
+    },
+    load(id) {
+      if (id !== FARM_REACT_REFRESH_PREAMBLE_ID) return;
+      if (!active) return "";
+      return `import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`;
+    },
+    transform(code, id) {
+      if (!active || this.environment?.config.consumer !== "client" || !isFarmClientEntryId(id)) {
+        return;
+      }
+      return {
+        code: `import ${JSON.stringify(FARM_REACT_REFRESH_PREAMBLE_ID)};
+${code}`,
+        map: null
+      };
+    }
+  };
+}
+async function loadFarmReactPlugin() {
+  const entry = createRequire(
+    typeof __filename === "string" ? __filename : import.meta.url
+  ).resolve("@vitejs/plugin-react");
+  return await import(
+    /* @vite-ignore */
+    pathToFileURL(entry).href
+  );
+}
+async function createFarmReactRefreshPlugins() {
+  const { default: react } = await loadFarmReactPlugin();
+  const plugins = react().map(
+    (plugin) => Object.assign(
+      {
+        ...plugin,
+        apply: (config, env) => env.command === "serve" && !hasAppReactPlugin(config.plugins)
+      },
+      { [FARM_OWNED]: true }
+    )
+  );
+  return [...plugins, createFarmReactRefreshPreamblePlugin()];
+}
+
+export {
+  isFarmReactRefreshActive,
+  loadFarmReactPlugin,
+  createFarmReactRefreshPlugins
+};

package/dist/chunk-XN2MB4QZ.cjs

@@ -0,0 +1,206 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkJHXJBNLYcjs = require('./chunk-JHXJBNLY.cjs');
+
+
+var _chunk6CTFVBATcjs = require('./chunk-6CTFVBAT.cjs');
+
+
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// src/utils.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function parseRoutePath(filePath) {
+  const segments = [];
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const pathParts = normalizedPath.split("/").filter(Boolean);
+  const fileName = pathParts.pop() || "";
+  const fileType = getRouteType(fileName);
+  const routePath = `/${pathParts.join("/")}`;
+  _chunkYTVSWXEZcjs.assertBrowserStableRoutePath.call(void 0, routePath);
+  _chunkYTVSWXEZcjs.assertTerminalCatchAll.call(void 0, routePath);
+  _chunkYTVSWXEZcjs.assertUniqueRouteParameters.call(void 0, routePath);
+  for (const part of pathParts) {
+    if (part.startsWith("(") && part.endsWith(")")) continue;
+    if (part.startsWith("[") && part.endsWith("]")) {
+      let segment = part.slice(1, -1);
+      const isDynamic = true;
+      let isOptional = false;
+      let isCatchAll = false;
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        isOptional = true;
+        segment = segment.slice(1, -1);
+        if (segment.startsWith("...")) {
+          segment = segment.slice(3);
+          isCatchAll = true;
+        }
+      } else if (segment.startsWith("...")) {
+        segment = segment.slice(3);
+        isCatchAll = true;
+      }
+      segments.push({ segment, isDynamic, isOptional, isCatchAll });
+    } else {
+      segments.push({
+        segment: part,
+        isDynamic: false,
+        isOptional: false,
+        isCatchAll: false
+      });
+    }
+  }
+  return {
+    segments,
+    filePath: normalizedPath,
+    type: fileType
+  };
+}
+function getRouteType(fileName) {
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|mdx?|markdown)$/, "");
+  switch (baseName) {
+    case "page":
+      return "page";
+    case "layout":
+      return "layout";
+    case "loading":
+      return "loading";
+    case "error":
+      return "error";
+    case "not-found":
+      return "not-found";
+    default:
+      return "page";
+  }
+}
+function segmentsToPattern(segments) {
+  if (segments.length === 0) return "/";
+  return "/" + segments.map((segment) => {
+    if (!segment.isDynamic) return segment.segment;
+    if (segment.isCatchAll) {
+      return segment.isOptional ? `*${segment.segment}?` : `*${segment.segment}`;
+    }
+    return `:${segment.segment}`;
+  }).join("/");
+}
+function matchRoute(url, segments) {
+  return matchRouteParts(splitRoutePath(url), segments);
+}
+function splitRoutePath(url) {
+  return url.split("/").filter(Boolean).map(_chunk6CTFVBATcjs.decodeRouteSegment);
+}
+function matchRouteParts(urlParts, segments) {
+  const params = {};
+  if (segments.length === 0) {
+    return { params, matches: urlParts.length === 0 };
+  }
+  let urlIndex = 0;
+  let segmentIndex = 0;
+  while (segmentIndex < segments.length && urlIndex <= urlParts.length) {
+    const segment = segments[segmentIndex];
+    if (!segment.isDynamic) {
+      if (urlParts[urlIndex] !== segment.segment) {
+        return { params: {}, matches: false };
+      }
+      urlIndex++;
+      segmentIndex++;
+    } else if (segment.isCatchAll) {
+      const remainingParts = urlParts.slice(urlIndex);
+      if (remainingParts.length === 0 && !segment.isOptional) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = remainingParts.join("/");
+      urlIndex = urlParts.length;
+      segmentIndex++;
+    } else {
+      if (urlIndex >= urlParts.length) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = urlParts[urlIndex];
+      urlIndex++;
+      segmentIndex++;
+    }
+  }
+  const matches = segmentIndex === segments.length && urlIndex === urlParts.length;
+  return { params, matches };
+}
+function matchRoutePrefix(url, segments) {
+  return matchRoutePrefixParts(splitRoutePath(url), segments);
+}
+function matchRoutePrefixParts(urlParts, segments) {
+  let urlIndex = 0;
+  for (const segment of segments) {
+    if (segment.isCatchAll) {
+      return segment.isOptional || urlIndex < urlParts.length;
+    }
+    const urlPart = urlParts[urlIndex];
+    if (urlPart === void 0) return false;
+    if (!segment.isDynamic && segment.segment !== urlPart) return false;
+    urlIndex++;
+  }
+  return true;
+}
+function resolveAppPath(root, ...paths) {
+  return _path2.default.resolve(root, ...paths);
+}
+function toRootRelativeUrlPath(absolutePath, projectRoot) {
+  if (absolutePath === projectRoot) return "";
+  if (absolutePath.startsWith(`${projectRoot}/`) || absolutePath.startsWith(`${projectRoot}\\`)) {
+    return absolutePath.slice(projectRoot.length).replace(/\\/g, "/");
+  }
+  return void 0;
+}
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function toViteModuleId(filePath, root) {
+  if (!_path2.default.isAbsolute(filePath)) return filePath;
+  const relativePath = _path2.default.relative(root, filePath);
+  if (relativePath && !relativePath.startsWith("..") && !_path2.default.isAbsolute(relativePath)) {
+    return `/${relativePath.split(_path2.default.sep).join("/")}`;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return normalizedPath.startsWith("/") ? `/@fs${normalizedPath}` : `/@fs/${normalizedPath}`;
+}
+async function fileExists(filePath) {
+  try {
+    const fs = await import("fs/promises");
+    await fs.access(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function globFiles(pattern, cwd) {
+  const glob = await import("fast-glob");
+  return glob.default(pattern, { cwd, absolute: false });
+}
+function parseSearchParams(searchParams) {
+  return _chunkJHXJBNLYcjs.searchParamsToObject.call(void 0, searchParams);
+}
+var logger = {
+  info: (message) => console.log(`[info] ${message}`),
+  success: (message) => console.log(`[success] ${message}`),
+  warn: (message) => console.warn(`\u26A0\uFE0F  ${message}`),
+  error: (message) => console.error(`\u274C ${message}`),
+  ready: (message) => console.log(`${message}`),
+  event: (message) => console.log(`  ${message}`)
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseRoutePath = parseRoutePath; exports.segmentsToPattern = segmentsToPattern; exports.matchRoute = matchRoute; exports.splitRoutePath = splitRoutePath; exports.matchRouteParts = matchRouteParts; exports.matchRoutePrefix = matchRoutePrefix; exports.matchRoutePrefixParts = matchRoutePrefixParts; exports.resolveAppPath = resolveAppPath; exports.toRootRelativeUrlPath = toRootRelativeUrlPath; exports.toPosixPath = toPosixPath; exports.toViteModuleId = toViteModuleId; exports.fileExists = fileExists; exports.globFiles = globFiles; exports.parseSearchParams = parseSearchParams; exports.logger = logger;