nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133849-ca1a9dee

package/dist/_libs/unplugin+unimport.d.mts

@@ -0,0 +1,426 @@
+import { t as MagicString } from "./magic-string.mjs";
+import { t as ESMExport } from "./mlly.mjs";
+import "vite";
+import "rolldown";
+import "rollup";
+import "webpack";
+import "@farmfe/core";
+import "@rspack/core";
+import "unloader";
+
+//#region node_modules/.pnpm/unplugin-utils@0.3.1/node_modules/unplugin-utils/dist/index.d.ts
+//#region src/filter.d.ts
+/**
+* A valid `picomatch` glob pattern, or array of patterns.
+*/
+type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+/**
+* Constructs a filter function which can be used to determine whether or not
+* certain modules should be operated upon.
+* @param include If `include` is omitted or has zero length, filter will return `true` by default.
+* @param exclude ID must not match any of the `exclude` patterns.
+* @param options Additional options.
+* @param options.resolve Optionally resolves the patterns against a directory other than `process.cwd()`.
+* If a `string` is specified, then the value will be used as the base directory.
+* Relative paths will be resolved against `process.cwd()` first.
+* If `false`, then the patterns will not be resolved against any directory.
+* This can be useful if you want to create a filter for virtual module names.
+*/
+//#endregion
+//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/shared/unimport.C0UbTDPO.d.mts
+declare const builtinPresets: {
+  '@vue/composition-api': InlinePreset;
+  '@vueuse/core': () => Preset;
+  '@vueuse/head': InlinePreset;
+  pinia: InlinePreset;
+  preact: InlinePreset;
+  quasar: InlinePreset;
+  react: InlinePreset;
+  'react-router': InlinePreset;
+  'react-router-dom': InlinePreset;
+  svelte: InlinePreset;
+  'svelte/animate': InlinePreset;
+  'svelte/easing': InlinePreset;
+  'svelte/motion': InlinePreset;
+  'svelte/store': InlinePreset;
+  'svelte/transition': InlinePreset;
+  'vee-validate': InlinePreset;
+  vitepress: InlinePreset;
+  'vue-demi': InlinePreset;
+  'vue-i18n': InlinePreset;
+  'vue-router': InlinePreset;
+  'vue-router-composables': InlinePreset;
+  vue: InlinePreset;
+  'vue/macros': InlinePreset;
+  vuex: InlinePreset;
+  vitest: InlinePreset;
+  'uni-app': InlinePreset;
+  'solid-js': InlinePreset;
+  'solid-app-router': InlinePreset;
+  rxjs: InlinePreset;
+  'date-fns': InlinePreset;
+};
+type BuiltinPresetName = keyof typeof builtinPresets;
+type ModuleId = string;
+type ImportName = string;
+interface ImportCommon {
+  /** Module specifier to import from */
+  from: ModuleId;
+  /**
+       * Priority of the import, if multiple imports have the same name, the one with the highest priority will be used
+       * @default 1
+       */
+  priority?: number;
+  /** If this import is disabled */
+  disabled?: boolean;
+  /** Won't output import in declaration file if true */
+  dtsDisabled?: boolean;
+  /** Import declaration type like const / var / enum */
+  declarationType?: ESMExport['declarationType'];
+  /**
+       * Metadata of the import
+       */
+  meta?: {
+    /** Short description of the import */description?: string; /** URL to the documentation */
+    docsUrl?: string; /** Additional metadata */
+    [key: string]: any;
+  };
+  /**
+       * If this import is a pure type import
+       */
+  type?: boolean;
+  /**
+       * Using this as the from when generating type declarations
+       */
+  typeFrom?: ModuleId;
+}
+interface Import extends ImportCommon {
+  /** Import name to be detected */
+  name: ImportName;
+  /** Import as this name */
+  as?: ImportName;
+  /**
+       * With properties
+       *
+       * Ignored for CJS imports.
+       */
+  with?: Record<string, string>;
+}
+type PresetImport = Omit<Import, 'from'> | ImportName | [name: ImportName, as?: ImportName, from?: ModuleId];
+interface InlinePreset extends ImportCommon {
+  imports: (PresetImport | InlinePreset)[];
+}
+/**
+ * Auto extract exports from a package for auto import
+ */
+interface PackagePreset {
+  /**
+       * Name of the package
+       */
+  package: string;
+  /**
+       * Path of the importer
+       * @default process.cwd()
+       */
+  url?: string;
+  /**
+       * RegExp, string, or custom function to exclude names of the extracted imports
+       */
+  ignore?: (string | RegExp | ((name: string) => boolean))[];
+  /**
+       * Use local cache if exits
+       * @default true
+       */
+  cache?: boolean;
+}
+type Preset = InlinePreset | PackagePreset;
+interface UnimportContext {
+  readonly version: string;
+  options: Partial<UnimportOptions>;
+  staticImports: Import[];
+  dynamicImports: Import[];
+  addons: Addon[];
+  getImports: () => Promise<Import[]>;
+  getImportMap: () => Promise<Map<string, Import>>;
+  getMetadata: () => UnimportMeta | undefined;
+  modifyDynamicImports: (fn: (imports: Import[]) => Thenable<void | Import[]>) => Promise<void>;
+  clearDynamicImports: () => void;
+  replaceImports: (imports: UnimportOptions['imports']) => Promise<Import[]>;
+  invalidate: () => void;
+  resolveId: (id: string, parentId?: string) => Thenable<string | null | undefined | void>;
+}
+interface DetectImportResult {
+  s: MagicString;
+  strippedCode: string;
+  isCJSContext: boolean;
+  matchedImports: Import[];
+  firstOccurrence: number;
+}
+interface Unimport {
+  readonly version: string;
+  init: () => Promise<void>;
+  clearDynamicImports: UnimportContext['clearDynamicImports'];
+  getImportMap: UnimportContext['getImportMap'];
+  getImports: UnimportContext['getImports'];
+  getInternalContext: () => UnimportContext;
+  getMetadata: UnimportContext['getMetadata'];
+  modifyDynamicImports: UnimportContext['modifyDynamicImports'];
+  generateTypeDeclarations: (options?: TypeDeclarationOptions) => Promise<string>;
+  /**
+       * Get un-imported usages from code
+       */
+  detectImports: (code: string | MagicString) => Promise<DetectImportResult>;
+  /**
+       * Insert missing imports statements to code
+       */
+  injectImports: (code: string | MagicString, id?: string, options?: InjectImportsOptions) => Promise<ImportInjectionResult>;
+  scanImportsFromDir: (dir?: (string | ScanDir)[], options?: ScanDirExportsOptions) => Promise<Import[]>;
+  scanImportsFromFile: (file: string, includeTypes?: boolean) => Promise<Import[]>;
+  /**
+       * @deprecated
+       */
+  toExports: (filepath?: string, includeTypes?: boolean) => Promise<string>;
+}
+interface InjectionUsageRecord {
+  import: Import;
+  count: number;
+  moduleIds: string[];
+}
+interface UnimportMeta {
+  injectionUsage: Record<string, InjectionUsageRecord>;
+}
+interface AddonsOptions {
+  addons?: Addon[];
+  /**
+       * Enable auto import inside for Vue's <template>
+       *
+       * @default false
+       */
+  vueTemplate?: boolean;
+  /**
+       * Enable auto import directives for Vue's SFC.
+       *
+       * Library authors should include `meta.vueDirective: true` in the import metadata.
+       *
+       * When using a local directives folder, provide the `isDirective`
+       * callback to check if the import is a Vue directive.
+       */
+  vueDirectives?: true | AddonVueDirectivesOptions;
+}
+interface AddonVueDirectivesOptions {
+  /**
+       * Checks if the import is a Vue directive.
+       *
+       * **NOTES**:
+       * - imports from a library should include `meta.vueDirective: true`.
+       * - this callback is only invoked for local directives (only when meta.vueDirective is not set).
+       *
+       * @param from The path of the import normalized.
+       * @param importEntry The import entry.
+       */
+  isDirective?: (from: string, importEntry: Import) => boolean;
+}
+interface UnimportOptions extends Pick<InjectImportsOptions, 'injectAtEnd' | 'mergeExisting' | 'parser'> {
+  /**
+       * Auto import items
+       */
+  imports: Import[];
+  /**
+       * Auto import preset
+       */
+  presets: (Preset | BuiltinPresetName)[];
+  /**
+       * Custom warning function
+       * @default console.warn
+       */
+  warn: (msg: string) => void;
+  /**
+       * Custom debug log function
+       * @default console.log
+       */
+  debugLog: (msg: string) => void;
+  /**
+       * Unimport Addons.
+       * To use built-in addons, use:
+       * ```js
+       * addons: {
+       *   addons: [<custom-addons-here>] // if you want to use also custom addons
+       *   vueTemplate: true,
+       *   vueDirectives: [<the-directives-here>]
+       * }
+       * ```
+       *
+       * Built-in addons:
+       * - vueDirectives: enable auto import directives for Vue's SFC
+       * - vueTemplate: enable auto import inside for Vue's <template>
+       *
+       * @default {}
+       */
+  addons: AddonsOptions | Addon[];
+  /**
+       * Name of virtual modules that exposed all the registed auto-imports
+       * @default []
+       */
+  virtualImports: string[];
+  /**
+       * Directories to scan for auto import
+       * @default []
+       */
+  dirs?: (string | ScanDir)[];
+  /**
+       * Options for scanning directories for auto import
+       */
+  dirsScanOptions?: ScanDirExportsOptions;
+  /**
+       * Custom resolver to auto import id
+       */
+  resolveId?: (id: string, importee?: string) => Thenable<string | void>;
+  /**
+       * Custom magic comments to be opt-out for auto import, per file/module
+       *
+       * @default ['@unimport-disable', '@imports-disable']
+       */
+  commentsDisable?: string[];
+  /**
+       * Custom magic comments to debug auto import, printed to console
+       *
+       * @default ['@unimport-debug', '@imports-debug']
+       */
+  commentsDebug?: string[];
+  /**
+       * Collect meta data for each auto import. Accessible via `ctx.meta`
+       */
+  collectMeta?: boolean;
+}
+type PathFromResolver = (_import: Import) => string | undefined;
+interface ScanDirExportsOptions {
+  /**
+       * Glob patterns for matching files
+       *
+       * @default ['*.{ts,js,mjs,cjs,mts,cts,tsx,jsx}']
+       */
+  filePatterns?: string[];
+  /**
+       * Custom function to filter scanned files
+       */
+  fileFilter?: (file: string) => boolean;
+  /**
+       * Register type exports
+       *
+       * @default true
+       */
+  types?: boolean;
+  /**
+       * Current working directory
+       *
+       * @default process.cwd()
+       */
+  cwd?: string;
+}
+interface ScanDir {
+  /**
+       * Path pattern of the directory
+       */
+  glob: string;
+  /**
+       * Register type exports
+       *
+       * @default true
+       */
+  types?: boolean;
+}
+interface TypeDeclarationOptions {
+  /**
+       * Custom resolver for path of the import
+       */
+  resolvePath?: PathFromResolver;
+  /**
+       * Append `export {}` to the end of the file
+       *
+       * @default true
+       */
+  exportHelper?: boolean;
+  /**
+       * Auto-import for type exports
+       *
+       * @default true
+       */
+  typeReExports?: boolean;
+}
+interface InjectImportsOptions {
+  /**
+       * Merge the existing imports
+       *
+       * @default false
+       */
+  mergeExisting?: boolean;
+  /**
+       * If the module should be auto imported
+       *
+       * @default true
+       */
+  autoImport?: boolean;
+  /**
+       * If the module should be transformed for virtual modules.
+       * Only available when `virtualImports` is set.
+       *
+       * @default true
+       */
+  transformVirtualImports?: boolean;
+  /**
+       * Parser to use for parsing the code
+       *
+       * Note that `acorn` only takes valid JS Code, should usually only be used after transformationa and transpilation
+       *
+       * @default 'regex'
+       */
+  parser?: 'acorn' | 'regex';
+  /**
+       * Inject the imports at the end of other imports
+       *
+       * @default false
+       */
+  injectAtEnd?: boolean;
+}
+type Thenable<T> = Promise<T> | T;
+interface Addon {
+  name?: string;
+  transform?: (this: UnimportContext, code: MagicString, id: string | undefined) => Thenable<MagicString>;
+  declaration?: (this: UnimportContext, dts: string, options: TypeDeclarationOptions) => Thenable<string>;
+  matchImports?: (this: UnimportContext, identifiers: Set<string>, matched: Import[]) => Thenable<Import[] | void>;
+  /**
+       * Extend or modify the imports list before injecting
+       */
+  extendImports?: (this: UnimportContext, imports: Import[]) => Import[] | void;
+  /**
+       * Resolve imports before injecting
+       */
+  injectImportsResolved?: (this: UnimportContext, imports: Import[], code: MagicString, id?: string) => Import[] | void;
+  /**
+       * Modify the injection code before injecting
+       */
+  injectImportsStringified?: (this: UnimportContext, injection: string, imports: Import[], code: MagicString, id?: string) => string | void;
+}
+interface MagicStringResult {
+  s: MagicString;
+  code: string;
+}
+interface ImportInjectionResult extends MagicStringResult {
+  imports: Import[];
+}
+//#endregion
+//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/unplugin.d.mts
+interface UnimportPluginOptions extends UnimportOptions {
+  include: FilterPattern;
+  exclude: FilterPattern;
+  dts: boolean | string;
+  /**
+       * Enable implicit auto import.
+       * Generate global TypeScript definitions.
+       *
+       * @default true
+       */
+  autoImport?: boolean;
+}
+//#endregion
+export { type Unimport as n, type UnimportPluginOptions as t };

package/dist/_libs/unwasm.d.mts

@@ -0,0 +1,29 @@
+import { Plugin } from "rollup";
+
+//#region node_modules/.pnpm/unwasm@0.5.3/node_modules/unwasm/dist/plugin/index.d.mts
+//#region src/plugin/shared.d.ts
+interface UnwasmPluginOptions {
+  /**
+     * Directly import the `.wasm` files instead of bundling as base64 string.
+     *
+     * @default false
+     */
+  esmImport?: boolean;
+  /**
+     * Avoid using top level await and always use a proxy.
+     *
+     * Useful for compatibility with environments that don't support top level await.
+     *
+     * @default false
+     */
+  lazy?: boolean;
+  /**
+     * Suppress all warnings from the plugin.
+     *
+     * @default false
+     */
+  silent?: boolean;
+} //#endregion
+//#region src/plugin/index.d.ts
+//#endregion
+export { UnwasmPluginOptions as t };

package/dist/_presets.mjs

@@ -1,12 +1,7 @@
-import "./_chunks/nitro.mjs";
-import { a as join$1, l as relative$1, n as dirname$1, u as resolve$1 } from "./_libs/pathe.mjs";
-import { a as readGitConfig, l as resolveModulePath, n as findNearestFile, o as readPackageJSON, t as findFile } from "./_libs/confbox+exsolve+pkg-types.mjs";
-import { t as h } from "./_libs/confbox3.mjs";
+import "./_common.mjs";
+import { $ as resolveModulePath, G as findFile, I as prettyPath$1, J as readGitConfig, K as findNearestFile, N as glob, R as writeFile$2, U as p, V as a, X as h, Y as readPackageJSON, at as join$1, ct as resolve$1, nt as dirname$1, st as relative$1, z as K } from "./_build/common.mjs";
+import { i as gr, n as Q } from "./_libs/confbox.mjs";
 import { r as resolveCompatibilityDatesFromEnv, t as formatCompatibilityDate } from "./_libs/compatx.mjs";
-import { i as a, n as K, o as p } from "./_libs/std-env.mjs";
-import { i as writeFile$2, n as prettyPath$1 } from "./_chunks/nitro4.mjs";
-import { t as glob } from "./_libs/fdir+picomatch+tinyglobby.mjs";
-import { n as gr, t as Q } from "./_chunks/nitro9.mjs";
 import { builtinModules } from "node:module";
 import consola$1 from "consola";
 import { existsSync, promises } from "node:fs";

package/dist/builder.mjs

@@ -1,11 +1,9 @@
-import "./_chunks/nitro.mjs";
-import "./_libs/c12+dotenv+rc9.mjs";
-import { a as copyPublicAssets, c as loadOptions, i as prepare, n as runTask, o as build, r as prerender, s as createNitro, t as listTasks } from "./_chunks/nitro3.mjs";
-import "./_chunks/nitro4.mjs";
-import "./_libs/fdir+picomatch+tinyglobby.mjs";
-import { n as writeTypes } from "./_chunks/nitro5.mjs";
-import { t as getBuildInfo } from "./_chunks/nitro6.mjs";
-import "./_libs/acorn+confbox+js-tokens+magic-string+mlly+pkg-types+sourcemap-codec+strip-literal+unimport.mjs";
+import "./_common.mjs";
+import { D as prepare, M as build, O as copyPublicAssets, _ as writeTypes, m as getBuildInfo } from "./_build/common.mjs";
+import "./_libs/rc9+c12+dotenv.mjs";
+import { a as loadOptions, i as createNitro, n as runTask, r as prerender, t as listTasks } from "./_chunks/nitro.mjs";
+import "./_libs/tsconfck.mjs";
+import "./_chunks/nitro2.mjs";
 import { n as createDevServer } from "./_chunks/dev.mjs";
 
 export { build, copyPublicAssets, createDevServer, createNitro, getBuildInfo, listTasks, loadOptions, prepare, prerender, runTask, writeTypes };

package/dist/cli/_chunks/build.mjs

@@ -1,4 +1,4 @@
-import { u as resolve } from "../../_libs/pathe.mjs";
+import { ct as resolve } from "../../_build/common.mjs";
 import { t as defineCommand } from "../../_libs/citty.mjs";
 import { t as commonArgs } from "./common.mjs";
 import { build, copyPublicAssets, createNitro, prepare, prerender } from "nitro/builder";

package/dist/cli/_chunks/dev.mjs

@@ -1,6 +1,5 @@
-import { u as resolve } from "../../_libs/pathe.mjs";
-import "../../_chunks/nitro4.mjs";
-import "../../_chunks/nitro6.mjs";
+import { ct as resolve } from "../../_build/common.mjs";
+import "../../_libs/rc9+c12+dotenv.mjs";
 import { t as NitroDevServer } from "../../_chunks/dev.mjs";
 import { t as defineCommand } from "../../_libs/citty.mjs";
 import { t as commonArgs } from "./common.mjs";

package/dist/cli/_chunks/list.mjs

@@ -1,4 +1,4 @@
-import { u as resolve } from "../../_libs/pathe.mjs";
+import { ct as resolve } from "../../_build/common.mjs";
 import { t as defineCommand } from "../../_libs/citty.mjs";
 import { consola } from "consola";
 import { listTasks, loadOptions } from "nitro/builder";

package/dist/cli/_chunks/prepare.mjs

@@ -1,4 +1,4 @@
-import { u as resolve } from "../../_libs/pathe.mjs";
+import { ct as resolve } from "../../_build/common.mjs";
 import { t as defineCommand } from "../../_libs/citty.mjs";
 import { t as commonArgs } from "./common.mjs";
 import { createNitro, writeTypes } from "nitro/builder";

package/dist/cli/_chunks/run.mjs

@@ -1,4 +1,4 @@
-import { u as resolve } from "../../_libs/pathe.mjs";
+import { ct as resolve } from "../../_build/common.mjs";
 import { t as defineCommand } from "../../_libs/citty.mjs";
 import { consola } from "consola";
 import destr from "destr";

package/dist/cli/_chunks/task.mjs

@@ -0,0 +1,16 @@
+import { t as defineCommand } from "../../_libs/citty.mjs";
+
+//#region src/cli/commands/task/index.ts
+var task_default = defineCommand({
+	meta: {
+		name: "task",
+		description: "Operate in nitro tasks (experimental)"
+	},
+	subCommands: {
+		list: () => import("./list.mjs").then((r) => r.default),
+		run: () => import("./run.mjs").then((r) => r.default)
+	}
+});
+
+//#endregion
+export { task_default as default };

package/dist/cli/index.mjs

@@ -13,7 +13,7 @@ runMain(defineCommand({
 		dev: () => import("./_chunks/dev.mjs").then((r) => r.default),
 		build: () => import("./_chunks/build.mjs").then((r) => r.default),
 		prepare: () => import("./_chunks/prepare.mjs").then((r) => r.default),
-		task: () => import("../_chunks/nitro9.mjs").then((r) => r.default)
+		task: () => import("./_chunks/task.mjs").then((r) => r.default)
 	}
 }));
 

package/dist/presets/aws-lambda/runtime/_utils.d.mts

@@ -1,12 +1,7 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
 import type { ServerRequest } from "srvx";
-// Incoming (AWS => Web)
 export declare function awsRequest(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: unknown): ServerRequest;
-// Outgoing (Web => AWS)
 export declare function awsResponseHeaders(response: Response);
-// AWS Lambda proxy integrations requires base64 encoded buffers
-// binaryMediaTypes should be */*
-// see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
 export declare function awsResponseBody(response: Response): Promise<{
 	body: string;
 	isBase64Encoded?: boolean;

package/dist/presets/netlify/runtime/netlify-edge.d.mts

@@ -1,4 +1,3 @@
 import "#nitro/virtual/polyfills";
 import type { Context } from "@netlify/edge-functions";
-// https://docs.netlify.com/edge-functions/api/
 export default function netlifyEdge(netlifyReq: Request, context: Context);

package/dist/presets/winterjs/runtime/winterjs.d.mts

@@ -1,3 +1,2 @@
-// @ts-nocheck TODO: Remove after removing polyfills
 import "#nitro/virtual/polyfills";
 export {};

package/dist/runtime/internal/error/dev.d.mts

@@ -6,5 +6,4 @@ export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?
 	silent?: boolean;
 	json?: boolean;
 }): Promise<InternalHandlerResponse>;
-// ---- Source Map support ----
 export declare function loadStackTrace(error: any);

package/dist/runtime/internal/route-rules.d.mts

@@ -1,8 +1,4 @@
-// Headers route rule
 export declare const headers: unknown;
-// Redirect route rule
 export declare const redirect: unknown;
-// Proxy route rule
 export declare const proxy: unknown;
-// Cache route rule
 export declare const cache: unknown;

package/dist/runtime/internal/routes/openapi.d.mts

@@ -1,4 +1,3 @@
 import type { EventHandler } from "h3";
-// Served as /_openapi.json
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/routes/scalar.d.mts

@@ -1,4 +1,3 @@
 import { type EventHandler } from "h3";
-// Served as /_scalar
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/routes/swagger.d.mts

@@ -1,4 +1,3 @@
 import type { EventHandler } from "h3";
-// https://github.com/swagger-api/swagger-ui
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/runtime-config.d.mts

@@ -1,6 +1,5 @@
 import type { NitroRuntimeConfig } from "nitro/types";
 export declare function useRuntimeConfig(): NitroRuntimeConfig;
-// ---- utils ----
 type EnvOptions = {
 	prefix?: string;
 	altPrefix?: string;

package/dist/runtime/nitro.d.mts

@@ -1,12 +1,9 @@
-// Config
 import type { NitroConfig } from "nitro/types";
 import type { ServerRequestContext } from "srvx";
 import { type H3EventContext } from "h3";
 export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit<NitroConfig, "rootDir">;
-// Type (only) helpers
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
-// Runtime
 export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
 export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;

package/dist/runtime/virtual/renderer-template.d.mts

@@ -1,5 +1,4 @@
 import "./_runtime_warn.mjs";
 export declare function rendererTemplate(_req: Request): string | Promise<string>;
-// dev only
 export declare const rendererTemplateFile: string | undefined;
 export declare const isStaticTemplate: boolean | undefined;