@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-d1jsmhhk.js

@@ -0,0 +1,955 @@
+// @bun
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  findWorkspaceRoot,
+  readPackageJson
+} from "./index-pym1cezq.js";
+import {
+  splitResourceQuery
+} from "./index-jt8e1pje.js";
+import {
+  onExtensionHostReset
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/resolve/engine.ts
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+
+// src/utils/fs-cache.ts
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+var NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+var dirents = new Map;
+function direntsFor(dir) {
+  if (dirents.has(dir))
+    return dirents.get(dir);
+  let names;
+  try {
+    names = new Set(readdirSync(dir));
+  } catch {
+    names = undefined;
+  }
+  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;
+}
+function clearNodeModulesFsCache() {
+  dirents.clear();
+}
+
+// src/resolve/engine.ts
+function createResolverFactory(options) {
+  const { ResolverFactory: Factory } = loadNative(() => __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 = new Map;
+var tsConfigFiles = new Map;
+function setEngineExtensions(extensions) {
+  configuredExtensions = extensions && extensions.length > 0 ? [...extensions] : undefined;
+  resetEngine();
+}
+function setEngineTsConfigPath(file) {
+  configuredTsConfigPath = file;
+  resetEngine();
+}
+function resetEngine() {
+  baseFactory = undefined;
+  factories.clear();
+  tsConfigFiles.clear();
+  nodeModulesOutcomes.clear();
+}
+function clearResolverFsCache() {
+  baseFactory?.clearCache();
+  for (const factory of factories.values())
+    factory.clearCache();
+  nodeModulesOutcomes.clear();
+  clearNodeModulesFsCache();
+}
+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 resolveFrom(dir, specifier, conditions, tsConfigRoot) {
+  const { path: request } = splitResourceQuery(specifier);
+  const tsconfig = tsConfigRoot ? tsConfigFileFor(tsConfigRoot) : undefined;
+  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, undefined, sourceAlias);
+  return outcome && "path" in outcome ? outcome.path : undefined;
+}
+var nodeModulesOutcomes = 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}\x00${request}\x00${conditions.join(",")}\x00${tsconfig ?? ""}\x00${sourceAlias}` : undefined;
+  if (key !== undefined && nodeModulesOutcomes.has(key))
+    return nodeModulesOutcomes.get(key);
+  const { path: file, error } = resolverFor(conditions, tsconfig, sourceAlias).sync(dir, request);
+  const outcome = file ? isDeclarationFile(file) ? undefined : { path: file } : error?.includes("is not exported") ? { notExported: true } : undefined;
+  if (key !== undefined)
+    nodeModulesOutcomes.set(key, outcome);
+  return outcome;
+}
+function isSourceRequest(request) {
+  return request.startsWith(".") || path2.isAbsolute(request);
+}
+function resolverFor(conditions, tsconfig, sourceExtensionAlias) {
+  const key = `${conditions.join(",")}\x00${tsconfig ?? ""}\x00${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,
+    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);
+}
+
+// src/resolve/imports.ts
+import { existsSync as existsSync3, readFileSync, readdirSync as readdirSync2, realpathSync } from "fs";
+import path3 from "path";
+var { Bun: bun } = 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 = new Map;
+function resolveExternalLoadTarget(context) {
+  if (!externalLoadResolver)
+    return;
+  if (context.specifier.startsWith("#"))
+    return externalLoadResolver(context);
+  const resolveContext = context.fromFile.includes(`${path3.sep}node_modules${path3.sep}`) ? { ...context, root: path3.dirname(context.fromFile) } : context;
+  const key = `${context.target}\x00${resolutionRootForFile(resolveContext.root, context.fromFile)}\x00${context.specifier}`;
+  if (externalLoadTargets.has(key))
+    return externalLoadTargets.get(key);
+  const target = externalLoadResolver(resolveContext);
+  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 : undefined;
+}
+function externalPackageImportTarget(root, fromFile, specifier) {
+  const packageName = packageNameFromSpecifier(specifier);
+  if (!packageName)
+    return;
+  const policy = getExternalPackagePolicy();
+  if (!policy.external(packageName) || policy.esmExternals() !== true)
+    return;
+  const imported = resolvePackageSpecifier(root, fromFile, specifier, ["import", "node", "default"]);
+  if (!imported || isEsmModuleFile(imported))
+    return;
+  const required = resolvePackageSpecifier(root, fromFile, specifier, [
+    "require",
+    "node",
+    "default"
+  ]);
+  return required && required !== imported ? required : undefined;
+}
+function setTsConfigPath(file) {
+  setEngineTsConfigPath(file);
+  tsConfigCache.clear();
+  clearVendorPackageResolutions();
+}
+var extraModuleAliases;
+onExtensionHostReset(() => {
+  extraModuleAliases = undefined;
+  clearVendorPackageResolutions();
+});
+function setModuleAliases(aliases) {
+  extraModuleAliases = aliases;
+}
+function resolveModuleAlias(specifier) {
+  const aliased = extraModuleAliases?.[specifier];
+  return aliased ? probeFile(aliased, localConditions) : undefined;
+}
+function resolveImport(root, fromFile, specifier, workspaceRoot) {
+  if (splitResourceQuery(specifier).query)
+    return;
+  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) : undefined;
+  }
+  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 : undefined;
+}
+var realImportPathCache = new Map;
+function realImportPath(file) {
+  const cached = realImportPathCache.get(file);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const real = realpathSync(file);
+    realImportPathCache.set(file, real);
+    return real;
+  } catch {
+    return file;
+  }
+}
+var appTreeResolveCache = 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}\x00${root}\x00${from}\x00${specifier}`;
+  if (memoAppTree) {
+    const cached = appTreeResolveCache.get(key);
+    if (cached !== undefined)
+      return cached;
+  }
+  const outcome = resolveFrom(from, specifier, localConditions, resolutionRoot);
+  if (!outcome || !("path" in outcome))
+    return;
+  const resolved = isAppTreeFile(path3.resolve(root), outcome.path) ? outcome.path : undefined;
+  if (memoAppTree && resolved !== undefined)
+    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;
+  }
+  return resolveTsPath(resolutionRootForFile(root, fromFile), specifier);
+}
+function configuredTsPathPatterns(root, workspaceRoot) {
+  const roots = 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 = 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;
+}
+function resolveWorkspacePackageImport(root, specifier, boundary) {
+  const workspaceRoot = boundary ? path3.resolve(boundary) : findWorkspaceRoot(root);
+  if (!workspaceRoot)
+    return;
+  const packageName = packageNameFromSpecifier(specifier);
+  if (!packageName)
+    return;
+  const packageRoot = workspacePackages(workspaceRoot).get(packageName);
+  if (!packageRoot)
+    return;
+  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;
+}
+function packageExportTarget(exports, subpath) {
+  if (!exports)
+    return;
+  if (!isSubpathExports(exports))
+    return subpath === "." ? packageTargetPath(exports) : undefined;
+  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;
+}
+function packageExportTargetForConditions(exports, subpath, conditions) {
+  if (!exports)
+    return;
+  if (!isSubpathExports(exports)) {
+    return subpath === "." ? packageTargetPathForConditions(exports, conditions) : undefined;
+  }
+  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;
+}
+function packageTargetPathForConditions(target, conditions) {
+  if (!target)
+    return;
+  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;
+  }
+  if (!isPackageExportObject(target))
+    return;
+  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;
+}
+function isSubpathExports(exports) {
+  return isPackageExportObject(exports) && Object.keys(exports).some((key) => key.startsWith("."));
+}
+function packageTargetPath(target) {
+  if (!target)
+    return;
+  if (typeof target === "string")
+    return target;
+  if (Array.isArray(target)) {
+    for (const item of target) {
+      const resolved = packageTargetPath(item);
+      if (resolved)
+        return resolved;
+    }
+    return;
+  }
+  if (!isPackageExportObject(target))
+    return;
+  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;
+}
+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;
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+    return;
+  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]}` : undefined;
+  return parts[0] || undefined;
+}
+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;
+  const from = path3.dirname(realImportPath(path3.resolve(importerFile)));
+  return realLinkedPackageFile(resolvePackageFrom(from, packageName, specifier, conditions));
+}
+var packageRoots = 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 = new Map;
+function provideEntryResolution(specifier, resolveDir, resolved) {
+  vendorEntryProvisions.set(`${specifier}\x00${resolveDir}`, resolved);
+}
+function providedEntryResolution(specifier, resolveDir) {
+  return vendorEntryProvisions.get(`${specifier}\x00${resolveDir}`);
+}
+function resolvePackageSpecifier(root, fromFile, specifier, conditions) {
+  const packageName = packageNameFromSpecifier(specifier);
+  if (!packageName)
+    return;
+  const from = resolutionRootForFile(root, fromFile);
+  return realLinkedPackageFile(resolvePackageFrom(from, packageName, specifier, conditions));
+}
+var vendorPackageResolutions = new Map;
+function resolveVendorPackageSpecifier(root, fromFile, specifier, conditions) {
+  const packageName = packageNameFromSpecifier(specifier);
+  if (!packageName)
+    return;
+  const from = resolutionRootForFile(root, fromFile);
+  const key = `${from}\x00${specifier}\x00${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 clearAppTreeResolutions() {
+  appTreeResolveCache.clear();
+  externalLoadTargets.clear();
+}
+function resolvePackageImportSpecifier(root, fromFile, specifier, conditions) {
+  if (!specifier.startsWith("#"))
+    return;
+  const from = nearestPackageRoot(path3.dirname(fromFile)) ?? resolutionRootForFile(root, fromFile);
+  const outcome = resolveFrom(from, specifier, conditions);
+  return outcome && "path" in outcome ? outcome.path : undefined;
+}
+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;
+  return onDiskSubpath(packageRoot, subpathOfSpecifier(packageName, specifier), conditions);
+}
+function onDiskSubpath(packageRoot, subpath, conditions) {
+  if (subpath === ".")
+    return;
+  const resolved = probePackageTarget(path3.resolve(packageRoot, subpath.slice(2)), conditions);
+  return resolved && isInside(packageRoot, resolved) ? resolved : undefined;
+}
+var runtimeResolveCache = new Map;
+function resolveRuntimeSpecifier(dir, specifier) {
+  const key = `${dir}\x00${specifier}`;
+  const cached = runtimeResolveCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const resolved = bun.resolveSync(specifier, dir);
+    runtimeResolveCache.set(key, resolved);
+    return resolved;
+  } catch {
+    return;
+  }
+}
+var linkedPackageFileCache = new Map;
+function realLinkedPackageFile(file) {
+  if (!file)
+    return file;
+  const cached = linkedPackageFileCache.get(file);
+  if (cached !== undefined)
+    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;
+  const packageRoot = findLinkedPackageRoot(resolutionRootForFile(root, fromFile), packageName);
+  if (!packageRoot)
+    return;
+  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;
+}
+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;
+    dir = parent;
+  }
+}
+var linkedPackageRootCache = 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)}\x00${packageName}`;
+  const cached = linkedPackageRootCache.get(key);
+  if (cached !== undefined || 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;
+    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;
+  const candidate = path3.resolve(packageRoot, relative);
+  const linkedPackageJson = readPackageJson(candidate);
+  return linkedPackageJson.name === packageName ? candidate : undefined;
+}
+function localDependencyPath(specifier) {
+  if (!specifier)
+    return;
+  for (const prefix of ["link:", "file:"]) {
+    if (specifier.startsWith(prefix))
+      return specifier.slice(prefix.length);
+  }
+  return specifier.startsWith("./") || specifier.startsWith("../") ? specifier : undefined;
+}
+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 = new Map;
+function isEsmModuleEntry(file) {
+  if (isEsmModuleFile(file))
+    return true;
+  if (path3.extname(file) !== ".js")
+    return false;
+  const cached = esmEntryCache.get(file);
+  if (cached !== undefined)
+    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 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 = 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 = new Map;
+var workspacePackageCache = new Map;
+function readTsConfig(root) {
+  const existing = tsConfigCache.get(root);
+  if (existing)
+    return existing;
+  const file = tsConfigFileFor(root);
+  const config = (file ? readJsonc(file) : undefined) ?? {};
+  tsConfigCache.set(root, config);
+  return config;
+}
+function workspacePackages(root) {
+  const existing = workspacePackageCache.get(root);
+  if (existing)
+    return existing;
+  const packages = 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 = new Map;
+function isWorkspacePackage(root, name, boundary) {
+  const key = `${path3.resolve(root)}\x00${name}\x00${boundary ?? ""}`;
+  const cached = workspaceMembershipCache.get(key);
+  if (cached !== undefined)
+    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) : undefined;
+    const linkedRoot = real ? findWorkspaceRoot(real) : undefined;
+    const declared = linkedRoot ? workspacePackages(linkedRoot).get(name) : undefined;
+    member = Boolean(declared && realImportPath(declared) === real);
+  }
+  workspaceMembershipCache.set(key, member);
+  return member;
+}
+function workspacePackageRoots(root) {
+  return [...workspacePackages(path3.resolve(root)).values()].sort();
+}
+function readJsonc(file) {
+  if (!existsSync3(file))
+    return;
+  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] !== `
+`)
+        index += 1;
+      output += `
+`;
+      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, clearResolverFsCache, setResolveExtensions, setExternalPackagePolicy, getExternalPackagePolicy, setExternalLoadResolver, resolveExternalLoadTarget, packageNameOfSpecifier, packageNameForFile, externalPackageImportTarget, setTsConfigPath, setModuleAliases, resolveModuleAlias, resolveImport, resolveConfiguredTsPath, configuredTsPathPatterns, resolutionRootForFile, resolveNestedPackageFromImporter, provideEntryResolution, providedEntryResolution, resolvePackageSpecifier, resolveVendorPackageSpecifier, clearAppTreeResolutions, resolvePackageImportSpecifier, resolveRuntimeSpecifier, isPackageSubpathUnexported, resolveLinkedPackageSpecifier, isEsmModuleFile, isEsmModuleEntry, isCommonJsModuleSource, isWorkspacePackage, workspacePackageRoots };