@wular/coder 0.4.1 → 0.4.3

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-4P5CMIYT.js

@@ -1,1582 +0,0 @@
-import { createRequire as __coderRequire } from "node:module";
-const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
-import { createRequire as __pnextCreateRequire } from "node:module";
-const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
-import {
-  __require,
-  loadNative
-} from "./chunk-3UPROT2C.js";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/code.ts
-function escapeRegex(value) {
-  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-}
-function specifierSniffTokens(keys) {
-  const heads = [
-    ...new Set(
-      [...keys].map((key) => {
-        const head = key.split("/").slice(0, key.startsWith("@") ? 2 : 1).join("/");
-        return head.replace(/\*.*$/, "");
-      })
-    )
-  ];
-  return heads.filter((head) => !heads.some((other) => other !== head && head.startsWith(other)));
-}
-function uniqueIdentifier(source, base, ...used) {
-  const usedNames = new Set(used);
-  let name = base;
-  let index = 0;
-  while (source.includes(name) || usedNames.has(name)) {
-    index += 1;
-    name = `${base}${index}`;
-  }
-  return name;
-}
-function isIdentifier(value) {
-  return /^[A-Za-z_$][\w$]*$/.test(value);
-}
-function esbuildEntryExportNames(code) {
-  const scope = entryCommonJsScope(code);
-  const assignments = [
-    ...scope.matchAll(
-      /module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*\s*\(\s*)?([A-Za-z_$][\w$]*)\s*\)?\s*[;\n]/g
-    )
-  ];
-  const entryVar = assignments.at(-1)?.[1];
-  if (!entryVar) return [];
-  const exportCall = new RegExp(
-    `[A-Za-z_$][\\w$]*\\(\\s*${escapeRegex(entryVar)}\\s*,\\s*\\{([\\s\\S]*?)\\}\\s*\\)`
-  ).exec(scope);
-  if (!exportCall?.[1]) return [];
-  return [
-    ...exportCall[1].matchAll(
-      /(?:^|,)\s*(?:["']([^"']+)["']|([A-Za-z_$][\w$]*))\s*:\s*\(\s*\)\s*=>/g
-    )
-  ].map((match) => match[1] ?? match[2]).filter((name) => Boolean(name && isIdentifier(name)));
-}
-function entryCommonJsScope(code) {
-  const wrapper = /(^|\n)export default ([A-Za-z_$][\w$]*)\(\)/.exec(code)?.[2];
-  if (!wrapper) return code;
-  const start = code.lastIndexOf(`var ${wrapper} = `);
-  return start === -1 ? code : code.slice(start);
-}
-function stripComments(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/extensions.ts
-var { Bun: bun } = globalThis;
-function createExtensionHost() {
-  return {
-    compatMode: createCompatModeExtensions(),
-    render: createRenderExtensions(),
-    request: createRequestExtensions(),
-    runtime: createRuntimeExtensions(),
-    build: createBuildExtensions(),
-    routing: createRoutingExtensions(),
-    proxy: createProxyExtensions(),
-    proxyResponse: createProxyResponseProtocol(),
-    routerProtocol: createRouterProtocolExtensions(),
-    bundler: createBundlerExtensions(),
-    importAlias: createImportAliasExtensions(),
-    asset: createAssetExtensions(),
-    loadable: []
-  };
-}
-var activeHost = createExtensionHost();
-var resetHandlers = [];
-var clientEntryReasonCache = /* @__PURE__ */ new Map();
-function onExtensionHostReset(handler) {
-  resetHandlers.push(handler);
-}
-function restoreWithExtensionHost(registry) {
-  const defaults = { ...registry };
-  onExtensionHostReset(() => {
-    for (const key of Object.keys(registry)) delete registry[key];
-    Object.assign(registry, defaults);
-  });
-}
-function createCompatModeExtensions() {
-  return {
-    nextEnabled: () => false,
-    reactEnabled: () => false,
-    reactCompilerOptions: () => void 0
-  };
-}
-function getCompatModeExtensions() {
-  return activeHost.compatMode;
-}
-function setCompatModeExtensions(overrides) {
-  Object.assign(activeHost.compatMode, overrides);
-}
-function createRenderExtensions() {
-  return {
-    clientRouteState: (_route, state) => state,
-    wrapServerComponentInvoke: (invoke) => invoke(),
-    onRenderInit: () => void 0,
-    serializeServerActionProp: () => void 0,
-    collectRenderMeta: async (produce, _options) => ({ value: await produce(), tags: [] }),
-    currentCacheStaleSeconds: () => void 0,
-    genericErrorTitle: () => void 0,
-    islandCommentWireFormat: () => false,
-    serializeError: () => void 0,
-    httpAccessFallbackUi: () => void 0,
-    defaultGlobalErrorUi: () => void 0,
-    globalErrorReportScript: () => void 0,
-    wrapThrownValue: () => void 0,
-    formatErrorLog: () => void 0,
-    globalNotFoundEnabled: () => false,
-    trackVaryParams: (value) => value,
-    legacySyncProps: (promise) => promise,
-    prerenderSidecar: {
-      begin: () => void 0,
-      collect: () => Promise.resolve(void 0),
-      persist: () => Promise.resolve(),
-      seed: () => void 0,
-      isStale: () => false
-    }
-  };
-}
-function getRenderExtensions() {
-  return activeHost.render;
-}
-function setRenderExtensions(overrides) {
-  Object.assign(activeHost.render, overrides);
-}
-function createRequestExtensions() {
-  return {
-    interceptors: [],
-    warmHooks: [],
-    outsideBasePathInterceptors: [],
-    responseFinalizers: [],
-    onRequestError: () => void 0,
-    staticStaleness: () => false,
-    staticStalenessReason: () => void 0,
-    onDemandRevalidatePath: () => void 0,
-    revalidateBypassToken: () => void 0
-  };
-}
-function getRequestExtensions() {
-  return activeHost.request;
-}
-function registerRequestInterceptors(...interceptors) {
-  activeHost.request.interceptors.push(...interceptors);
-}
-function registerRequestWarmHooks(...hooks) {
-  activeHost.request.warmHooks.push(...hooks);
-}
-function registerOutsideBasePathInterceptors(...interceptors) {
-  activeHost.request.outsideBasePathInterceptors.push(...interceptors);
-}
-function registerResponseFinalizers(...finalizers) {
-  activeHost.request.responseFinalizers.push(...finalizers);
-}
-function registerRevalidateBypassToken(token) {
-  activeHost.request.revalidateBypassToken = token;
-}
-async function finalizeResponse(response, request, info) {
-  const finalizers = activeHost.request.responseFinalizers;
-  const ctx = {
-    request,
-    routeKind: info.routeKind,
-    ...info.routeMode ? { routeMode: info.routeMode } : {},
-    ...info.hints ? { hints: info.hints } : {},
-    status: response.status,
-    headers: response.headers
-  };
-  for (const finalizer of finalizers) await finalizer(ctx);
-  applyDocumentCacheControl(ctx, info.dev === true);
-  if (ctx.status === response.status) return response;
-  return new Response(response.body, {
-    status: ctx.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-var DYNAMIC_DOCUMENT_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
-var DEV_DOCUMENT_CACHE_CONTROL = "no-cache, must-revalidate";
-var DOCUMENT_EXPIRE_SECONDS = 31536e3;
-function applyDocumentCacheControl(ctx, dev) {
-  if (ctx.routeKind !== "html") return;
-  if (ctx.headers.has("cache-control")) return;
-  if (!(ctx.headers.get("content-type") ?? "").startsWith("text/html")) return;
-  if (dev) {
-    ctx.headers.set("cache-control", DEV_DOCUMENT_CACHE_CONTROL);
-    return;
-  }
-  if (ctx.status !== 200) {
-    ctx.headers.set("cache-control", DYNAMIC_DOCUMENT_CACHE_CONTROL);
-    return;
-  }
-  const revalidate = ctx.routeMode === "isr" ? ctx.hints?.revalidateSeconds : void 0;
-  if (typeof revalidate === "number" && revalidate > 0) {
-    const swr = Math.max(0, DOCUMENT_EXPIRE_SECONDS - revalidate);
-    ctx.headers.set("cache-control", `s-maxage=${revalidate}, stale-while-revalidate=${swr}`);
-    return;
-  }
-  ctx.headers.set(
-    "cache-control",
-    ctx.routeMode === "static" ? `s-maxage=${DOCUMENT_EXPIRE_SECONDS}` : DYNAMIC_DOCUMENT_CACHE_CONTROL
-  );
-}
-function setRequestExtensions(overrides) {
-  Object.assign(activeHost.request, overrides);
-}
-async function reportRequestError(error, requestInfo, context) {
-  try {
-    await activeHost.request.onRequestError(error, requestInfo, context);
-  } catch (reportError) {
-    console.error("onRequestError funnel failed:", reportError);
-  }
-}
-function createRuntimeExtensions() {
-  return { withEdgeRuntime: (callback) => callback() };
-}
-function setRuntimeExtensions(overrides) {
-  Object.assign(activeHost.runtime, overrides);
-}
-function withRouteRuntime(runtime, callback) {
-  const edge = runtime === "edge" || runtime === "experimental-edge";
-  const previous = process.env.NEXT_RUNTIME;
-  process.env.NEXT_RUNTIME = edge ? "edge" : "nodejs";
-  try {
-    const result = edge ? activeHost.runtime.withEdgeRuntime(callback) : callback();
-    if (isThenable(result)) {
-      return Promise.resolve(result).finally(() => restoreNextRuntime(previous));
-    }
-    restoreNextRuntime(previous);
-    return result;
-  } catch (error) {
-    restoreNextRuntime(previous);
-    throw error;
-  }
-}
-function restoreNextRuntime(value) {
-  if (value === void 0) {
-    delete process.env.NEXT_RUNTIME;
-  } else {
-    process.env.NEXT_RUNTIME = value;
-  }
-}
-function isThenable(value) {
-  return typeof value?.then === "function";
-}
-function createBuildExtensions() {
-  const compat = {
-    withVaryParamsTracking: async (produce) => ({ value: await produce() }),
-    varyNamesFor: () => [],
-    warnMetadataIssues: () => Promise.resolve(),
-    nextOutputExport: () => false,
-    nextOutputMode: () => void 0,
-    nextScriptWorkersEnabled: () => false,
-    defaultExpireTimeSeconds: () => void 0,
-    takeCacheLifeStash: () => void 0,
-    takeFontLinkHeader: () => void 0,
-    normalizeStaticParamsModule: (module) => module,
-    defaultDynamicStaleTimeSeconds: 30,
-    defaultStaticStaleTimeSeconds: 300,
-    buildRootTreePrefetch: (options) => {
-      const staleTime = options.staleTimeSeconds ?? (options.isStatic ? compat.defaultStaticStaleTimeSeconds : compat.defaultDynamicStaleTimeSeconds);
-      const bodySize = options.bodySizeBytes ?? 0;
-      const budget = options.inlineBudgetBytes ?? 32 * 1024;
-      const canInlineBody = options.isStatic && !options.postponed && bodySize <= budget;
-      return {
-        tree: {
-          name: "",
-          param: null,
-          slots: {
-            children: {
-              name: "__PAGE__",
-              param: null,
-              slots: null,
-              prefetchHints: canInlineBody ? 128 : 256,
-              ...options.bodySizeBytes !== void 0 ? { sizeBytes: options.bodySizeBytes } : {},
-              ...canInlineBody ? {} : { segmentPath: "/" }
-            }
-          },
-          prefetchHints: 16 | (canInlineBody ? 64 : 0)
-        },
-        staleTime,
-        isStatic: options.isStatic
-      };
-    },
-    rootTreePrefetchText: (payload, format = "json") => {
-      const json = JSON.stringify(payload);
-      return format === "flight" ? `0:${json}` : json;
-    },
-    buildSegmentMeta: (options) => {
-      const inlined = !options.postponed && options.bodySizeBytes !== void 0 && options.bodySizeBytes <= (options.inlineBudgetBytes ?? 32 * 1024);
-      return {
-        status: options.status,
-        staleTime: options.staleTime,
-        postponed: options.postponed,
-        segmentPaths: ["/_tree", "/"],
-        ...options.bodySizeBytes !== void 0 ? { segmentSizes: { "/": options.bodySizeBytes } } : {},
-        ...inlined ? { inlinedSegmentPaths: ["/"] } : {},
-        ...options.prefetchHints ? { prefetchHints: options.prefetchHints } : {}
-      };
-    },
-    diagnoseCacheComponentsPrerender: () => void 0,
-    prerenderFailureFooter: () => "",
-    diagnosticLeadsWithErrorLine: () => false,
-    recordBuildFlags: () => void 0,
-    segmentDir: (outPath, routeId) => `${outPath}/segments/${routeId}`,
-    treeSegmentFile: (outPath, routeId) => `${compat.segmentDir(outPath, routeId)}/_tree.segment.rsc`,
-    bodySegmentFile: (outPath, routeId) => `${compat.segmentDir(outPath, routeId)}/index.segment.rsc`,
-    segmentMetaFile: (outPath, routeId) => `${compat.segmentDir(outPath, routeId)}/route.segment.meta`
-  };
-  return { steps: [], completeHooks: [], initHooks: [], parallelPhases: [], compat };
-}
-function getBuildExtensions() {
-  return activeHost.build;
-}
-function setBuildCompatExtensions(overrides) {
-  Object.assign(activeHost.build.compat, overrides);
-}
-function registerBuildSteps(...steps) {
-  activeHost.build.steps.push(...steps);
-}
-function registerBuildCompleteHooks(...hooks) {
-  activeHost.build.completeHooks.push(...hooks);
-}
-function registerBuildParallelPhases(...phases) {
-  for (const phase of phases) {
-    phase.run.catch((error) => {
-      parallelPhaseErrors.set(phase, error);
-    });
-  }
-  activeHost.build.parallelPhases.push(...phases);
-}
-var parallelPhaseErrors = /* @__PURE__ */ new WeakMap();
-function registerInitHooks(...hooks) {
-  activeHost.build.initHooks.push(...hooks);
-}
-function runInitHooks(config, context = { build: false }) {
-  for (const hook of activeHost.build.initHooks) hook(config, context);
-}
-function createRoutingExtensions() {
-  return {
-    conventions: [],
-    usageDetection: [],
-    dependencyClassification: [],
-    clientEntryDetection: [],
-    pageExtensions: [],
-    alwaysClientEntryReasons: /* @__PURE__ */ new Set()
-  };
-}
-function registerRouteConventions(...conventions) {
-  activeHost.routing.conventions.push(...conventions);
-}
-function registerUsageDetectors(...detectors) {
-  activeHost.routing.usageDetection.push(...detectors);
-}
-function registerRouteDependencyClassifiers(...classifiers) {
-  activeHost.routing.dependencyClassification.push(...classifiers);
-}
-function registerClientEntryDetectors(...detectors) {
-  activeHost.routing.clientEntryDetection.push(...detectors);
-  clientEntryReasonCache.clear();
-}
-var loadableExtensionListeners = [];
-function onLoadableExtensionsChanged(listener) {
-  loadableExtensionListeners.push(listener);
-}
-function registerLoadableExtensions(...extensions) {
-  const loadable = activeHost.loadable;
-  const fresh = [...new Set(extensions)].filter((ext) => !loadable.includes(ext));
-  if (fresh.length === 0) return;
-  loadable.push(...fresh);
-  for (const listener of loadableExtensionListeners) listener();
-}
-function extraLoadableExtensions() {
-  return [.../* @__PURE__ */ new Set([...activeHost.routing.pageExtensions, ...activeHost.loadable])];
-}
-function registerPageExtensions(...extensions) {
-  const { pageExtensions } = activeHost.routing;
-  const fresh = [...new Set(extensions)].filter((ext) => !pageExtensions.includes(ext));
-  if (fresh.length === 0) return;
-  pageExtensions.push(...fresh);
-  for (const listener of loadableExtensionListeners) listener();
-}
-function registerAlwaysClientEntryReason(reason) {
-  activeHost.routing.alwaysClientEntryReasons.add(reason);
-}
-function alwaysClientEntryReasons() {
-  return [...activeHost.routing.alwaysClientEntryReasons];
-}
-function extraPageExtensions() {
-  return activeHost.routing.pageExtensions;
-}
-function extraBoundaryConventionNames() {
-  return activeHost.routing.conventions.filter((c) => c.boundary).map((c) => c.name);
-}
-function sourceUsesRegisteredRequestApi(source) {
-  return activeHost.routing.usageDetection.some((detect) => detect(source));
-}
-function classifyRouteDependencies(context) {
-  const classification = {};
-  for (const classify of activeHost.routing.dependencyClassification) {
-    const result = classify(context);
-    if (!result) continue;
-    if (result.usesRequest) classification.usesRequest = true;
-  }
-  return classification;
-}
-function sourceClientEntryReasons(source) {
-  const key = `${source.length}\0${bun.hash(source).toString(36)}`;
-  const cached = clientEntryReasonCache.get(key);
-  if (cached) return cached;
-  const reasons = [];
-  for (const { reason, detect } of activeHost.routing.clientEntryDetection) {
-    if (!reasons.includes(reason) && detect(source)) reasons.push(reason);
-  }
-  clientEntryReasonCache.set(key, reasons);
-  return reasons;
-}
-function createProxyExtensions() {
-  return {
-    names: ["proxy"],
-    validateFiles: () => Promise.resolve(),
-    handlerExport: (module) => module.proxy ?? module.default,
-    skipUrlNormalize: () => false,
-    locale: () => "",
-    onExternalRewrite: (request) => void request,
-    clientMaxBodySize: () => 10 * 1024 * 1024
-  };
-}
-function getProxyExtensions() {
-  return activeHost.proxy;
-}
-function setProxyExtensions(overrides) {
-  Object.assign(activeHost.proxy, overrides);
-}
-function createBundlerExtensions() {
-  return {
-    serverSourcePreTransforms: [],
-    serverSourceTransforms: [],
-    clientSourceTransforms: [],
-    clientSourceAsyncPreTransforms: [],
-    bundledSourceTransforms: [],
-    clientEsbuildPlugins: () => [],
-    serverEsbuildPlugins: () => [],
-    serverBundleEntry: () => void 0,
-    serverDefines: () => ({}),
-    clientDefines: () => ({}),
-    clientInjects: () => [],
-    resolveRouteDependency: () => void 0,
-    clientPureFunctions: () => [],
-    staticClientChunks: () => []
-  };
-}
-function getBundlerExtensions() {
-  return activeHost.bundler;
-}
-function serverDefineOptions() {
-  const define = activeHost.bundler.serverDefines();
-  return Object.keys(define).length > 0 ? { define } : {};
-}
-function registerServerSourceTransforms(...transforms) {
-  activeHost.bundler.serverSourceTransforms.push(...transforms);
-  activeHost.serverSniff = void 0;
-}
-function registerServerSourcePreTransforms(...transforms) {
-  activeHost.bundler.serverSourcePreTransforms.push(...transforms);
-  activeHost.serverSniff = void 0;
-}
-function registerClientSourceTransforms(...transforms) {
-  activeHost.bundler.clientSourceTransforms.push(...transforms);
-}
-function registerClientSourceAsyncPreTransforms(...transforms) {
-  activeHost.bundler.clientSourceAsyncPreTransforms.push(...transforms);
-}
-function registerBundledSourceTransforms(...transforms) {
-  activeHost.bundler.bundledSourceTransforms.push(...transforms);
-}
-function withSniff(sniff, transform) {
-  return Object.assign(
-    (source, file, root) => transform(source, file, root),
-    { sniff }
-  );
-}
-function sniffHit(source, sniff) {
-  for (const token of sniff) {
-    if (typeof token === "string" ? source.includes(token) : token.test(source)) return true;
-  }
-  return false;
-}
-function serverSourceSniff() {
-  const host = activeHost;
-  if (host.serverSniff) return host.serverSniff;
-  const tokens = /* @__PURE__ */ new Set();
-  for (const transform of [
-    ...host.bundler.serverSourcePreTransforms,
-    ...host.bundler.serverSourceTransforms
-  ]) {
-    if (!transform.sniff) return host.serverSniff = { pattern: void 0 };
-    for (const token of transform.sniff) {
-      tokens.add(`(?:${typeof token === "string" ? escapeRegex(token) : token.source})`);
-    }
-  }
-  return host.serverSniff = { pattern: new RegExp(tokens.size ? [...tokens].join("|") : "(?!)") };
-}
-function sourceNeedsServerTransforms(source) {
-  const { pattern } = serverSourceSniff();
-  return !pattern || pattern.test(source);
-}
-function applyTransforms(transforms, source, file, root) {
-  let next = source;
-  for (const transform of transforms) {
-    if (transform.sniff && !sniffHit(next, transform.sniff)) continue;
-    next = transform(next, file, root);
-  }
-  return next;
-}
-function setBundlerExtensions(overrides) {
-  Object.assign(activeHost.bundler, overrides);
-}
-function applyServerSourcePreTransforms(source, file, root) {
-  return applyTransforms(activeHost.bundler.serverSourcePreTransforms, source, file, root);
-}
-function applyServerSourceTransforms(source, file, root) {
-  return applyTransforms(activeHost.bundler.serverSourceTransforms, source, file, root);
-}
-function applyClientSourceTransforms(source, file, root) {
-  return applyTransforms(activeHost.bundler.clientSourceTransforms, source, file, root);
-}
-function applyBundledSourceTransforms(source, file) {
-  return applyTransforms(activeHost.bundler.bundledSourceTransforms, source, file);
-}
-function createImportAliasExtensions() {
-  return {
-    aliases: () => ({}),
-    clientSsrAliases: () => ({}),
-    missingImportError: () => void 0,
-    reactServerLayerAliases: () => ({})
-  };
-}
-function getImportAliasExtensions() {
-  return activeHost.importAlias;
-}
-function setImportAliasExtensions(overrides) {
-  Object.assign(activeHost.importAlias, overrides);
-}
-function createProxyResponseProtocol() {
-  return {
-    nextHeader: "x-pnext-middleware-next",
-    rewriteHeader: "x-pnext-middleware-rewrite"
-  };
-}
-function getProxyResponseProtocol() {
-  return activeHost.proxyResponse;
-}
-function setProxyResponseProtocol(overrides) {
-  Object.assign(activeHost.proxyResponse, overrides);
-}
-function createRouterProtocolExtensions() {
-  return {
-    prefetchRequestHeaders: () => [],
-    shellOnlyRequest: () => false
-  };
-}
-function getRouterProtocolExtensions() {
-  return activeHost.routerProtocol;
-}
-function setRouterProtocolExtensions(overrides) {
-  Object.assign(activeHost.routerProtocol, overrides);
-}
-function createAssetExtensions() {
-  return {
-    staticAssetPublicPrefixes: () => ["/__pnext/static/media/"],
-    staticAssetRelativePath: ({ base, hash, ext }) => `__pnext/static/media/${base}.${hash}${ext}`,
-    staticAssetModule: () => void 0,
-    hasLoaderRuleFor: () => false,
-    loaderRuleModule: () => void 0
-  };
-}
-function getAssetExtensions() {
-  return activeHost.asset;
-}
-function setAssetExtensions(overrides) {
-  Object.assign(activeHost.asset, overrides);
-}
-var cssExtensions = {
-  extraCssExtensions: () => [],
-  resolveCssDependency: () => void 0,
-  deferRootNotFoundCss: () => false,
-  inlineStylesheets: () => void 0,
-  cssChunkPlugins: () => [],
-  resolveCssModule: () => void 0,
-  loadCssModuleForClient: () => void 0,
-  planRouteCssChunks: () => /* @__PURE__ */ new Map()
-};
-restoreWithExtensionHost(cssExtensions);
-function getCssExtensions() {
-  return cssExtensions;
-}
-function setCssExtensions(overrides) {
-  Object.assign(cssExtensions, overrides);
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/imports.ts
-import { existsSync as existsSync3, readFileSync, readdirSync as readdirSync2, realpathSync } from "node:fs";
-import path3 from "node:path";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/engine.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/fs-cache.ts
-import { existsSync, readdirSync } from "node:fs";
-import path from "node:path";
-var NODE_MODULES = `${path.sep}node_modules${path.sep}`;
-var dirents = /* @__PURE__ */ new Map();
-function direntsFor(dir) {
-  if (dirents.has(dir)) return dirents.get(dir);
-  let names;
-  try {
-    names = new Set(readdirSync(dir));
-  } catch {
-    names = void 0;
-  }
-  dirents.set(dir, names);
-  return names;
-}
-function cachedExistsSync(file) {
-  if (!file.includes(NODE_MODULES)) return existsSync(file);
-  return direntsFor(path.dirname(file))?.has(path.basename(file)) ?? false;
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/engine.ts
-function createResolverFactory(options) {
-  const { ResolverFactory: Factory } = loadNative(
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    () => __require("oxc-resolver")
-  );
-  return new Factory(options);
-}
-var sourceExtensions = [
-  ".tsx",
-  ".ts",
-  ".jsx",
-  ".js",
-  ".mjs",
-  ".mts",
-  ".cts",
-  ".module.css",
-  ".css"
-];
-var extensionAlias = {
-  ".js": [".ts", ".tsx", ".js"],
-  ".jsx": [".tsx", ".jsx"],
-  ".mjs": [".mts", ".mjs"],
-  ".cjs": [".cts", ".cjs"]
-};
-var configuredExtensions;
-var configuredTsConfigPath;
-var baseFactory;
-var factories = /* @__PURE__ */ new Map();
-var tsConfigFiles = /* @__PURE__ */ new Map();
-function setEngineExtensions(extensions) {
-  configuredExtensions = extensions && extensions.length > 0 ? [...extensions] : void 0;
-  resetEngine();
-}
-function setEngineTsConfigPath(file) {
-  configuredTsConfigPath = file;
-  resetEngine();
-}
-function resetEngine() {
-  baseFactory = void 0;
-  factories.clear();
-  tsConfigFiles.clear();
-  nodeModulesOutcomes.clear();
-}
-function tsConfigFileFor(root) {
-  const key = path2.resolve(root);
-  if (tsConfigFiles.has(key)) return tsConfigFiles.get(key);
-  const candidates = [
-    ...configuredTsConfigPath ? [path2.resolve(key, configuredTsConfigPath)] : [],
-    path2.join(key, "tsconfig.json"),
-    path2.join(key, "jsconfig.json")
-  ];
-  const file = candidates.find((candidate) => existsSync2(candidate));
-  tsConfigFiles.set(key, file);
-  return file;
-}
-function splitResourceQuery(specifier) {
-  const offset = specifier.startsWith("#") ? 1 : 0;
-  const match = /[?#]/.exec(specifier.slice(offset));
-  if (!match) return { path: specifier, query: "" };
-  const index = offset + match.index;
-  return { path: specifier.slice(0, index), query: specifier.slice(index) };
-}
-function resolveFrom(dir, specifier, conditions, tsConfigRoot) {
-  const { path: request } = splitResourceQuery(specifier);
-  const tsconfig = tsConfigRoot ? tsConfigFileFor(tsConfigRoot) : void 0;
-  return resolveRequest(dir, request, conditions, tsconfig, isSourceRequest(request));
-}
-function probeFile(target, conditions) {
-  return probe(target, conditions, true);
-}
-function probePackageTarget(target, conditions) {
-  return probe(target, conditions, false);
-}
-function probe(target, conditions, sourceAlias) {
-  const { path: file } = splitResourceQuery(target);
-  const request = `./${path2.basename(file)}`;
-  const outcome = resolveRequest(path2.dirname(file), request, conditions, void 0, sourceAlias);
-  return outcome && "path" in outcome ? outcome.path : void 0;
-}
-var nodeModulesOutcomes = /* @__PURE__ */ new Map();
-var NODE_MODULES_SEGMENT = `${path2.sep}node_modules${path2.sep}`;
-function resolveRequest(dir, request, conditions, tsconfig, sourceAlias) {
-  const key = dir.includes(NODE_MODULES_SEGMENT) ? `${dir}\0${request}\0${conditions.join(",")}\0${tsconfig ?? ""}\0${sourceAlias}` : void 0;
-  if (key !== void 0 && nodeModulesOutcomes.has(key)) return nodeModulesOutcomes.get(key);
-  const { path: file, error } = resolverFor(conditions, tsconfig, sourceAlias).sync(dir, request);
-  const outcome = file ? isDeclarationFile(file) ? void 0 : { path: file } : error?.includes("is not exported") ? { notExported: true } : void 0;
-  if (key !== void 0) nodeModulesOutcomes.set(key, outcome);
-  return outcome;
-}
-function isSourceRequest(request) {
-  return request.startsWith(".") || path2.isAbsolute(request);
-}
-function resolverFor(conditions, tsconfig, sourceExtensionAlias) {
-  const key = `${conditions.join(",")}\0${tsconfig ?? ""}\0${sourceExtensionAlias}`;
-  let resolver = factories.get(key);
-  if (!resolver) {
-    const options = {
-      ...baseOptions(),
-      extensionAlias: sourceExtensionAlias ? extensionAlias : {},
-      conditionNames: [...conditions],
-      mainFields: mainFieldsFor(conditions)
-    };
-    if (tsconfig) options.tsconfig = { configFile: tsconfig };
-    resolver = baseResolver().cloneWithOptions(options);
-    factories.set(key, resolver);
-  }
-  return resolver;
-}
-function baseOptions() {
-  return {
-    extensions: configuredExtensions ?? sourceExtensions,
-    // Symlink policy is the caller's (see realLinkedPackageFile in imports.ts):
-    // pnpm virtual-store paths carry version identity that must not collapse.
-    symlinks: false
-  };
-}
-function baseResolver() {
-  baseFactory ??= createResolverFactory(baseOptions());
-  return baseFactory;
-}
-function mainFieldsFor(conditions) {
-  const fields = ["module", "main"];
-  if (conditions.includes("browser")) fields.unshift("browser");
-  if (conditions.includes("edge-light")) fields.unshift("edge-light");
-  return fields;
-}
-function isDeclarationFile(file) {
-  return /\.d\.[cm]?ts$/.test(file);
-}
-
-// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/imports.ts
-var { Bun: bun2 } = globalThis;
-var localConditions = ["source", "import", "browser", "node", "default", "require"];
-function setResolveExtensions(extensions) {
-  setEngineExtensions(extensions);
-  clearVendorPackageResolutions();
-}
-var noExternalPolicy = {
-  external: () => false,
-  transpile: () => false,
-  esmExternals: () => true
-};
-var externalPackagePolicy = noExternalPolicy;
-var externalLoadResolver;
-function setExternalPackagePolicy(policy) {
-  externalPackagePolicy = policy ?? noExternalPolicy;
-}
-function getExternalPackagePolicy() {
-  return externalPackagePolicy;
-}
-function setExternalLoadResolver(resolver) {
-  externalLoadResolver = resolver;
-  externalLoadTargets.clear();
-}
-var externalLoadTargets = /* @__PURE__ */ new Map();
-function resolveExternalLoadTarget(context) {
-  if (!externalLoadResolver) return void 0;
-  if (context.specifier.startsWith("#")) return externalLoadResolver(context);
-  const key = `${context.target}\0${resolutionRootForFile(context.root, context.fromFile)}\0${context.specifier}`;
-  if (externalLoadTargets.has(key)) return externalLoadTargets.get(key);
-  const target = externalLoadResolver(context);
-  externalLoadTargets.set(key, target);
-  return target;
-}
-function packageNameOfSpecifier(specifier) {
-  return packageNameFromSpecifier(specifier);
-}
-function packageNameForFile(file) {
-  const packageRoot = nearestPackageRoot(path3.dirname(file));
-  return packageRoot ? readPackageJson(packageRoot).name : void 0;
-}
-function externalPackageImportTarget(root, fromFile, specifier) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const policy = getExternalPackagePolicy();
-  if (!policy.external(packageName) || policy.esmExternals() !== true) return void 0;
-  const imported = resolvePackageSpecifier(root, fromFile, specifier, ["import", "node", "default"]);
-  if (!imported || isEsmModuleFile(imported)) return void 0;
-  const required = resolvePackageSpecifier(root, fromFile, specifier, [
-    "require",
-    "node",
-    "default"
-  ]);
-  return required && required !== imported ? required : void 0;
-}
-function setTsConfigPath(file) {
-  setEngineTsConfigPath(file);
-  tsConfigCache.clear();
-  clearVendorPackageResolutions();
-}
-var extraModuleAliases;
-onExtensionHostReset(() => {
-  extraModuleAliases = void 0;
-  clearVendorPackageResolutions();
-});
-function setModuleAliases(aliases) {
-  extraModuleAliases = aliases;
-}
-function resolveModuleAlias(specifier) {
-  const aliased = extraModuleAliases?.[specifier];
-  return aliased ? probeFile(aliased, localConditions) : void 0;
-}
-function resolveImport(root, fromFile, specifier, workspaceRoot) {
-  if (splitResourceQuery(specifier).query) return void 0;
-  if (specifier.startsWith(".")) {
-    return resolveLocalFile(path3.dirname(realImportPath(fromFile)), specifier);
-  }
-  if (path3.isAbsolute(specifier)) return probeFile(specifier, localConditions);
-  const resolutionRoot = resolutionRootForFile(root, fromFile);
-  const tsResolved = resolveTsPath(resolutionRoot, specifier);
-  if (tsResolved) return realImportPath(tsResolved);
-  if (specifier.startsWith("#")) {
-    const resolved = resolveLocalFile(resolutionRoot, specifier);
-    return resolved ? realImportPath(resolved) : void 0;
-  }
-  const workspaceResolved = resolveWorkspacePackageImport(root, specifier, workspaceRoot);
-  if (workspaceResolved) return workspaceResolved;
-  return resolveAppTreePackage(resolutionRoot, root, fromFile, specifier);
-}
-function resolveLocalFile(dir, specifier) {
-  const outcome = resolveFrom(dir, specifier, localConditions);
-  return outcome && "path" in outcome ? outcome.path : void 0;
-}
-var realImportPathCache = /* @__PURE__ */ new Map();
-function realImportPath(file) {
-  const cached = realImportPathCache.get(file);
-  if (cached !== void 0) return cached;
-  try {
-    const real = realpathSync(file);
-    realImportPathCache.set(file, real);
-    return real;
-  } catch {
-    return file;
-  }
-}
-var appTreeResolveCache = /* @__PURE__ */ new Map();
-var memoAppTree = process.env.PNEXT_RESOLVE_APPTREE_MEMO !== "0";
-function resolveAppTreePackage(resolutionRoot, root, fromFile, specifier) {
-  const from = path3.dirname(path3.resolve(fromFile));
-  const key = `${resolutionRoot}\0${root}\0${from}\0${specifier}`;
-  if (memoAppTree) {
-    const cached = appTreeResolveCache.get(key);
-    if (cached !== void 0) return cached;
-  }
-  const outcome = resolveFrom(from, specifier, localConditions, resolutionRoot);
-  if (!outcome || !("path" in outcome)) return void 0;
-  const resolved = isAppTreeFile(path3.resolve(root), outcome.path) ? outcome.path : void 0;
-  if (memoAppTree && resolved !== void 0) appTreeResolveCache.set(key, resolved);
-  return resolved;
-}
-function isAppTreeFile(root, file) {
-  const relative = path3.relative(root, file);
-  if (relative.startsWith("..") || path3.isAbsolute(relative)) return false;
-  const nodeModules = relative.split(path3.sep).indexOf("node_modules");
-  return nodeModules !== 0;
-}
-function resolveConfiguredTsPath(root, fromFile, specifier) {
-  if (specifier.startsWith(".") || specifier.startsWith("#") || path3.isAbsolute(specifier)) {
-    return void 0;
-  }
-  return resolveTsPath(resolutionRootForFile(root, fromFile), specifier);
-}
-function configuredTsPathPatterns(root, workspaceRoot) {
-  const roots = /* @__PURE__ */ new Set([path3.resolve(root)]);
-  if (workspaceRoot) {
-    const resolved = path3.resolve(workspaceRoot);
-    roots.add(resolved);
-    for (const packageRoot of workspacePackages(resolved).values()) roots.add(packageRoot);
-  }
-  const patterns = /* @__PURE__ */ new Set();
-  for (const dir of roots) {
-    for (const pattern of Object.keys(readTsConfig(dir).compilerOptions?.paths ?? {})) {
-      patterns.add(pattern);
-    }
-  }
-  return [...patterns];
-}
-function resolveTsPath(root, specifier) {
-  const compilerOptions = readTsConfig(root).compilerOptions ?? {};
-  const baseUrl = path3.resolve(root, compilerOptions.baseUrl ?? ".");
-  for (const [pattern, targets] of Object.entries(compilerOptions.paths ?? {})) {
-    const match = matchPattern(pattern, specifier);
-    if (!match) continue;
-    for (const target of targets) {
-      const resolved = probeFile(
-        path3.resolve(baseUrl, applyPattern(target, match)),
-        localConditions
-      );
-      if (resolved) return resolved;
-    }
-  }
-  return void 0;
-}
-function resolveWorkspacePackageImport(root, specifier, boundary) {
-  const workspaceRoot = boundary ? path3.resolve(boundary) : findWorkspaceRoot(root);
-  if (!workspaceRoot) return void 0;
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const packageRoot = workspacePackages(workspaceRoot).get(packageName);
-  if (!packageRoot) return void 0;
-  const packageJson = readPackageJson(packageRoot);
-  const subpath = subpathOfSpecifier(packageName, specifier);
-  const exported = packageExportTarget(packageJson.exports, subpath);
-  if (exported) {
-    const resolved = probePackageTarget(path3.resolve(packageRoot, exported), localConditions);
-    if (resolved && isInside(packageRoot, resolved)) return resolved;
-  }
-  const onDisk = onDiskSubpath(packageRoot, subpath, localConditions);
-  if (onDisk) return onDisk;
-  for (const entry of [
-    packageJson.source,
-    packageJson.module,
-    packageJson.main,
-    "./src/index",
-    "./index"
-  ]) {
-    if (!entry) continue;
-    const resolved = probePackageTarget(path3.resolve(packageRoot, entry), localConditions);
-    if (resolved) return resolved;
-  }
-  return void 0;
-}
-function packageExportTarget(exports, subpath) {
-  if (!exports) return void 0;
-  if (!isSubpathExports(exports)) return subpath === "." ? packageTargetPath(exports) : void 0;
-  for (const [pattern, target] of Object.entries(exports)) {
-    const match = matchPattern(pattern, subpath);
-    if (!match) continue;
-    const targetPath = packageTargetPath(target);
-    if (targetPath) return applyPattern(targetPath, match);
-  }
-  return void 0;
-}
-function packageExportTargetForConditions(exports, subpath, conditions) {
-  if (!exports) return void 0;
-  if (!isSubpathExports(exports)) {
-    return subpath === "." ? packageTargetPathForConditions(exports, conditions) : void 0;
-  }
-  for (const [pattern, target] of Object.entries(exports)) {
-    const match = matchPattern(pattern, subpath);
-    if (!match) continue;
-    const targetPath = packageTargetPathForConditions(target, conditions);
-    if (targetPath) return applyPattern(targetPath, match);
-  }
-  return void 0;
-}
-function packageTargetPathForConditions(target, conditions) {
-  if (!target) return void 0;
-  if (typeof target === "string") return target;
-  if (Array.isArray(target)) {
-    for (const item of target) {
-      const resolved = packageTargetPathForConditions(item, conditions);
-      if (resolved) return resolved;
-    }
-    return void 0;
-  }
-  if (!isPackageExportObject(target)) return void 0;
-  for (const [key, value] of Object.entries(target)) {
-    if (key !== "default" && !conditions.includes(key)) continue;
-    const resolved = packageTargetPathForConditions(value, conditions);
-    if (resolved) return resolved;
-  }
-  return void 0;
-}
-function isSubpathExports(exports) {
-  return isPackageExportObject(exports) && Object.keys(exports).some((key) => key.startsWith("."));
-}
-function packageTargetPath(target) {
-  if (!target) return void 0;
-  if (typeof target === "string") return target;
-  if (Array.isArray(target)) {
-    for (const item of target) {
-      const resolved = packageTargetPath(item);
-      if (resolved) return resolved;
-    }
-    return void 0;
-  }
-  if (!isPackageExportObject(target)) return void 0;
-  for (const key of ["source", "import", "browser", "node", "default", "types", "require"]) {
-    const resolved = packageTargetPath(target[key]);
-    if (resolved) return resolved;
-  }
-  for (const value of Object.values(target)) {
-    const resolved = packageTargetPath(value);
-    if (resolved) return resolved;
-  }
-  return void 0;
-}
-function isPackageExportObject(target) {
-  return typeof target === "object" && target !== null && !Array.isArray(target);
-}
-function matchPattern(pattern, specifier) {
-  if (pattern === specifier) return { wildcard: "" };
-  const star = pattern.indexOf("*");
-  if (star === -1) return void 0;
-  const prefix = pattern.slice(0, star);
-  const suffix = pattern.slice(star + 1);
-  if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) return void 0;
-  return { wildcard: specifier.slice(prefix.length, specifier.length - suffix.length) };
-}
-function applyPattern(pattern, match) {
-  return pattern.replace("*", match.wildcard);
-}
-function packageNameFromSpecifier(specifier) {
-  const parts = specifier.split("/");
-  if (specifier.startsWith("@")) return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
-  return parts[0] || void 0;
-}
-function subpathOfSpecifier(packageName, specifier) {
-  return specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
-}
-function resolutionRootForFile(root, fromFile) {
-  const resolvedRoot = path3.resolve(root);
-  const resolvedFile = path3.resolve(fromFile);
-  if (isInside(resolvedRoot, resolvedFile)) return resolvedRoot;
-  return nearestPackageRoot(path3.dirname(resolvedFile)) ?? resolvedRoot;
-}
-function resolveNestedPackageFromImporter(importerFile, specifier, conditions) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const from = path3.dirname(realImportPath(path3.resolve(importerFile)));
-  return realLinkedPackageFile(resolvePackageFrom(from, packageName, specifier, conditions));
-}
-var packageRoots = /* @__PURE__ */ new Map();
-function nearestPackageRoot(fromDir) {
-  const start = path3.resolve(fromDir);
-  if (packageRoots.has(start)) return packageRoots.get(start);
-  let dir = start;
-  const walked = [];
-  let found;
-  while (true) {
-    walked.push(dir);
-    if (existsSync3(path3.join(dir, "package.json"))) {
-      found = dir;
-      break;
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  for (const seen of walked) packageRoots.set(seen, found);
-  return found;
-}
-var vendorEntryProvisions = /* @__PURE__ */ new Map();
-function provideEntryResolution(specifier, resolveDir, resolved) {
-  vendorEntryProvisions.set(`${specifier}\0${resolveDir}`, resolved);
-}
-function providedEntryResolution(specifier, resolveDir) {
-  return vendorEntryProvisions.get(`${specifier}\0${resolveDir}`);
-}
-function resolvePackageSpecifier(root, fromFile, specifier, conditions) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const from = resolutionRootForFile(root, fromFile);
-  return realLinkedPackageFile(resolvePackageFrom(from, packageName, specifier, conditions));
-}
-var vendorPackageResolutions = /* @__PURE__ */ new Map();
-function resolveVendorPackageSpecifier(root, fromFile, specifier, conditions) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const from = resolutionRootForFile(root, fromFile);
-  const key = `${from}\0${specifier}\0${conditions.join(",")}`;
-  if (vendorPackageResolutions.has(key)) return vendorPackageResolutions.get(key);
-  const resolved = realLinkedPackageFile(
-    resolvePackageFrom(from, packageName, specifier, conditions)
-  );
-  vendorPackageResolutions.set(key, resolved);
-  return resolved;
-}
-function clearVendorPackageResolutions() {
-  vendorPackageResolutions.clear();
-}
-function resolvePackageImportSpecifier(root, fromFile, specifier, conditions) {
-  if (!specifier.startsWith("#")) return void 0;
-  const from = nearestPackageRoot(path3.dirname(fromFile)) ?? resolutionRootForFile(root, fromFile);
-  const outcome = resolveFrom(from, specifier, conditions);
-  return outcome && "path" in outcome ? outcome.path : void 0;
-}
-function resolvePackageFrom(from, packageName, specifier, conditions) {
-  const outcome = resolveFrom(from, specifier, conditions);
-  if (outcome && "path" in outcome) return outcome.path;
-  const packageRoot = findNodePackageRoot(from, packageName);
-  if (!packageRoot) return void 0;
-  return onDiskSubpath(packageRoot, subpathOfSpecifier(packageName, specifier), conditions);
-}
-function onDiskSubpath(packageRoot, subpath, conditions) {
-  if (subpath === ".") return void 0;
-  const resolved = probePackageTarget(path3.resolve(packageRoot, subpath.slice(2)), conditions);
-  return resolved && isInside(packageRoot, resolved) ? resolved : void 0;
-}
-var runtimeResolveCache = /* @__PURE__ */ new Map();
-function resolveRuntimeSpecifier(dir, specifier) {
-  const key = `${dir}\0${specifier}`;
-  const cached = runtimeResolveCache.get(key);
-  if (cached !== void 0) return cached;
-  try {
-    const resolved = bun2.resolveSync(specifier, dir);
-    runtimeResolveCache.set(key, resolved);
-    return resolved;
-  } catch {
-    return void 0;
-  }
-}
-var linkedPackageFileCache = /* @__PURE__ */ new Map();
-function realLinkedPackageFile(file) {
-  if (!file) return file;
-  const cached = linkedPackageFileCache.get(file);
-  if (cached !== void 0) return cached;
-  let resolved = file;
-  try {
-    const real = realpathSync(file);
-    if (!real.includes(`${path3.sep}node_modules${path3.sep}`)) resolved = real;
-  } catch {
-  }
-  linkedPackageFileCache.set(file, resolved);
-  return resolved;
-}
-function isPackageSubpathUnexported(root, fromFile, specifier, conditions) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return false;
-  const resolutionRoot = resolutionRootForFile(root, fromFile);
-  const packageRoot = findNodePackageRoot(resolutionRoot, packageName) ?? findLinkedPackageRoot(resolutionRoot, packageName);
-  if (!packageRoot) return false;
-  const { exports } = readPackageJson(packageRoot);
-  if (!exports || !isSubpathExports(exports)) return false;
-  const subpath = subpathOfSpecifier(packageName, specifier);
-  if (!Object.keys(exports).some((pattern) => matchPattern(pattern, subpath))) return false;
-  if (packageExportTargetForConditions(exports, subpath, conditions)) return false;
-  return !onDiskSubpath(packageRoot, subpath, conditions);
-}
-function resolveLinkedPackageSpecifier(root, fromFile, specifier, conditions) {
-  const packageName = packageNameFromSpecifier(specifier);
-  if (!packageName) return void 0;
-  const packageRoot = findLinkedPackageRoot(resolutionRootForFile(root, fromFile), packageName);
-  if (!packageRoot) return void 0;
-  return realLinkedPackageFile(
-    resolvePackageAtRoot(packageRoot, subpathOfSpecifier(packageName, specifier), conditions)
-  );
-}
-function resolvePackageAtRoot(packageRoot, subpath, conditions) {
-  const packageJson = readPackageJson(packageRoot);
-  const exported = packageExportTargetForConditions(packageJson.exports, subpath, conditions);
-  if (exported) {
-    const resolved = probePackageTarget(path3.resolve(packageRoot, exported), conditions);
-    if (resolved && isInside(packageRoot, resolved)) return resolved;
-  }
-  const onDisk = onDiskSubpath(packageRoot, subpath, conditions);
-  if (onDisk) return onDisk;
-  const edgeLight = conditions.includes("edge-light") ? [packageJson["edge-light"]] : [];
-  const browser = conditions.includes("browser") ? [packageJson.browser] : [];
-  for (const entry of [...edgeLight, ...browser, packageJson.module, packageJson.main, "./index"]) {
-    if (typeof entry !== "string") continue;
-    const resolved = probePackageTarget(path3.resolve(packageRoot, entry), conditions);
-    if (resolved) return resolved;
-  }
-  return void 0;
-}
-function findNodePackageRoot(root, packageName) {
-  let dir = path3.resolve(root);
-  while (true) {
-    const candidate = path3.join(dir, "node_modules", packageName);
-    if (existsSync3(path3.join(candidate, "package.json"))) return candidate;
-    const parent = path3.dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-var linkedPackageRootCache = /* @__PURE__ */ new Map();
-var memoLinkedRoots = process.env.PNEXT_RESOLVE_LINK_MEMO !== "0";
-function findLinkedPackageRoot(root, packageName) {
-  if (!memoLinkedRoots) return walkForLinkedPackageRoot(root, packageName);
-  const key = `${path3.resolve(root)}\0${packageName}`;
-  const cached = linkedPackageRootCache.get(key);
-  if (cached !== void 0 || linkedPackageRootCache.has(key)) return cached;
-  const found = walkForLinkedPackageRoot(root, packageName);
-  linkedPackageRootCache.set(key, found);
-  return found;
-}
-function walkForLinkedPackageRoot(root, packageName) {
-  let dir = path3.resolve(root);
-  while (true) {
-    const linked = linkedPackageRoot(dir, packageName);
-    if (linked) return linked;
-    const parent = path3.dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function linkedPackageRoot(packageRoot, packageName) {
-  const packageJson = readPackageJson(packageRoot);
-  const specifier = packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName] ?? packageJson.optionalDependencies?.[packageName] ?? packageJson.peerDependencies?.[packageName];
-  const relative = localDependencyPath(specifier);
-  if (!relative) return void 0;
-  const candidate = path3.resolve(packageRoot, relative);
-  const linkedPackageJson = readPackageJson(candidate);
-  return linkedPackageJson.name === packageName ? candidate : void 0;
-}
-function localDependencyPath(specifier) {
-  if (!specifier) return void 0;
-  for (const prefix of ["link:", "file:"]) {
-    if (specifier.startsWith(prefix)) return specifier.slice(prefix.length);
-  }
-  return specifier.startsWith("./") || specifier.startsWith("../") ? specifier : void 0;
-}
-function isEsmModuleFile(file) {
-  const ext = path3.extname(file);
-  if (ext === ".mjs" || ext === ".mts") return true;
-  if (ext === ".cjs" || ext === ".cts") return false;
-  const packageRoot = nearestPackageRoot(path3.dirname(file));
-  return Boolean(packageRoot && readPackageJson(packageRoot).type === "module");
-}
-var esmEntryCache = /* @__PURE__ */ new Map();
-function isEsmModuleEntry(file) {
-  if (isEsmModuleFile(file)) return true;
-  if (path3.extname(file) !== ".js") return false;
-  const cached = esmEntryCache.get(file);
-  if (cached !== void 0) return cached;
-  let esm = false;
-  try {
-    esm = !isCommonJsModuleSource(readFileSync(file, "utf8"), file);
-  } catch {
-  }
-  esmEntryCache.set(file, esm);
-  return esm;
-}
-function isCommonJsModuleSource(source, file) {
-  const extension = path3.extname(file);
-  if (extension !== ".js" && extension !== ".cjs" || isEsmModuleFile(file)) return false;
-  return !/^\s*(?:import(?:\s|[{'"*])|export(?:\s|[{*]))/m.test(source);
-}
-function findWorkspaceRoot(root) {
-  const key = path3.resolve(root);
-  if (workspaceRootCache.has(key)) return workspaceRootCache.get(key);
-  let dir = key;
-  while (true) {
-    if (readPackageJson(dir).workspaces || existsSync3(path3.join(dir, "pnpm-workspace.yaml"))) {
-      workspaceRootCache.set(key, dir);
-      return dir;
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) {
-      workspaceRootCache.set(key, void 0);
-      return void 0;
-    }
-    dir = parent;
-  }
-}
-function isInside(root, file) {
-  const relative = path3.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
-}
-function workspacePackageDirs(root) {
-  const workspaces = readPackageJson(root).workspaces;
-  const patterns = [
-    ...Array.isArray(workspaces) ? workspaces : workspaces?.packages ?? [],
-    ...readPnpmWorkspacePatterns(root)
-  ];
-  const dirs = /* @__PURE__ */ new Set();
-  for (const pattern of patterns) {
-    if (pattern.startsWith("!")) continue;
-    const star = pattern.indexOf("*");
-    if (star === -1) {
-      dirs.add(path3.resolve(root, pattern));
-      continue;
-    }
-    const base = path3.resolve(root, pattern.slice(0, star));
-    if (!existsSync3(base)) continue;
-    for (const entry of readdirSync2(base, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      dirs.add(path3.join(base, entry.name, pattern.slice(star + 1)));
-    }
-  }
-  return [...dirs];
-}
-function readPnpmWorkspacePatterns(root) {
-  const file = path3.join(root, "pnpm-workspace.yaml");
-  if (!existsSync3(file)) return [];
-  const patterns = [];
-  let inPackages = false;
-  for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    if (/^packages\s*:\s*$/.test(trimmed)) {
-      inPackages = true;
-      continue;
-    }
-    if (!inPackages) continue;
-    const match = /^-\s*['"]?([^'"]+)['"]?\s*(?:#.*)?$/.exec(trimmed);
-    if (match?.[1]) {
-      patterns.push(match[1]);
-      continue;
-    }
-    if (/^\S/.test(line)) break;
-  }
-  return patterns;
-}
-var tsConfigCache = /* @__PURE__ */ new Map();
-var packageJsonCache = /* @__PURE__ */ new Map();
-var workspaceRootCache = /* @__PURE__ */ new Map();
-var workspacePackageCache = /* @__PURE__ */ new Map();
-function readTsConfig(root) {
-  const existing = tsConfigCache.get(root);
-  if (existing) return existing;
-  const file = tsConfigFileFor(root);
-  const config = (file ? readJsonc(file) : void 0) ?? {};
-  tsConfigCache.set(root, config);
-  return config;
-}
-function readPackageJson(root) {
-  const existing = packageJsonCache.get(root);
-  if (existing) return existing;
-  const config = readJson(path3.join(root, "package.json")) ?? {};
-  packageJsonCache.set(root, config);
-  return config;
-}
-function workspacePackages(root) {
-  const existing = workspacePackageCache.get(root);
-  if (existing) return existing;
-  const packages = /* @__PURE__ */ new Map();
-  for (const dir of workspacePackageDirs(root)) {
-    const packageJson = readPackageJson(dir);
-    if (packageJson.name) packages.set(packageJson.name, dir);
-  }
-  workspacePackageCache.set(root, packages);
-  return packages;
-}
-var workspaceMembershipCache = /* @__PURE__ */ new Map();
-function isWorkspacePackage(root, name, boundary) {
-  const key = `${path3.resolve(root)}\0${name}\0${boundary ?? ""}`;
-  const cached = workspaceMembershipCache.get(key);
-  if (cached !== void 0) return cached;
-  const workspaceRoot = boundary ? path3.resolve(boundary) : findWorkspaceRoot(root);
-  let member = Boolean(workspaceRoot && workspacePackages(workspaceRoot).has(name));
-  if (!member && !boundary) {
-    const packageRoot = findNodePackageRoot(path3.resolve(root), name);
-    const real = packageRoot ? realImportPath(packageRoot) : void 0;
-    const linkedRoot = real ? findWorkspaceRoot(real) : void 0;
-    const declared = linkedRoot ? workspacePackages(linkedRoot).get(name) : void 0;
-    member = Boolean(declared && realImportPath(declared) === real);
-  }
-  workspaceMembershipCache.set(key, member);
-  return member;
-}
-function workspacePackageRoots(root) {
-  return [...workspacePackages(path3.resolve(root)).values()].sort();
-}
-function readJson(file) {
-  if (!existsSync3(file)) return void 0;
-  return JSON.parse(readFileSync(file, "utf8"));
-}
-function readJsonc(file) {
-  if (!existsSync3(file)) return void 0;
-  return JSON.parse(stripTrailingCommas(stripJsonComments(readFileSync(file, "utf8"))));
-}
-function stripJsonComments(source) {
-  let output = "";
-  let inString = false;
-  let quote = "";
-  let escaped = false;
-  for (let index = 0; index < source.length; index += 1) {
-    const char = source[index];
-    const next = source[index + 1];
-    if (inString) {
-      output += char;
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      quote = char;
-      output += char;
-      continue;
-    }
-    if (char === "/" && next === "/") {
-      while (index < source.length && source[index] !== "\n") index += 1;
-      output += "\n";
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      index += 2;
-      while (index < source.length && !(source[index] === "*" && source[index + 1] === "/"))
-        index += 1;
-      index += 1;
-      continue;
-    }
-    output += char;
-  }
-  return output;
-}
-function stripTrailingCommas(source) {
-  let output = "";
-  let inString = false;
-  let quote = "";
-  let escaped = false;
-  for (let index = 0; index < source.length; index += 1) {
-    const char = source[index];
-    if (inString) {
-      output += char;
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      quote = char;
-      output += char;
-      continue;
-    }
-    if (char === ",") {
-      let nextIndex = index + 1;
-      while (/\s/.test(source[nextIndex] ?? "")) nextIndex += 1;
-      if (source[nextIndex] === "}" || source[nextIndex] === "]") continue;
-    }
-    output += char;
-  }
-  return output;
-}
-
-export {
-  cachedExistsSync,
-  escapeRegex,
-  specifierSniffTokens,
-  uniqueIdentifier,
-  isIdentifier,
-  esbuildEntryExportNames,
-  stripComments,
-  onExtensionHostReset,
-  restoreWithExtensionHost,
-  getCompatModeExtensions,
-  setCompatModeExtensions,
-  getRenderExtensions,
-  setRenderExtensions,
-  getRequestExtensions,
-  registerRequestInterceptors,
-  registerRequestWarmHooks,
-  registerOutsideBasePathInterceptors,
-  registerResponseFinalizers,
-  registerRevalidateBypassToken,
-  finalizeResponse,
-  setRequestExtensions,
-  reportRequestError,
-  setRuntimeExtensions,
-  withRouteRuntime,
-  getBuildExtensions,
-  setBuildCompatExtensions,
-  registerBuildSteps,
-  registerBuildCompleteHooks,
-  registerBuildParallelPhases,
-  registerInitHooks,
-  runInitHooks,
-  registerRouteConventions,
-  registerUsageDetectors,
-  registerRouteDependencyClassifiers,
-  registerClientEntryDetectors,
-  onLoadableExtensionsChanged,
-  registerLoadableExtensions,
-  extraLoadableExtensions,
-  registerPageExtensions,
-  registerAlwaysClientEntryReason,
-  alwaysClientEntryReasons,
-  extraPageExtensions,
-  extraBoundaryConventionNames,
-  sourceUsesRegisteredRequestApi,
-  classifyRouteDependencies,
-  sourceClientEntryReasons,
-  getProxyExtensions,
-  setProxyExtensions,
-  getBundlerExtensions,
-  serverDefineOptions,
-  registerServerSourceTransforms,
-  registerServerSourcePreTransforms,
-  registerClientSourceTransforms,
-  registerClientSourceAsyncPreTransforms,
-  registerBundledSourceTransforms,
-  withSniff,
-  sourceNeedsServerTransforms,
-  setBundlerExtensions,
-  applyServerSourcePreTransforms,
-  applyServerSourceTransforms,
-  applyClientSourceTransforms,
-  applyBundledSourceTransforms,
-  getImportAliasExtensions,
-  setImportAliasExtensions,
-  getProxyResponseProtocol,
-  setProxyResponseProtocol,
-  getRouterProtocolExtensions,
-  setRouterProtocolExtensions,
-  getAssetExtensions,
-  setAssetExtensions,
-  getCssExtensions,
-  setCssExtensions,
-  setResolveExtensions,
-  setExternalPackagePolicy,
-  getExternalPackagePolicy,
-  setExternalLoadResolver,
-  resolveExternalLoadTarget,
-  packageNameOfSpecifier,
-  packageNameForFile,
-  externalPackageImportTarget,
-  setTsConfigPath,
-  setModuleAliases,
-  resolveModuleAlias,
-  resolveImport,
-  resolveConfiguredTsPath,
-  configuredTsPathPatterns,
-  resolutionRootForFile,
-  resolveNestedPackageFromImporter,
-  provideEntryResolution,
-  providedEntryResolution,
-  resolvePackageSpecifier,
-  resolveVendorPackageSpecifier,
-  resolvePackageImportSpecifier,
-  resolveRuntimeSpecifier,
-  isPackageSubpathUnexported,
-  resolveLinkedPackageSpecifier,
-  isEsmModuleFile,
-  isEsmModuleEntry,
-  isCommonJsModuleSource,
-  findWorkspaceRoot,
-  isWorkspacePackage,
-  workspacePackageRoots
-};