@wular/coder 0.3.17 → 0.4.0

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-7DCNCW6O.js

@@ -0,0 +1,722 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  canonicalTrailingSlashPath,
+  devServerModuleHref,
+  getBasePathPrefix,
+  isBuildAssetPathname,
+  registerServerRuntime
+} from "./chunk-E6IXL2NJ.js";
+import {
+  pathToFileHref,
+  runWithRequest
+} from "./chunk-JESFYECC.js";
+import {
+  safeDecode
+} from "./chunk-JRPJM2XY.js";
+import {
+  getProxyExtensions,
+  getProxyResponseProtocol,
+  withRouteRuntime
+} from "./chunk-4P5CMIYT.js";
+import {
+  __require,
+  loadNative
+} from "./chunk-3UPROT2C.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/proxy.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/api/server.ts
+var nextResponseMetaSymbol = Symbol.for("pnext.nextResponse");
+var _a;
+var NextResponse = class _NextResponse extends (_a = Response, nextResponseMetaSymbol, _a) {
+  constructor(body, init) {
+    super(body, init);
+    this.cookies = responseCookies(this.headers);
+  }
+  static json(body, init) {
+    const headers = new Headers(init?.headers);
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    return new _NextResponse(JSON.stringify(body), {
+      ...init,
+      headers
+    });
+  }
+  static next(init) {
+    const response = new _NextResponse(null, init);
+    response.headers.set(getProxyResponseProtocol().nextHeader, "1");
+    defineMeta(response, { kind: "next", ...requestMeta(init) });
+    return response;
+  }
+  static rewrite(url, init) {
+    const response = new _NextResponse(null, init);
+    response.headers.set(getProxyResponseProtocol().rewriteHeader, String(url));
+    defineMeta(response, { kind: "rewrite", url: String(url), ...requestMeta(init) });
+    return response;
+  }
+  static redirect(url, init = 307) {
+    const responseInit = typeof init === "number" ? { status: init } : init;
+    const headers = new Headers(responseInit.headers);
+    headers.set("location", String(url));
+    return new _NextResponse(null, {
+      ...responseInit,
+      status: responseInit.status ?? 307,
+      headers
+    });
+  }
+};
+function toNextRequest(request) {
+  const nextRequest = request;
+  if (nextRequest.cookies && nextRequest.nextUrl) return request;
+  Object.defineProperties(request, {
+    cookies: {
+      configurable: true,
+      enumerable: true,
+      value: requestCookies(request.headers)
+    },
+    nextUrl: {
+      configurable: true,
+      enumerable: true,
+      value: createNextUrl(request.url)
+    }
+  });
+  return request;
+}
+function nextResponseMeta(response) {
+  const meta = response[nextResponseMetaSymbol];
+  if (meta) return meta;
+  const protocol = getProxyResponseProtocol();
+  const rewrite = response.headers.get(protocol.rewriteHeader);
+  if (rewrite) return { kind: "rewrite", url: rewrite };
+  if (response.headers.get(protocol.nextHeader)) return { kind: "next" };
+  return void 0;
+}
+function copyMiddlewareHeaders(from, to) {
+  const internalHeaders = proxyInternalHeaders();
+  from.headers.forEach((value, key) => {
+    if (internalHeaders.has(key) || key === "content-length" || key === "set-cookie") return;
+    if (key === "vary") mergeVaryInto(to.headers, value);
+    else to.headers.set(key, value);
+  });
+  const middlewareCookies = getSetCookie(from.headers);
+  if (middlewareCookies.length === 0) return;
+  const responseCookies2 = getSetCookie(to.headers);
+  to.headers.delete("set-cookie");
+  for (const cookie of middlewareCookies) to.headers.append("set-cookie", cookie);
+  for (const cookie of responseCookies2) to.headers.append("set-cookie", cookie);
+}
+function forwardMiddlewareRequestHeaders(from, request) {
+  const additions = [];
+  const internalHeaders = proxyInternalHeaders();
+  from.headers.forEach((value, key) => {
+    if (internalHeaders.has(key) || key === "content-length" || key === "set-cookie") return;
+    additions.push([key, value]);
+  });
+  if (additions.length === 0) return request;
+  const headers = new Headers(request.headers);
+  for (const [key, value] of additions) headers.set(key, value);
+  return new Request(request, { headers });
+}
+function proxyInternalHeaders() {
+  const protocol = getProxyResponseProtocol();
+  return /* @__PURE__ */ new Set([protocol.nextHeader, protocol.rewriteHeader]);
+}
+function mergeVaryInto(headers, value) {
+  const existing = headers.get("vary");
+  const seen = new Set(
+    (existing ?? "").split(",").map((token) => token.trim().toLowerCase()).filter(Boolean)
+  );
+  const merged = existing ? existing.split(",").map((token) => token.trim()).filter(Boolean) : [];
+  for (const token of value.split(",").map((part) => part.trim()).filter(Boolean)) {
+    if (seen.has(token.toLowerCase())) continue;
+    seen.add(token.toLowerCase());
+    merged.push(token);
+  }
+  if (merged.length > 0) headers.set("vary", merged.join(", "));
+}
+function defineMeta(response, meta) {
+  Object.defineProperty(response, nextResponseMetaSymbol, {
+    configurable: false,
+    enumerable: false,
+    value: meta
+  });
+}
+function requestMeta(init) {
+  return init?.request?.headers ? { requestHeaders: new Headers(init.request.headers) } : {};
+}
+function createNextUrl(url) {
+  const nextUrl = new URL(url);
+  Object.defineProperty(nextUrl, "clone", {
+    configurable: true,
+    enumerable: false,
+    value: () => createNextUrl(nextUrl.href)
+  });
+  nextUrl.basePath = getBasePathPrefix();
+  nextUrl.locale = getProxyExtensions().locale(nextUrl);
+  return nextUrl;
+}
+function requestCookies(headers) {
+  let cookies = parseCookies(headers.get("cookie") ?? "");
+  const sync = () => {
+    const header = requestCookieHeader(cookies);
+    if (header) headers.set("cookie", header);
+    else headers.delete("cookie");
+  };
+  return {
+    get(name) {
+      return cookies.find((cookie) => cookie.name === name);
+    },
+    getAll(name) {
+      return name ? cookies.filter((cookie) => cookie.name === name) : [...cookies];
+    },
+    has(name) {
+      return cookies.some((cookie) => cookie.name === name);
+    },
+    set(name, value) {
+      cookies = [...cookies.filter((cookie) => cookie.name !== name), { name, value }];
+      sync();
+      return this;
+    },
+    delete(name) {
+      const existed = cookies.some((cookie) => cookie.name === name);
+      cookies = cookies.filter((cookie) => cookie.name !== name);
+      sync();
+      return existed;
+    },
+    clear() {
+      cookies = [];
+      sync();
+    }
+  };
+}
+function responseCookies(headers) {
+  return {
+    set(nameOrOptions, value, options = {}) {
+      const cookie = typeof nameOrOptions === "string" ? { ...options, name: nameOrOptions, value: value ?? "" } : nameOrOptions;
+      headers.append("set-cookie", serializeCookie(cookie.name, cookie.value, cookie));
+      return this;
+    },
+    delete(name) {
+      headers.append("set-cookie", serializeCookie(name, "", { maxAge: 0, path: "/" }));
+      return this;
+    }
+  };
+}
+function serializeCookie(name, value, options) {
+  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+  parts.push(`Path=${options.path ?? "/"}`);
+  if (options.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
+  if (options.httpOnly) parts.push("HttpOnly");
+  if (options.secure) parts.push("Secure");
+  if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
+  return parts.join("; ");
+}
+function parseCookies(header) {
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const [key = "", ...rest] = part.split("=");
+    return { name: safeDecode(key), value: safeDecode(rest.join("=")) };
+  });
+}
+function requestCookieHeader(cookies) {
+  return cookies.map((cookie) => `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`).join("; ");
+}
+function getSetCookie(headers) {
+  const withSetCookie = headers;
+  return withSetCookie.getSetCookie?.() ?? [];
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/proxy.ts
+var parseSync = (...args) => (
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  loadNative(() => __require("/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/oxc-parser@0.142.0/node_modules/oxc-parser/src-js/index.js")).parseSync(...args)
+);
+var proxyRewriteObserver;
+function setProxyRewriteObserver(observer) {
+  proxyRewriteObserver = observer;
+}
+var proxyRunObserver;
+function setProxyRunObserver(observer) {
+  proxyRunObserver = observer;
+}
+function wrapMiddleware(request, fn) {
+  return proxyRunObserver ? proxyRunObserver(request, fn) : fn();
+}
+var proxyExtensions = [".ts", ".tsx", ".js", ".jsx", ".mts"];
+function findProxyFile(config) {
+  return findProxyFiles(config)[0];
+}
+function proxyExternalLoadTarget(file) {
+  return path.basename(file).startsWith("proxy.") ? "client-ssr" : "edge";
+}
+function findProxyFiles(config, names = getProxyExtensions().names) {
+  const files = [];
+  for (const base of proxyBases(config)) {
+    for (const name of names) {
+      for (const extension of proxyExtensions) {
+        const file = path.join(base, `${name}${extension}`);
+        if (existsSync(file)) files.push(file);
+      }
+    }
+  }
+  return files;
+}
+function createProxyRunner(config, runnerOptions = {}) {
+  const file = findProxyFile(config);
+  registerServerRuntime(config, file ? [file] : []);
+  let moduleKey;
+  let modulePromise;
+  let matchers;
+  function proxyModule(options) {
+    const key = proxyModuleKey(options);
+    if (key !== moduleKey) {
+      moduleKey = key;
+      modulePromise = importProxyModule(config, file, options, runnerOptions);
+      matchers = void 0;
+    }
+    return modulePromise ??= importProxyModule(config, file, options, runnerOptions);
+  }
+  const runner = async (request, options = {}) => {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith("/__pnext/") || !config.compat?.next && isBuildAssetPathname(url.pathname)) {
+      return void 0;
+    }
+    if (!file) return void 0;
+    if (!matchers && proxyMatcherGateEnabled()) {
+      const staticMatchers = staticProxyMatchers(file);
+      if (staticMatchers && !matchesProxy(staticMatchers, url, request)) return void 0;
+    }
+    const module = await proxyModule(options);
+    matchers ??= proxyMatchers(module.config);
+    if (!matchesProxy(matchers, url, request)) return void 0;
+    request = await bufferProxyRequestBody(request, url.pathname);
+    const handlerExport = getProxyExtensions().handlerExport(module);
+    if (typeof handlerExport !== "function") throw new Error(`${file} must export proxy or default`);
+    const handler = handlerExport;
+    const handlerRequest = getProxyExtensions().skipUrlNormalize() ? request : stripFlightHeaders(stripRscUnionQuery(request));
+    const nextRequest = toNextRequest(handlerRequest);
+    const proxyResponseHeaders = new Headers();
+    let response = await runWithRequest(
+      nextRequest,
+      () => withRouteRuntime(
+        "edge",
+        () => wrapMiddleware(
+          nextRequest,
+          () => handler(nextRequest, {
+            waitUntil(promise) {
+              void promise;
+            }
+          })
+        )
+      ),
+      {},
+      { responseHeaders: proxyResponseHeaders }
+    );
+    const scopedCookies = getSetCookie(proxyResponseHeaders);
+    if (scopedCookies.length > 0) {
+      if (!response) response = NextResponse.next();
+      for (const cookie of scopedCookies) response.headers.append("set-cookie", cookie);
+    }
+    if (!response) return { request };
+    response = await normalizeRedirectResponse(response, url, request.method, config);
+    const meta = nextResponseMeta(response);
+    if (!meta) return response;
+    const forwardedRequest = forwardMiddlewareRequestHeaders(
+      response,
+      applyProxyCookies(applyRequestOverride(request, meta.requestHeaders), response)
+    );
+    if (meta.kind === "rewrite" && meta.url) {
+      let rewritten = rewriteRequest(forwardedRequest, meta.url);
+      const rewrittenUrl = new URL(rewritten.url);
+      if (rewrittenUrl.origin !== url.origin) {
+        const rscHash = url.searchParams.get("_rsc");
+        if (rscHash !== null && !rewrittenUrl.searchParams.has("_rsc")) {
+          rewrittenUrl.searchParams.set("_rsc", rscHash);
+          rewritten = new Request(rewrittenUrl, rewritten);
+        }
+        getProxyExtensions().onExternalRewrite(rewritten);
+        const externalHeaders = new Headers(rewritten.headers);
+        externalHeaders.delete("host");
+        const external = await fetch(new Request(rewritten, { headers: externalHeaders }));
+        const headers = new Headers(external.headers);
+        headers.delete("content-encoding");
+        headers.delete("content-length");
+        headers.delete("transfer-encoding");
+        const proxied = new Response(external.body, {
+          status: external.status,
+          statusText: external.statusText,
+          headers
+        });
+        copyMiddlewareHeaders(response, proxied);
+        return proxied;
+      }
+      if (rewrittenUrl.origin === url.origin) {
+        proxyRewriteObserver?.(url, rewrittenUrl);
+        if (request.headers.get("x-nextjs-data") === "1") {
+          response.headers.set("x-nextjs-rewrite", rewrittenUrl.href);
+        }
+      }
+      return { request: rewritten, response };
+    }
+    return { request: forwardedRequest, response };
+  };
+  runner.warm = (options = {}) => {
+    if (!file) return;
+    void proxyModule(options).catch(() => void 0);
+  };
+  return runner;
+}
+async function normalizeRedirectResponse(response, requestUrl, method, config) {
+  if (response.status < 300 || response.status >= 400) return response;
+  const location = response.headers.get("location");
+  if (!location) return response;
+  let target;
+  try {
+    target = new URL(location, requestUrl);
+  } catch {
+    return response;
+  }
+  if (target.origin === requestUrl.origin) {
+    if (!config.skipTrailingSlashRedirect && config.trailingSlash) {
+      target.pathname = canonicalTrailingSlashPath(target.pathname, true);
+    }
+  }
+  const destination = target.origin === requestUrl.origin ? `${target.pathname}${target.search}${target.hash}` : target.href;
+  const headers = new Headers(response.headers);
+  headers.set("location", destination);
+  const body = method.toUpperCase() === "HEAD" || response.body === null ? null : await response.arrayBuffer();
+  const synthesizeDestination = method.toUpperCase() !== "HEAD" && (!body || body.byteLength === 0);
+  if (synthesizeDestination) headers.delete("content-length");
+  return new Response(synthesizeDestination ? destination : body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function formatBodyLimit(bytes) {
+  if (bytes >= 1024 * 1024 && bytes % (1024 * 1024) === 0) return `${bytes / (1024 * 1024)}MB`;
+  if (bytes >= 1024 && bytes % 1024 === 0) return `${bytes / 1024}KB`;
+  return `${bytes}B`;
+}
+async function bufferProxyRequestBody(request, pathname) {
+  if (request.method === "GET" || request.method === "HEAD" || !request.body) return request;
+  const limit = getProxyExtensions().clientMaxBodySize();
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  const reader = request.body.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!truncated && total + value.byteLength > limit) {
+      const keep = limit - total;
+      if (keep > 0) chunks.push(value.subarray(0, keep));
+      total = limit;
+      truncated = true;
+      continue;
+    }
+    if (!truncated) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  if (truncated) {
+    console.warn(`Request body exceeded ${formatBodyLimit(limit)} for ${pathname}`);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const headers = new Headers(request.headers);
+  headers.set("content-length", String(total));
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body,
+    // @ts-expect-error Bun/Node fetch option for streaming request bodies.
+    duplex: "half"
+  });
+}
+function applyProxyResponse(response, proxyResponse) {
+  if (proxyResponse) copyMiddlewareHeaders(proxyResponse, response);
+  return response;
+}
+async function importProxyModule(config, file, options, runnerOptions) {
+  const href = options.dev ? await devServerModuleHref(config, file, options.devImportVersion ?? "dev", {
+    conditionTarget: "edge",
+    externalLoadTarget: proxyExternalLoadTarget(file),
+    reactServerLayer: true
+  }) : runnerOptions.compiledModuleHref ?? pathToFileHref(file);
+  return import(href);
+}
+function proxyBases(config) {
+  return config.appPath === path.join(config.root, "src", "app") ? [path.join(config.root, "src"), config.root] : [config.root];
+}
+function proxyMatcherGateEnabled() {
+  return process.env.PNEXT_PROXY_MATCHER_GATE !== "0";
+}
+var staticMatcherCache = /* @__PURE__ */ new Map();
+function staticProxyMatchers(file) {
+  let key;
+  try {
+    const stats = statSync(file);
+    key = `${stats.size}:${stats.mtimeMs}`;
+  } catch {
+    return void 0;
+  }
+  const cached = staticMatcherCache.get(file);
+  if (cached?.key === key) return cached.matchers;
+  let matchers;
+  try {
+    const config = staticProxyConfig(file, readFileSync(file, "utf8"));
+    if (config) matchers = proxyMatchers(config);
+  } catch {
+    matchers = void 0;
+  }
+  staticMatcherCache.set(file, { key, matchers });
+  return matchers;
+}
+function staticProxyConfig(file, source) {
+  const result = parseSync(file, source, { lang: parserLang(file) });
+  if (result.errors.length > 0) return void 0;
+  for (const statement of result.program.body) {
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const declaration = statement.declaration;
+    if (declaration?.type !== "VariableDeclaration") continue;
+    for (const declarator of declaration.declarations ?? []) {
+      if (declarator.id?.type !== "Identifier" || declarator.id.name !== "config") continue;
+      const value = staticValue(declarator.init);
+      return isProxyConfigShape(value) ? value : void 0;
+    }
+  }
+  return void 0;
+}
+function parserLang(file) {
+  const ext = path.extname(file);
+  if (ext === ".tsx") return "tsx";
+  if (ext === ".jsx") return "jsx";
+  return ext === ".js" || ext === ".mjs" ? "js" : "ts";
+}
+function staticValue(node) {
+  if (!node) return void 0;
+  switch (node.type) {
+    // `… as const` / `… satisfies ProxyConfig` wrap the literal, they never change it.
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      return staticValue(node.expression);
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value === null ? void 0 : node.value;
+    case "TemplateLiteral":
+      return node.expressions?.length === 0 ? node.quasis?.[0]?.value?.cooked ?? void 0 : void 0;
+    case "ArrayExpression": {
+      const items = [];
+      for (const element of node.elements ?? []) {
+        const value = staticValue(element);
+        if (value === void 0) return void 0;
+        items.push(value);
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const object = {};
+      for (const property of node.properties ?? []) {
+        if (property.type !== "Property" && property.type !== "ObjectProperty") return void 0;
+        if (property.computed) return void 0;
+        const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+        if (typeof key !== "string") return void 0;
+        const value = staticValue(property.value);
+        if (value === void 0) return void 0;
+        object[key] = value;
+      }
+      return object;
+    }
+    default:
+      return void 0;
+  }
+}
+function isProxyConfigShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const matcher = value.matcher;
+  if (matcher === void 0) return true;
+  const items = Array.isArray(matcher) ? matcher : [matcher];
+  return items.every((item) => {
+    if (typeof item === "string") return true;
+    if (typeof item !== "object" || item === null) return false;
+    const { source, has, missing } = item;
+    if (typeof source !== "string") return false;
+    return [has, missing].every(
+      (list) => list === void 0 || Array.isArray(list) && list.every(isConditionShape)
+    );
+  });
+}
+function isConditionShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { type, key, value: expected } = value;
+  if (type !== "header" && type !== "query" && type !== "cookie" && type !== "host") return false;
+  if (key !== void 0 && typeof key !== "string") return false;
+  return expected === void 0 || typeof expected === "string";
+}
+function proxyMatchers(config) {
+  const matcher = config?.matcher;
+  if (!matcher) return [{ regex: /.*/ }];
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.map((item) => ({
+    regex: matcherRegex(matcherSource(item)),
+    ...typeof item === "object" && item.has ? { has: item.has } : {},
+    ...typeof item === "object" && item.missing ? { missing: item.missing } : {}
+  }));
+}
+function matchesProxy(matchers, url, request) {
+  const decoded = decodePathSeparators(url.pathname);
+  return matchers.some(
+    (matcher) => (matcher.regex.test(url.pathname) || matcher.regex.test(decoded)) && matchesConditions(matcher, url, request)
+  );
+}
+function matchesConditions(matcher, url, request) {
+  if (matcher.has && !matcher.has.every((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  if (matcher.missing?.some((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  return true;
+}
+function hasCondition(condition, url, request) {
+  const actual = conditionValue(condition, url, request);
+  if (actual === null) return false;
+  if (condition.value === void 0) return true;
+  try {
+    return new RegExp(`^${condition.value}$`).test(actual);
+  } catch {
+    return condition.value === actual;
+  }
+}
+function conditionValue(condition, url, request) {
+  switch (condition.type) {
+    case "header":
+      return condition.key ? request.headers.get(condition.key) : null;
+    case "query":
+      return condition.key ? url.searchParams.get(condition.key) : null;
+    case "cookie": {
+      if (!condition.key) return null;
+      const cookie = parseCookies(request.headers.get("cookie") ?? "").find(
+        (item) => item.name === condition.key
+      );
+      return cookie ? cookie.value : null;
+    }
+    case "host":
+      return url.host;
+    default:
+      return null;
+  }
+}
+function decodePathSeparators(pathname) {
+  return pathname.replace(/%2f/gi, "/");
+}
+function matcherSource(matcher) {
+  return typeof matcher === "string" ? matcher : matcher.source;
+}
+function matcherRegex(matcher) {
+  return new RegExp(`^${matcherPattern(matcher)}$`);
+}
+function matcherPattern(matcher) {
+  if (matcher.includes("(")) return matcher;
+  if (matcher === "/") return "/";
+  let source = "";
+  for (const segment of matcher.split("/").filter(Boolean)) {
+    if (/^:[^/]+\*$/.test(segment)) {
+      source += "(?:/.*)?";
+    } else if (/^:[^/]+$/.test(segment)) {
+      source += "/[^/]+";
+    } else {
+      source += `/${escapeRegex(segment)}`;
+    }
+  }
+  return source || "/";
+}
+function rewriteRequest(request, url) {
+  return new Request(new URL(url, request.url), request);
+}
+function stripRscUnionQuery(request) {
+  const url = new URL(request.url);
+  if (!url.searchParams.has("_rsc")) return request;
+  url.searchParams.delete("_rsc");
+  return new Request(url, request);
+}
+var FLIGHT_HEADERS = [
+  "rsc",
+  "next-router-state-tree",
+  "next-router-prefetch",
+  "next-hmr-refresh",
+  "next-router-segment-prefetch"
+];
+function stripFlightHeaders(request) {
+  if (!FLIGHT_HEADERS.some((header) => request.headers.has(header))) return request;
+  const headers = new Headers(request.headers);
+  for (const header of FLIGHT_HEADERS) headers.delete(header);
+  return new Request(request, { headers });
+}
+function applyRequestOverride(request, headers) {
+  if (!headers) return request;
+  return new Request(request, { headers });
+}
+function applyProxyCookies(request, response) {
+  const setCookies = getSetCookie(response.headers);
+  if (setCookies.length === 0) return request;
+  const cookies = parseCookies(request.headers.get("cookie") ?? "");
+  for (const header of setCookies) {
+    const cookie = parseSetCookie(header);
+    if (!cookie) continue;
+    const index = cookies.findIndex((item) => item.name === cookie.name);
+    if (cookie.deleted) {
+      if (index !== -1) cookies.splice(index, 1);
+      continue;
+    }
+    if (index === -1) cookies.push({ name: cookie.name, value: cookie.value });
+    else cookies[index] = { name: cookie.name, value: cookie.value };
+  }
+  const headers = new Headers(request.headers);
+  const cookieHeader = requestCookieHeader(cookies);
+  if (cookieHeader) headers.set("cookie", cookieHeader);
+  else headers.delete("cookie");
+  return new Request(request, { headers });
+}
+function parseSetCookie(header) {
+  const [pair = "", ...attributes] = header.split(";").map((part) => part.trim());
+  const [name = "", ...valueParts] = pair.split("=");
+  if (!name) return void 0;
+  const deleted = attributes.some((attribute) => /^max-age=0$/i.test(attribute));
+  return { name: decodeCookiePart(name), value: decodeCookiePart(valueParts.join("=")), deleted };
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function proxyModuleKey(options) {
+  return options.dev ? `dev:${options.devImportVersion ?? "dev"}` : "prod";
+}
+
+export {
+  toNextRequest,
+  nextResponseMeta,
+  setProxyRewriteObserver,
+  setProxyRunObserver,
+  findProxyFile,
+  proxyExternalLoadTarget,
+  findProxyFiles,
+  createProxyRunner,
+  applyProxyResponse
+};