@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,11 @@
+// @bun
+// src/routing/request-environment.ts
+var current;
+function setRequestRuntime(runtime) {
+  current = runtime;
+}
+function getRequestRuntime() {
+  return current;
+}
+
+export { setRequestRuntime, getRequestRuntime };

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

@@ -0,0 +1,666 @@
+// @bun
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+
+// 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 ANCHOR = Symbol.for("pnext.extensionHost");
+globalThis[ANCHOR] ??= activeHost;
+var resetHandlers = [];
+var clientEntryReasonCache = 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: () => {
+      return;
+    }
+  };
+}
+function getCompatModeExtensions() {
+  return activeHost.compatMode;
+}
+function setCompatModeExtensions(overrides) {
+  Object.assign(activeHost.compatMode, overrides);
+}
+function createRenderExtensions() {
+  return {
+    clientRouteState: (_route, state) => state,
+    wrapServerComponentInvoke: (invoke) => invoke(),
+    onRenderInit: () => {
+      return;
+    },
+    serializeServerActionProp: () => {
+      return;
+    },
+    collectRenderMeta: async (produce, _options) => ({ value: await produce(), tags: [] }),
+    currentCacheStaleSeconds: () => {
+      return;
+    },
+    genericErrorTitle: () => {
+      return;
+    },
+    islandCommentWireFormat: () => false,
+    serializeError: () => {
+      return;
+    },
+    httpAccessFallbackUi: () => {
+      return;
+    },
+    defaultGlobalErrorUi: () => {
+      return;
+    },
+    globalErrorReportScript: () => {
+      return;
+    },
+    wrapThrownValue: () => {
+      return;
+    },
+    formatErrorLog: () => {
+      return;
+    },
+    globalNotFoundEnabled: () => false,
+    trackVaryParams: (value) => value,
+    legacySyncProps: (promise) => promise,
+    prerenderSidecar: {
+      begin: () => {
+        return;
+      },
+      collect: () => Promise.resolve(undefined),
+      persist: () => Promise.resolve(),
+      seed: () => {
+        return;
+      },
+      isStale: () => false
+    }
+  };
+}
+function getRenderExtensions() {
+  return activeHost.render;
+}
+function setRenderExtensions(overrides) {
+  Object.assign(activeHost.render, overrides);
+}
+function createRequestExtensions() {
+  return {
+    interceptors: [],
+    warmHooks: [],
+    outsideBasePathInterceptors: [],
+    responseFinalizers: [],
+    onRequestError: () => {
+      return;
+    },
+    staticStaleness: () => false,
+    staticStalenessReason: () => {
+      return;
+    },
+    onDemandRevalidatePath: () => {
+      return;
+    },
+    revalidateBypassToken: () => {
+      return;
+    }
+  };
+}
+function getRequestExtensions() {
+  return activeHost.request;
+}
+function registerRequestInterceptors(...interceptors) {
+  activeHost.request.interceptors.push(...interceptors);
+}
+function registerRequestWarmHooks(...hooks) {
+  activeHost.request.warmHooks.push(...hooks);
+}
+function runRequestWarmHooks(config) {
+  for (const hook of activeHost.request.warmHooks) {
+    try {
+      hook(config);
+    } catch {}
+  }
+}
+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 = 31536000;
+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 : undefined;
+  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 === undefined) {
+    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: () => {
+      return;
+    },
+    nextScriptWorkersEnabled: () => false,
+    defaultExpireTimeSeconds: () => {
+      return;
+    },
+    takeCacheLifeStash: () => {
+      return;
+    },
+    takeFontLinkHeader: () => {
+      return;
+    },
+    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 !== undefined ? { 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 !== undefined && options.bodySizeBytes <= (options.inlineBudgetBytes ?? 32 * 1024);
+      return {
+        status: options.status,
+        staleTime: options.staleTime,
+        postponed: options.postponed,
+        segmentPaths: ["/_tree", "/"],
+        ...options.bodySizeBytes !== undefined ? { segmentSizes: { "/": options.bodySizeBytes } } : {},
+        ...inlined ? { inlinedSegmentPaths: ["/"] } : {},
+        ...options.prefetchHints ? { prefetchHints: options.prefetchHints } : {}
+      };
+    },
+    diagnoseCacheComponentsPrerender: () => {
+      return;
+    },
+    prerenderFailureFooter: () => "",
+    diagnosticLeadsWithErrorLine: () => false,
+    recordBuildFlags: () => {
+      return;
+    },
+    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 = new WeakMap;
+function clearBuildParallelPhases() {
+  activeHost.build.parallelPhases.length = 0;
+}
+function buildParallelPhaseError() {
+  for (const phase of activeHost.build.parallelPhases) {
+    if (parallelPhaseErrors.has(phase))
+      return parallelPhaseErrors.get(phase);
+  }
+  return;
+}
+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: 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 [...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}\x00${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) => {
+      return;
+    },
+    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: () => {
+      return;
+    },
+    serverDefines: () => ({}),
+    clientDefines: () => ({}),
+    clientInjects: () => [],
+    resolveRouteDependency: () => {
+      return;
+    },
+    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 = undefined;
+}
+function registerServerSourcePreTransforms(...transforms) {
+  activeHost.bundler.serverSourcePreTransforms.push(...transforms);
+  activeHost.serverSniff = undefined;
+}
+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 = new Set;
+  for (const transform of [
+    ...host.bundler.serverSourcePreTransforms,
+    ...host.bundler.serverSourceTransforms
+  ]) {
+    if (!transform.sniff)
+      return host.serverSniff = { pattern: undefined };
+    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 hasClientSourceAsyncPreTransforms() {
+  return activeHost.bundler.clientSourceAsyncPreTransforms.length > 0;
+}
+async function applyClientSourceAsyncPreTransforms(source, file, root) {
+  let next = source;
+  for (const transform of activeHost.bundler.clientSourceAsyncPreTransforms) {
+    if (transform.sniff && !sniffHit(next, transform.sniff))
+      continue;
+    next = await transform(next, file, root);
+  }
+  return next;
+}
+function applyBundledSourceTransforms(source, file) {
+  return applyTransforms(activeHost.bundler.bundledSourceTransforms, source, file);
+}
+function createImportAliasExtensions() {
+  return {
+    aliases: () => ({}),
+    clientSsrAliases: () => ({}),
+    missingImportError: () => {
+      return;
+    },
+    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 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: () => {
+      return;
+    },
+    hasLoaderRuleFor: () => false,
+    loaderRuleModule: () => {
+      return;
+    }
+  };
+}
+function getAssetExtensions() {
+  return activeHost.asset;
+}
+function setAssetExtensions(overrides) {
+  Object.assign(activeHost.asset, overrides);
+}
+var cssExtensions = {
+  extraCssExtensions: () => [],
+  resolveCssDependency: () => {
+    return;
+  },
+  deferRootNotFoundCss: () => false,
+  inlineStylesheets: () => {
+    return;
+  },
+  cssChunkPlugins: () => [],
+  resolveCssModule: () => {
+    return;
+  },
+  loadCssModuleForClient: () => {
+    return;
+  },
+  planRouteCssChunks: () => new Map
+};
+restoreWithExtensionHost(cssExtensions);
+function getCssExtensions() {
+  return cssExtensions;
+}
+function setCssExtensions(overrides) {
+  Object.assign(cssExtensions, overrides);
+}
+
+export { onExtensionHostReset, restoreWithExtensionHost, getCompatModeExtensions, setCompatModeExtensions, getRenderExtensions, setRenderExtensions, getRequestExtensions, registerRequestInterceptors, registerRequestWarmHooks, runRequestWarmHooks, registerOutsideBasePathInterceptors, registerResponseFinalizers, registerRevalidateBypassToken, finalizeResponse, setRequestExtensions, reportRequestError, setRuntimeExtensions, withRouteRuntime, getBuildExtensions, setBuildCompatExtensions, registerBuildSteps, registerBuildCompleteHooks, registerBuildParallelPhases, clearBuildParallelPhases, buildParallelPhaseError, 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, hasClientSourceAsyncPreTransforms, applyClientSourceAsyncPreTransforms, applyBundledSourceTransforms, getImportAliasExtensions, setImportAliasExtensions, setProxyResponseProtocol, getRouterProtocolExtensions, setRouterProtocolExtensions, getAssetExtensions, setAssetExtensions, getCssExtensions, setCssExtensions };