@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-b7j671dj.js

@@ -0,0 +1,207 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  includeTypes,
+  writeFileAtomic
+} from "./index-4da76t62.js";
+
+// src/compat/tsconfig-defaults.ts
+import { existsSync, readdirSync } from "fs";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import path from "path";
+function hasTypescriptSources(root, depth = 0) {
+  if (depth > 6)
+    return false;
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules")
+      continue;
+    if (entry.isFile() && /\.(ts|tsx|mts|cts)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      return true;
+    }
+    if (entry.isDirectory() && hasTypescriptSources(path.join(root, entry.name), depth + 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function appTypescriptVersion(root) {
+  for (const base of [root, __PNEXT_PACKAGE_ROOT__ + "/src/compat"]) {
+    try {
+      const require2 = createRequire(path.join(base, "noop.js"));
+      const pkg = require2("typescript/package.json");
+      if (typeof pkg.version === "string")
+        return pkg.version;
+    } catch {}
+  }
+  return "5.9.0";
+}
+function versionGte(version, major, minor) {
+  const [maj = 0, min = 0] = version.split(".").map((part) => Number.parseInt(part, 10));
+  return maj > major || maj === major && min >= minor;
+}
+function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
+  const configuredModule = typeof userTsConfig.compilerOptions?.module === "string" ? userTsConfig.compilerOptions.module.toLowerCase() : undefined;
+  const preferBundlerResolution = versionGte(typescriptVersion, 5, 0) && configuredModule !== "commonjs" && configuredModule !== "amd";
+  const modulePreserve = versionGte(typescriptVersion, 5, 4) && configuredModule === "preserve";
+  return {
+    target: {
+      suggested: "ES2017",
+      reason: "For top-level `await`. Note: Next.js only polyfills for the esmodules target."
+    },
+    lib: { suggested: ["dom", "dom.iterable", "esnext"] },
+    allowJs: { suggested: true },
+    skipLibCheck: { suggested: true },
+    strict: { suggested: false },
+    noEmit: { suggested: true },
+    incremental: { suggested: true },
+    module: {
+      parsedValue: "esnext",
+      parsedValues: [
+        ...versionGte(typescriptVersion, 5, 4) ? ["preserve"] : [],
+        "es2020",
+        "esnext",
+        "commonjs",
+        "amd",
+        "nodenext",
+        "node16"
+      ],
+      value: "esnext",
+      reason: "for dynamic import() support"
+    },
+    ...modulePreserve ? {} : {
+      esModuleInterop: { value: true, reason: "requirement for SWC / babel" },
+      moduleResolution: {
+        parsedValue: preferBundlerResolution ? "bundler" : "node",
+        parsedValues: preferBundlerResolution ? ["node16", "nodenext", "bundler"] : ["node", "node12", "node16", "nodenext"],
+        value: preferBundlerResolution ? "bundler" : "node",
+        reason: preferBundlerResolution ? "to match modern bundler resolution" : "to match webpack resolution"
+      },
+      resolveJsonModule: { value: true, reason: "to match webpack resolution" }
+    },
+    ...userTsConfig.compilerOptions?.verbatimModuleSyntax === true ? {} : { isolatedModules: { value: true, reason: "requirement for SWC / Babel" } },
+    jsx: {
+      parsedValue: "react-jsx",
+      parsedValues: ["preserve", "react-jsx"],
+      value: "react-jsx",
+      reason: "next.js uses the React automatic runtime"
+    }
+  };
+}
+function typeDefinitionGlobPatterns(distDir) {
+  return [`${distDir}/types/**/*.ts`, `${distDir}/dev/types/**/*.ts`].sort((a, b) => a.length - b.length);
+}
+async function writeTsconfigDefaults(config) {
+  const tsConfigPath = path.join(config.root, "tsconfig.json");
+  const tempDirectory = path.dirname(config.root);
+  let isFirstTimeSetup = false;
+  if (!existsSync(tsConfigPath)) {
+    if (!hasTypescriptSources(config.root))
+      return;
+    isFirstTimeSetup = true;
+    await writeFileAtomic(tsConfigPath, `{}
+`, tempDirectory);
+  }
+  let userTsConfig;
+  try {
+    userTsConfig = JSON.parse(await readFile(tsConfigPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (userTsConfig === null || typeof userTsConfig !== "object")
+    return;
+  if ("extends" in userTsConfig || "references" in userTsConfig)
+    return;
+  if (userTsConfig.compilerOptions == null)
+    userTsConfig.compilerOptions = {};
+  const compilerOptions = userTsConfig.compilerOptions;
+  const desired = getDesiredCompilerOptions(appTypescriptVersion(config.root), userTsConfig);
+  const suggestedActions = [];
+  const requiredActions = [];
+  for (const [optionKey, check] of Object.entries(desired)) {
+    if ("suggested" in check) {
+      if (!(optionKey in compilerOptions)) {
+        compilerOptions[optionKey] = check.suggested;
+        suggestedActions.push(`${optionKey} was set to ${JSON.stringify(check.suggested)}` + (check.reason ? ` (${check.reason})` : ""));
+      }
+      continue;
+    }
+    let existingValue = compilerOptions[optionKey];
+    if (typeof existingValue === "string")
+      existingValue = existingValue.toLowerCase();
+    const satisfied = check.parsedValues ? check.parsedValues.includes(existingValue) : (check.parsedValue ?? check.value) === existingValue;
+    if (!satisfied) {
+      compilerOptions[optionKey] = check.value;
+      requiredActions.push(`${optionKey} was set to ${String(check.value)} (${check.reason})`);
+    }
+  }
+  const hasAppDir = existsSync(path.join(config.root, "app")) || existsSync(path.join(config.root, "src", "app"));
+  const hasPagesDir = existsSync(path.join(config.root, "pages")) || existsSync(path.join(config.root, "src", "pages"));
+  const strictRouteTypes = process.env.__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES === "true";
+  const distDir = typeof getNextConfig().distDir === "string" ? getNextConfig().distDir : ".next";
+  const nextTypes = typeDefinitionGlobPatterns(distDir);
+  if (!("include" in userTsConfig)) {
+    const defaultInclude = hasAppDir && !strictRouteTypes ? ["next-env.d.ts", ...nextTypes, "**/*.mts", "**/*.ts", "**/*.tsx"] : ["next-env.d.ts", "**/*.mts", "**/*.ts", "**/*.tsx"];
+    includeTypes(userTsConfig, [], defaultInclude);
+    suggestedActions.push(`include was set to [${defaultInclude.map((type) => `'${type}'`).join(", ")}]`);
+  } else if (hasAppDir && !strictRouteTypes && Array.isArray(userTsConfig.include)) {
+    for (const type of includeTypes(userTsConfig, nextTypes, [])) {
+      suggestedActions.push(`include was updated to add '${type}'`);
+    }
+  }
+  if (hasAppDir) {
+    const plugins = [
+      ...Array.isArray(userTsConfig.plugins) ? userTsConfig.plugins : [],
+      ...Array.isArray(compilerOptions.plugins) ? compilerOptions.plugins : []
+    ];
+    if (!plugins.some((plugin) => plugin?.name === "next")) {
+      if (!Array.isArray(compilerOptions.plugins))
+        compilerOptions.plugins = [];
+      compilerOptions.plugins.push({ name: "next" });
+      suggestedActions.push(`plugins was updated to add { name: 'next' }`);
+    }
+    if (hasPagesDir && !compilerOptions.strict && !("strictNullChecks" in compilerOptions)) {
+      compilerOptions.strictNullChecks = true;
+      suggestedActions.push("strictNullChecks was set to true");
+    }
+  }
+  if (!("exclude" in userTsConfig)) {
+    userTsConfig.exclude = ["node_modules"];
+    suggestedActions.push(`exclude was set to ['node_modules']`);
+  }
+  if (suggestedActions.length === 0 && requiredActions.length === 0)
+    return;
+  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}
+`, tempDirectory);
+  if (isFirstTimeSetup) {
+    console.log(`
+We detected TypeScript in your project and created a tsconfig.json file for you.`);
+    return;
+  }
+  const lines = [
+    "",
+    `We detected TypeScript in your project and reconfigured your tsconfig.json file for you.${compilerOptions.strict ? "" : " Strict-mode is set to false by default."}`
+  ];
+  if (suggestedActions.length > 0) {
+    lines.push(`The following suggested values were added to your tsconfig.json. These values can be changed to fit your project's needs:
+`, ...suggestedActions.map((action) => `	- ${action}`), "");
+  }
+  if (requiredActions.length > 0) {
+    lines.push(`The following mandatory changes were made to your tsconfig.json:
+`, ...requiredActions.map((action) => `	- ${action}`), "");
+  }
+  console.log(lines.join(`
+`));
+}
+
+export { writeTsconfigDefaults };

package/dist/server/_chunks/index-bcws5eh2.js

@@ -0,0 +1,35 @@
+// @bun
+// src/compat/cache/handler.ts
+var handler;
+function setCacheHandler(instance) {
+  handler = instance;
+}
+function hasCacheHandler() {
+  return handler !== undefined;
+}
+async function cacheHandlerGet(key, ctx) {
+  if (!handler)
+    return;
+  try {
+    const entry = await handler.get(key, ctx);
+    return entry ?? undefined;
+  } catch {
+    return;
+  }
+}
+async function cacheHandlerSet(key, data, ctx) {
+  if (!handler)
+    return;
+  try {
+    await handler.set(key, data, ctx);
+  } catch {}
+}
+async function cacheHandlerRevalidateTag(tag) {
+  if (!handler?.revalidateTag)
+    return;
+  try {
+    await handler.revalidateTag(tag);
+  } catch {}
+}
+
+export { setCacheHandler, hasCacheHandler, cacheHandlerGet, cacheHandlerSet, cacheHandlerRevalidateTag };

package/dist/server/_chunks/index-bzd2ef7t.js

@@ -0,0 +1,10 @@
+// @bun
+// src/out-paths.ts
+import path from "path";
+var standaloneOutSegment = "standalone";
+function outCachePath(outPath) {
+  const owner = path.basename(outPath) === standaloneOutSegment ? path.dirname(outPath) : outPath;
+  return path.join(owner, "cache");
+}
+
+export { standaloneOutSegment, outCachePath };

package/dist/server/_chunks/index-cjgqs13g.js

@@ -0,0 +1,65 @@
+// @bun
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/utils/esbuild.ts
+var esbuild;
+function load() {
+  return esbuild ??= loadNative(() => __require("esbuild"));
+}
+var inFlight = 0;
+var stopWhenIdle = false;
+function track(promise) {
+  inFlight += 1;
+  return promise.finally(() => {
+    inFlight -= 1;
+    if (inFlight === 0 && stopWhenIdle) {
+      stopWhenIdle = false;
+      esbuild?.stop();
+    }
+  });
+}
+var serviceDied = (error) => error instanceof Error && (error.message.includes("The service is no longer running") || error.message.includes("The service was stopped"));
+var resetEpoch = 0;
+var serviceReset;
+async function withServiceRetry(run) {
+  const epoch = resetEpoch;
+  try {
+    return await track(run());
+  } catch (error) {
+    if (!serviceDied(error))
+      throw error;
+    if (epoch === resetEpoch) {
+      serviceReset ??= Promise.resolve(esbuild?.stop()).catch(() => {
+        return;
+      }).then(() => {
+        resetEpoch += 1;
+        serviceReset = undefined;
+      });
+      await serviceReset;
+    }
+    return track(run());
+  }
+}
+var build = (options) => withServiceRetry(() => load().build(options));
+var transform = (input, options) => withServiceRetry(() => load().transform(input, options));
+function warmEsbuildService() {
+  transform("", { loader: "js" }).catch(() => {
+    return;
+  });
+}
+function stopEsbuildService() {
+  if (!esbuild)
+    return;
+  if (inFlight > 0) {
+    stopWhenIdle = true;
+    return;
+  }
+  esbuild.stop();
+}
+
+export { build, transform, warmEsbuildService, stopEsbuildService };

package/dist/server/_chunks/index-ckkdpht5.js

@@ -0,0 +1,41 @@
+// @bun
+// src/compat/next/svgr.ts
+var svgAsComponent = false;
+function setSvgAsComponentEnabled(enabled) {
+  svgAsComponent = enabled;
+}
+function isSvgAsComponentEnabled() {
+  return svgAsComponent;
+}
+function webpackReferencesSvgr(config) {
+  return typeof config.webpack === "function" && String(config.webpack).includes("@svgr/webpack");
+}
+var XML_PROLOGUE = /^\uFEFF?\s*(?:<\?xml[^>]*\?>\s*)?(?:<!DOCTYPE[^>]*>\s*)?/i;
+var SVG_TAG = /^<svg([^>]*)>([\s\S]*)<\/svg>\s*$/i;
+var ATTR = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*"([^"]*)"|([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*'([^']*)'/g;
+function parseRootAttrs(raw) {
+  const attrs = {};
+  for (const match of raw.matchAll(ATTR)) {
+    const name = match[1] ?? match[3];
+    const value = match[2] ?? match[4] ?? "";
+    if (name)
+      attrs[name] = value;
+  }
+  return attrs;
+}
+function svgComponentModule(bytes) {
+  const text = new TextDecoder().decode(bytes).replace(XML_PROLOGUE, "").trim();
+  const match = SVG_TAG.exec(text);
+  const rootAttrs = match ? parseRootAttrs(match[1] ?? "") : {};
+  const inner = match ? match[2] : text;
+  return `import { h } from 'preact';
+const __pnextSvgAttrs = ${JSON.stringify(rootAttrs)};
+const __pnextSvgInner = ${JSON.stringify(inner)};
+function SvgComponent(props) {
+  return h('svg', { ...__pnextSvgAttrs, ...props, dangerouslySetInnerHTML: { __html: __pnextSvgInner } });
+}
+export default SvgComponent;
+`;
+}
+
+export { setSvgAsComponentEnabled, isSvgAsComponentEnabled, webpackReferencesSvgr, svgComponentModule };

package/dist/server/_chunks/index-cn86z041.js

@@ -0,0 +1,296 @@
+// @bun
+import {
+  readDirListing,
+  toPosixPath
+} from "./index-4da76t62.js";
+
+// src/routing/slots.ts
+import path from "path";
+import { safeDecode } from "../../../src/utils/decode.ts";
+var pageExtensions = ["tsx", "ts", "jsx", "js", "mjs"];
+var interceptionMarkers = ["(..)(..)", "(...)", "(..)", "(.)"];
+var interceptionLevels = {
+  "(.)": 0,
+  "(..)": 1,
+  "(..)(..)": 2,
+  "(...)": Number.POSITIVE_INFINITY
+};
+function interceptionMarkerOf(segment) {
+  return interceptionMarkers.find((marker) => segment.startsWith(marker) && segment.length > marker.length);
+}
+function interceptionMarkerLevels(marker) {
+  return interceptionLevels[marker];
+}
+function isSlotSegment(name) {
+  return name.startsWith("@");
+}
+function isGroupSegment(name) {
+  return name.startsWith("(") && name.endsWith(")") && !interceptionMarkerOf(name);
+}
+function slotConventionFile(dir, base) {
+  const { files } = readDirListing(dir);
+  for (const extension of pageExtensions) {
+    if (files.has(`${base}.${extension}`))
+      return path.join(dir, `${base}.${extension}`);
+  }
+  return;
+}
+function childDirectories(dir) {
+  return readDirListing(dir).dirs;
+}
+function slotDirectoriesIn(dir) {
+  return childDirectories(dir).filter(isSlotSegment).map((name) => path.join(dir, name));
+}
+function consumedSegments(appPath, dir) {
+  const relative = path.relative(appPath, dir);
+  if (relative.startsWith(".."))
+    return 0;
+  let consumed = 0;
+  for (const name of relative.split(path.sep).filter(Boolean)) {
+    if (isGroupSegment(name) || isSlotSegment(name))
+      continue;
+    const marker = interceptionMarkerOf(name);
+    const bare = marker ? name.slice(marker.length) : name;
+    if (/^\[\[?\.\.\./.test(bare))
+      return Number.POSITIVE_INFINITY;
+    consumed += 1;
+  }
+  return consumed;
+}
+function matchSegments(dir, segments, options = {}, params = {}, dirs = []) {
+  const children = childDirectories(dir);
+  const groups = children.filter(isGroupSegment);
+  if (segments.length === 0) {
+    const page = slotConventionFile(dir, "page");
+    if (page)
+      return { file: page, dirs, params };
+    for (const group of groups) {
+      const match = matchSegments(path.join(dir, group), [], options, params, [...dirs, group]);
+      if (match)
+        return match;
+    }
+    for (const name of children) {
+      const param = optionalCatchAllName(bareName(name, options));
+      if (!param)
+        continue;
+      const match = matchSegments(path.join(dir, name), [], options, { ...params, [param]: [] }, [
+        ...dirs,
+        name
+      ]);
+      if (match)
+        return match;
+    }
+    if (options.markersAsSegments && (slotConventionFile(dir, "layout") || children.some(isSlotSegment))) {
+      return { dirs, params };
+    }
+    return null;
+  }
+  const [head, ...rest] = segments;
+  for (const name of children) {
+    if (bareName(name, options) !== head)
+      continue;
+    const match = matchSegments(path.join(dir, name), rest, options, params, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  for (const group of groups) {
+    const match = matchSegments(path.join(dir, group), segments, options, params, [...dirs, group]);
+    if (match)
+      return match;
+  }
+  for (const name of children) {
+    const param = dynamicParamName(bareName(name, options));
+    if (!param)
+      continue;
+    const match = matchSegments(path.join(dir, name), rest, options, { ...params, [param]: safeDecode(head) }, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  for (const name of children) {
+    const bare = bareName(name, options);
+    const param = catchAllName(bare) ?? optionalCatchAllName(bare);
+    if (!param)
+      continue;
+    const match = matchSegments(path.join(dir, name), [], options, { ...params, [param]: segments.map(safeDecode) }, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  return null;
+}
+function bareName(name, options) {
+  if (isSlotSegment(name))
+    return "\x00";
+  const marker = interceptionMarkerOf(name);
+  if (!marker)
+    return name;
+  return options.markersAsSegments ? name.slice(marker.length) : "\x00";
+}
+function dynamicParamName(name) {
+  const match = /^\[([^\].]+)\]$/.exec(name);
+  return match?.[1];
+}
+function catchAllName(name) {
+  const match = /^\[\.\.\.([^\]]+)\]$/.exec(name);
+  return match?.[1];
+}
+function optionalCatchAllName(name) {
+  const match = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(name);
+  return match?.[1];
+}
+function childrenDefaultFile(dir, segments) {
+  let current = dir;
+  let best = slotConventionFile(current, "default");
+  for (const segment of segments) {
+    const next = childSegmentDir(current, segment);
+    if (!next)
+      break;
+    current = next;
+    best = slotConventionFile(current, "default") ?? best;
+  }
+  return best;
+}
+function childSegmentDir(dir, segment) {
+  const children = childDirectories(dir);
+  if (children.includes(segment))
+    return path.join(dir, segment);
+  for (const group of children.filter(isGroupSegment)) {
+    const nested = childSegmentDir(path.join(dir, group), segment);
+    if (nested)
+      return nested;
+  }
+  const dynamic = children.find((name) => dynamicParamName(name));
+  if (dynamic)
+    return path.join(dir, dynamic);
+  return;
+}
+function slotInterceptorUnits(appPath, slotDir) {
+  const owner = routeTokensForDir(appPath, path.dirname(slotDir));
+  if (!owner)
+    return [];
+  const units = [];
+  collectInterceptorUnits(slotDir, owner, [], units);
+  return units;
+}
+function collectInterceptorUnits(dir, owner, inner, units) {
+  for (const name of childDirectories(dir)) {
+    const child = path.join(dir, name);
+    if (isSlotSegment(name) || isGroupSegment(name)) {
+      collectInterceptorUnits(child, owner, inner, units);
+      continue;
+    }
+    const marker = interceptionMarkerOf(name);
+    if (marker) {
+      const bare = name.slice(marker.length);
+      const levels = interceptionLevels[marker];
+      const context = [...owner, ...inner];
+      const kept = levels === Number.POSITIVE_INFINITY ? [] : context.slice(0, Math.max(0, context.length - levels));
+      const target = [...kept, segmentToken(bare)];
+      units.push({
+        dir: child,
+        targetSegments: target.map((token) => token.route),
+        targetPattern: target.map((token) => token.pattern).join("/"),
+        params: target.filter((token) => token.param).map((token) => ({ name: token.param, catchAll: Boolean(token.catchAll) })),
+        catchAllTail: Boolean(target[target.length - 1]?.catchAll)
+      });
+      continue;
+    }
+    collectInterceptorUnits(child, owner, [...inner, segmentToken(name)], units);
+  }
+}
+function routeTokensForDir(appPath, dir) {
+  const relative = path.relative(appPath, dir);
+  if (relative.startsWith(".."))
+    return;
+  let tokens = [];
+  for (const name of toPosixPath(relative).split("/").filter(Boolean)) {
+    if (isGroupSegment(name) || isSlotSegment(name))
+      continue;
+    const marker = interceptionMarkerOf(name);
+    if (marker) {
+      const levels = interceptionLevels[marker];
+      tokens = levels === Number.POSITIVE_INFINITY ? [] : tokens.slice(0, Math.max(0, tokens.length - levels));
+      tokens.push(segmentToken(name.slice(marker.length)));
+      continue;
+    }
+    tokens.push(segmentToken(name));
+  }
+  return tokens;
+}
+function segmentToken(name) {
+  const optional = optionalCatchAllName(name);
+  if (optional)
+    return { route: `:${optional}*`, pattern: "(.*)", param: optional, catchAll: true };
+  const catchAll = catchAllName(name);
+  if (catchAll)
+    return { route: `:${catchAll}*`, pattern: "(.*)", param: catchAll, catchAll: true };
+  const param = dynamicParamName(name);
+  if (param)
+    return { route: `:${param}`, pattern: "([^/]+)", param };
+  return { route: name, pattern: escapeRegex(name) };
+}
+function matchSlotInterceptor(appPath, slotDir, pathname) {
+  const segments = pathnameSegments(pathname);
+  const markerOwner = markerOwnerTokens(appPath, slotDir);
+  if (markerOwner) {
+    const params = matchTargetTokens(markerOwner, pathname);
+    if (params) {
+      const rest = markerOwner.at(-1)?.catchAll ? [] : segments.slice(markerOwner.length);
+      const inner = matchSegments(slotDir, rest, { markersAsSegments: true }, params, []);
+      if (inner)
+        return inner;
+    }
+  }
+  const units = slotInterceptorUnits(appPath, slotDir).sort((a, b) => Number(a.catchAllTail) - Number(b.catchAllTail) || b.targetSegments.length - a.targetSegments.length || a.params.length - b.params.length);
+  for (const unit of units) {
+    const regex = new RegExp(`^/${unit.targetPattern}(?:/(.*))?$`);
+    const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
+    if (!match)
+      continue;
+    const params = {};
+    unit.params.forEach((param, index) => {
+      const value = match[index + 1] ?? "";
+      params[param.name] = param.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
+    });
+    const rest = unit.catchAllTail ? [] : segments.slice(unit.targetSegments.length);
+    const inner = matchSegments(unit.dir, rest, { markersAsSegments: true }, params, []);
+    if (inner) {
+      return {
+        file: inner.file,
+        dirs: [path.basename(unit.dir), ...inner.dirs],
+        params: inner.params
+      };
+    }
+  }
+  return null;
+}
+function markerOwnerTokens(appPath, slotDir) {
+  const relative = path.relative(appPath, slotDir);
+  if (relative.startsWith(".."))
+    return null;
+  const segments = toPosixPath(relative).split("/").filter(Boolean);
+  const markerIndex = segments.findIndex((segment) => Boolean(interceptionMarkerOf(segment)));
+  if (markerIndex === -1)
+    return null;
+  return routeTokensForDir(appPath, path.join(appPath, ...segments.slice(0, markerIndex + 1))) ?? null;
+}
+function matchTargetTokens(tokens, pathname) {
+  const pattern = tokens.map((token) => token.pattern).join("/");
+  const regex = new RegExp(`^/${pattern}(?:/.*)?$`);
+  const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
+  if (!match)
+    return null;
+  const params = {};
+  tokens.filter((token) => token.param).forEach((token, index) => {
+    const value = match[index + 1] ?? "";
+    params[token.param] = token.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
+  });
+  return params;
+}
+function pathnameSegments(pathname) {
+  return pathname.split("?")[0].split("/").filter(Boolean);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { interceptionMarkerOf, interceptionMarkerLevels, isSlotSegment, isGroupSegment, slotConventionFile, slotDirectoriesIn, consumedSegments, matchSegments, childrenDefaultFile, matchSlotInterceptor, pathnameSegments };