weapp-vite 6.8.0 → 6.9.0

package/dist/config-IEj3IfSy.d.mts

@@ -0,0 +1,3128 @@
+import { c as Resolver, s as ResolvedValue } from "./index-B5wBsuYI.mjs";
+import { t as AutoRoutes } from "./routes-o20IHwXa.mjs";
+import { LoggerConfig } from "@weapp-core/logger";
+import { WeappAstConfig } from "@weapp-vite/ast";
+import { ConfigEnv, ConfigEnv as ConfigEnv$1, InlineConfig, InlineConfig as InlineConfig$1, Plugin as Plugin$1, PluginOption, ResolvedConfig, UserConfig, ViteDevServer, ViteDevServer as ViteDevServer$1, build } from "vite";
+import { InputOption, RolldownBuild, RolldownOptions, RolldownOutput, RolldownOutput as RolldownOutput$1, RolldownPlugin, RolldownPluginOption, RolldownWatcher, RolldownWatcher as RolldownWatcher$1, WatchOptions as RolldownWatchOptions } from "rolldown";
+import { Options } from "rolldown-plugin-dts";
+import { Buffer } from "node:buffer";
+import { PluginOptions } from "vite-tsconfig-paths";
+import { WrapPluginOptions } from "vite-plugin-performance";
+import { ComputedDefinitions as ComputedDefinitions$1, MethodDefinitions as MethodDefinitions$1, Ref, WevuDefaults } from "wevu";
+import { App, App as App$1, Component, Component as Component$1, GenerateType, Page, Page as Page$1, Plugin, Sitemap, Sitemap as Sitemap$1, Theme, Theme as Theme$1 } from "@weapp-core/schematics";
+import { CompilerOptions } from "typescript";
+import { WeappWebPluginOptions } from "@weapp-vite/web/plugin";
+
+//#region src/pluginHost.d.ts
+declare const WEAPP_VITE_HOST_NAME = "weapp-vite";
+type WeappViteRuntime = 'miniprogram' | 'web';
+interface WeappViteHostMeta {
+  name: typeof WEAPP_VITE_HOST_NAME;
+  runtime: WeappViteRuntime;
+}
+declare function createWeappViteHostMeta(runtime: WeappViteRuntime): WeappViteHostMeta;
+declare function applyWeappViteHostMeta(config: InlineConfig, runtime: WeappViteRuntime): InlineConfig;
+declare function resolveWeappViteHostMeta(config: Pick<InlineConfig, 'weappVite'> | undefined): WeappViteHostMeta | undefined;
+declare function isWeappViteHost(config: Pick<InlineConfig, 'weappVite'> | undefined): boolean;
+declare module 'vite' {
+  interface UserConfig {
+    weappVite?: WeappViteHostMeta;
+  }
+  interface ResolvedConfig {
+    weappVite?: WeappViteHostMeta;
+  }
+}
+//#endregion
+//#region src/types/config/foundation.d.ts
+type NpmBuildOptions = InlineConfig;
+/**
+ * @description 支付宝平台本地 npm 输出模式
+ */
+type AlipayNpmMode = 'miniprogram_npm' | 'node_modules';
+interface Alias {
+  /**
+   * @description 被匹配的原始路径或正则
+   */
+  find: string | RegExp;
+  /**
+   * @description 命中后的替换路径
+   */
+  replacement: string;
+}
+interface ResolvedAlias {
+  /**
+   * @description 解析后的匹配条件
+   */
+  find: string | RegExp;
+  /**
+   * @description 解析后的替换路径
+   */
+  replacement: string;
+}
+interface AliasOptions {
+  /**
+   * @example
+   * ```ts
+   * entries: [
+   *   {
+   *     find: '@',
+   *     replacement: path.resolve(import.meta.dirname, 'components'),
+   *   },
+   * ]
+   * ```
+   */
+  entries?: readonly Alias[] | {
+    [find: string]: string;
+  };
+}
+type MpPlatform = 'weapp' | 'alipay' | 'tt' | 'swan' | 'jd' | 'xhs';
+interface SubPackage {
+  /**
+   * @description 分包内页面列表，路径相对于分包 root
+   */
+  pages: string[];
+  /**
+   * @description 分包根目录
+   */
+  root: string;
+  /**
+   * @description 是否为独立分包
+   */
+  independent?: boolean;
+  /**
+   * @description 分包入口文件，也基于 root 解析
+   */
+  entry?: string;
+  /**
+   * @description 分包名称
+   */
+  name?: string;
+  /**
+   * @description 分包依赖范围控制
+   */
+  dependencies?: (string | RegExp)[];
+  /**
+   * @description 分包级额外 inline Vite 配置
+   */
+  inlineConfig?: Partial<InlineConfig>;
+}
+type SubPackageStyleScope = 'all' | 'pages' | 'components';
+interface SubPackageStyleConfigObject {
+  /** 样式文件路径，可以是相对分包 root、相对 `srcRoot` 或绝对路径 */
+  source: string;
+  /**
+   * @description 作用范围快捷配置
+   */
+  scope?: SubPackageStyleScope;
+  /** 自定义包含路径，支持传入单个 glob 或数组，默认覆盖分包内所有文件 */
+  include?: string | string[];
+  /** 自定义排除路径，支持传入单个 glob 或数组 */
+  exclude?: string | string[];
+}
+type SubPackageStyleConfigEntry = string | SubPackageStyleConfigObject;
+interface SubPackageStyleEntry {
+  source: string;
+  absolutePath: string;
+  outputRelativePath: string;
+  inputExtension: string;
+  scope: SubPackageStyleScope;
+  include: string[];
+  exclude: string[];
+}
+type GenerateExtensionsOptions = Partial<{
+  js: 'js' | 'ts' | (string & {});
+  json: 'js' | 'ts' | 'json' | (string & {});
+  wxml: 'wxml' | (string & {});
+  wxss: 'wxss' | 'scss' | 'less' | 'css' | (string & {});
+}>;
+type GenerateDirsOptions = Partial<{
+  app: string;
+  page: string;
+  component: string;
+}>;
+type GenerateFilenamesOptions = Partial<{
+  app: string;
+  page: string;
+  component: string;
+}>;
+type GenerateFileType = 'js' | 'json' | 'wxml' | 'wxss';
+interface GenerateTemplateContext {
+  type: GenerateType;
+  fileType: GenerateFileType;
+  fileName: string;
+  outDir: string;
+  extension: string;
+  cwd: string;
+  defaultCode?: string;
+}
+interface GenerateTemplateFileSource {
+  path: string;
+}
+interface GenerateTemplateInlineSource {
+  content: string;
+}
+type GenerateTemplateFactory = (context: GenerateTemplateContext) => string | Promise<string> | undefined;
+type GenerateTemplate = string | GenerateTemplateFileSource | GenerateTemplateInlineSource | GenerateTemplateFactory;
+type GenerateTemplateEntry = Partial<Record<GenerateFileType, GenerateTemplate>>;
+type GenerateTemplateScope = GenerateType | 'shared';
+type GenerateTemplatesConfig = Partial<Record<GenerateTemplateScope, GenerateTemplateEntry>>;
+interface GenerateOptions {
+  extensions?: GenerateExtensionsOptions;
+  dirs?: GenerateDirsOptions;
+  filenames?: GenerateFilenamesOptions;
+  templates?: GenerateTemplatesConfig;
+}
+interface CopyOptions {
+  include?: CopyGlobs;
+  exclude?: CopyGlobs;
+  filter?: (filePath: string, index: number, array: string[]) => boolean;
+}
+/**
+ * @description 资源复制使用的 glob 列表
+ */
+type CopyGlobs = string[];
+interface WeappWebConfig {
+  enable?: boolean;
+  root?: string;
+  srcDir?: string;
+  outDir?: string;
+  pluginOptions?: Partial<Omit<WeappWebPluginOptions, 'srcDir'>>;
+  vite?: InlineConfig;
+}
+interface WeappLibEntryContext {
+  name: string;
+  input: string;
+}
+type WeappLibFileName = string | ((context: WeappLibEntryContext) => string);
+type WeappLibComponentJson = boolean | 'auto' | ((context: WeappLibEntryContext) => Record<string, any>);
+interface WeappLibInternalDtsOptions {
+  tsconfig?: string | false;
+  compilerOptions?: CompilerOptions;
+  vueCompilerOptions?: Record<string, any>;
+}
+interface WeappLibVueTscOptions {
+  tsconfig?: Record<string, any>;
+  compilerOptions?: CompilerOptions;
+  vueCompilerOptions?: Record<string, any>;
+}
+interface WeappLibDtsOptions {
+  enabled?: boolean;
+  mode?: 'internal' | 'vue-tsc';
+  internal?: WeappLibInternalDtsOptions;
+  rolldown?: Options;
+  vueTsc?: WeappLibVueTscOptions;
+}
+interface WeappLibConfig {
+  entry: string | string[] | Record<string, string>;
+  root?: string;
+  outDir?: string;
+  preservePath?: boolean;
+  fileName?: WeappLibFileName;
+  componentJson?: WeappLibComponentJson;
+  dts?: boolean | WeappLibDtsOptions;
+}
+interface BuildNpmPackageMeta {
+  name: string;
+  entry: InputOption;
+}
+interface NpmSubPackageConfig {
+  dependencies?: (string | RegExp)[];
+}
+interface NpmMainPackageConfig {
+  dependencies?: false | (string | RegExp)[];
+}
+type JsFormat = 'cjs' | 'esm';
+type SharedChunkStrategy = 'hoist' | 'duplicate';
+type SharedChunkMode = 'common' | 'path' | 'inline';
+type SharedChunkDynamicImports = 'preserve' | 'inline';
+interface SharedChunkOverride {
+  test: string | RegExp;
+  mode: SharedChunkMode;
+}
+type JsonMergeStage = 'defaults' | 'json-block' | 'auto-using-components' | 'component-generics' | 'macro' | 'emit' | 'merge-existing';
+interface JsonMergeContext {
+  filename?: string;
+  kind?: 'app' | 'page' | 'component' | 'unknown';
+  stage: JsonMergeStage;
+}
+type JsonMergeFunction = (target: Record<string, any>, source: Record<string, any>, context: JsonMergeContext) => Record<string, any> | void;
+type JsonMergeStrategy = 'deep' | 'assign' | 'replace' | JsonMergeFunction;
+interface JsonConfig {
+  defaults?: {
+    app?: Record<string, any>;
+    page?: Record<string, any>;
+    component?: Record<string, any>;
+  };
+  mergeStrategy?: JsonMergeStrategy;
+}
+interface ChunksConfig {
+  sharedStrategy?: SharedChunkStrategy;
+  sharedMode?: SharedChunkMode;
+  sharedOverrides?: SharedChunkOverride[];
+  sharedPathRoot?: string;
+  dynamicImports?: SharedChunkDynamicImports;
+  logOptimization?: boolean;
+  forceDuplicatePatterns?: (string | RegExp)[];
+  duplicateWarningBytes?: number;
+}
+//#endregion
+//#region src/types/config/features.d.ts
+/**
+ * @description 自动导入组件配置
+ */
+interface AutoImportComponents {
+  /**
+   * @description 组件扫描范围
+   */
+  globs?: string[];
+  /**
+   * @description 组件解析器列表
+   */
+  resolvers?: Resolver[];
+  /**
+   * @description 组件清单输出路径
+   */
+  output?: string | boolean;
+  /**
+   * @description WXML 组件 props 类型声明输出路径
+   */
+  typedComponents?: boolean | string;
+  /**
+   * @description VS Code HTML customData 输出路径
+   */
+  htmlCustomData?: boolean | string;
+  /**
+   * @description Vue SFC 组件声明输出路径
+   */
+  vueComponents?: boolean | string;
+  /**
+   * @description 生成 `components.d.ts` 时使用的运行时模块名
+   */
+  vueComponentsModule?: string;
+}
+type AutoImportComponentsOption = AutoImportComponents | boolean;
+type EnhanceWxmlOptions = ScanWxmlOptions & HandleWxmlOptions;
+/**
+ * @description WXML 扫描阶段配置
+ */
+interface ScanWxmlOptions {
+  excludeComponent?: (tagName: string) => boolean;
+  platform?: MpPlatform;
+}
+/**
+ * @description WXML 处理阶段配置
+ */
+interface HandleWxmlOptions {
+  removeComment?: boolean;
+  transformEvent?: boolean;
+  scriptModuleExtension?: string;
+  scriptModuleTag?: string;
+  templateExtension?: string;
+}
+interface EnhanceOptions {
+  wxml?: boolean | Partial<Omit<EnhanceWxmlOptions, 'platform'>>;
+  wxs?: boolean;
+  autoImportComponents?: AutoImportComponentsOption;
+}
+/**
+ * @description 多平台 project.config 配置
+ */
+interface MultiPlatformConfig {
+  enabled?: boolean;
+  projectConfigRoot?: string;
+}
+/**
+ * @description MCP 服务配置
+ */
+interface WeappMcpConfig {
+  enabled?: boolean;
+  autoStart?: boolean;
+  host?: string;
+  port?: number;
+  endpoint?: string;
+}
+/**
+ * @description 自动路由配置
+ */
+type WeappAutoRoutesIncludePattern = string | RegExp;
+/**
+ * @description 自动路由包含规则
+ */
+type WeappAutoRoutesInclude = WeappAutoRoutesIncludePattern | WeappAutoRoutesIncludePattern[];
+/**
+ * @description 自动路由配置
+ */
+interface WeappAutoRoutesConfig {
+  enabled?: boolean;
+  typedRouter?: boolean;
+  /**
+   * @description 自动路由扫描规则，支持字符串 glob、正则以及它们的数组
+   * @remarks 默认会扫描主包 `pages/**`，以及已声明分包 root 下的 `pages/**`
+   */
+  include?: WeappAutoRoutesInclude;
+  /**
+   * @description 是否启用自动路由持久化缓存，或指定自定义缓存文件路径
+   * @default false
+   */
+  persistentCache?: boolean | string;
+  watch?: boolean;
+}
+/**
+ * @description `@wevu/api` 注入配置
+ */
+interface WeappInjectWeapiConfig {
+  enabled?: boolean;
+  replaceWx?: boolean;
+  globalName?: string;
+}
+/**
+ * @description 本地 npm 构建配置
+ */
+interface WeappNpmConfig {
+  enable?: boolean;
+  cache?: boolean;
+  mainPackage?: NpmMainPackageConfig;
+  subPackages?: Record<string, NpmSubPackageConfig>;
+  buildOptions?: (options: NpmBuildOptions, pkgMeta: BuildNpmPackageMeta) => NpmBuildOptions | undefined;
+  alipayNpmMode?: AlipayNpmMode;
+}
+/**
+ * @description 分包级额外配置
+ */
+interface WeappSubPackageConfig {
+  independent?: boolean;
+  inlineConfig?: Partial<InlineConfig>;
+  autoImportComponents?: AutoImportComponentsOption;
+  watchSharedStyles?: boolean;
+  styles?: SubPackageStyleConfigEntry | SubPackageStyleConfigEntry[];
+}
+/**
+ * @description HMR 配置
+ */
+interface WeappHmrConfig {
+  sharedChunks?: 'full' | 'auto' | 'off';
+  touchAppWxss?: boolean | 'auto';
+}
+/**
+ * @description worker 构建配置
+ */
+interface WeappWorkerConfig {
+  entry?: string | string[];
+}
+/**
+ * @description Vue 模板编译配置
+ */
+interface WeappVueTemplateConfig {
+  removeComments?: boolean;
+  simplifyWhitespace?: boolean;
+  scopedSlotsCompiler?: 'auto' | 'augmented' | 'off';
+  scopedSlotsRequireProps?: boolean;
+  slotMultipleInstance?: boolean;
+  classStyleRuntime?: 'auto' | 'wxs' | 'js';
+  objectLiteralBindMode?: 'runtime' | 'inline';
+  mustacheInterpolation?: 'compact' | 'spaced';
+  classStyleWxsShared?: boolean;
+}
+/**
+ * @description Vue 支持配置
+ */
+interface WeappVueConfig {
+  enable?: boolean;
+  template?: WeappVueTemplateConfig;
+  autoImport?: boolean;
+}
+/**
+ * @description wevu 编译期默认值配置
+ */
+interface WeappWevuConfig {
+  preset?: 'performance';
+  defaults?: WevuDefaults;
+  autoSetDataPick?: boolean;
+}
+//#endregion
+//#region src/types/config/main.d.ts
+/**
+ * @description 分包元信息
+ */
+interface SubPackageMetaValue {
+  entries: string[];
+  subPackage: SubPackage;
+  autoImportComponents?: AutoImportComponentsOption;
+  styleEntries?: SubPackageStyleEntry[];
+  watchSharedStyles?: boolean;
+}
+/**
+ * @description 调试输出配置
+ */
+interface WeappDebugConfig {
+  watchFiles?: (watchFiles: string[], subPackageMeta?: SubPackageMetaValue) => void;
+  resolveId?: (id: string, subPackageMeta?: SubPackageMetaValue) => void;
+  load?: (id: string, subPackageMeta?: SubPackageMetaValue) => void;
+  inspect?: WrapPluginOptions;
+}
+/**
+ * @description weapp-vite 主配置
+ */
+interface WeappViteConfig {
+  /**
+   * 应用入口目录（`app.json` 所在目录）。
+   */
+  srcRoot?: string;
+  /**
+   * 自动路由模块配置。
+   * - `undefined` / `false`: 默认关闭
+   * - `true`: 启用默认自动路由配置
+   * - `object`: 启用自动路由并允许细粒度控制
+   */
+  autoRoutes?: boolean | WeappAutoRoutesConfig;
+  /**
+   * 插件入口目录（`plugin.json` 所在目录）。
+   */
+  pluginRoot?: string;
+  /**
+   * 日志输出配置。
+   */
+  logger?: LoggerConfig;
+  /**
+   * AST 引擎配置。
+   */
+  ast?: WeappAstConfig;
+  /**
+   * 主包/分包体积告警阈值（字节）。
+   */
+  packageSizeWarningBytes?: number;
+  jsonAlias?: AliasOptions;
+  npm?: WeappNpmConfig;
+  generate?: GenerateOptions;
+  tsconfigPaths?: PluginOptions | false;
+  subPackages?: Record<string, WeappSubPackageConfig>;
+  copy?: CopyOptions;
+  web?: WeappWebConfig;
+  lib?: WeappLibConfig;
+  isAdditionalWxml?: (wxmlFilePath: string) => boolean;
+  platform?: MpPlatform;
+  multiPlatform?: boolean | MultiPlatformConfig;
+  jsFormat?: JsFormat;
+  /**
+   * @deprecated 已废弃，不建议继续使用。请改为保持 `build.target >= es2020`，并在开发者工具中开启“将 JS 编译成 ES5”功能。
+   * 该选项依赖 `@swc/core` 做额外 ES5 降级，后续版本将移除。
+   */
+  es5?: boolean;
+  wxml?: EnhanceOptions['wxml'];
+  wxs?: EnhanceOptions['wxs'];
+  autoImportComponents?: AutoImportComponentsOption;
+  enhance?: EnhanceOptions;
+  debug?: WeappDebugConfig;
+  hmr?: WeappHmrConfig;
+  worker?: WeappWorkerConfig;
+  vue?: WeappVueConfig;
+  wevu?: WeappWevuConfig;
+  injectWeapi?: boolean | WeappInjectWeapiConfig;
+  mcp?: boolean | WeappMcpConfig;
+  chunks?: ChunksConfig;
+  json?: JsonConfig;
+}
+type UserConfig$2 = UserConfig & {
+  weapp?: WeappViteConfig;
+};
+/**
+ * @description 小程序 project.config 结构
+ */
+interface ProjectConfig {
+  miniprogramRoot?: string;
+  srcMiniprogramRoot?: string;
+  smartProgramRoot?: string;
+  setting?: {
+    packNpmManually?: boolean;
+    packNpmRelationList?: {
+      packageJsonPath: string;
+      miniprogramNpmDistDir: string;
+    }[];
+  };
+}
+//#endregion
+//#region src/types/context.d.ts
+interface WxmlDep {
+  tagName: string;
+  start: number;
+  end: number;
+  quote: string | null | undefined;
+  name: string;
+  value: string;
+  attrs: Record<string, string>;
+}
+interface ScanComponentItem {
+  start: number;
+  end: number;
+}
+type ComponentsMap = Record<string, ScanComponentItem[]>;
+//#endregion
+//#region src/types/entry.d.ts
+interface BaseEntry {
+  path: string;
+  jsonPath?: string;
+  json?: object;
+  type: 'app' | 'page' | 'component' | (string & {});
+}
+type Entry = AppEntry | PageEntry | ComponentEntry;
+/**
+ * 应用入口 js + json
+ */
+interface AppEntry extends BaseEntry {
+  type: 'app';
+  themeJsonPath?: string;
+  themeJson?: Theme;
+  sitemapJsonPath?: string;
+  sitemapJson?: Sitemap;
+  json: App;
+  jsonPath: string;
+}
+/**
+ * 页面入口 js + wxml
+ */
+interface PageEntry extends BaseEntry {
+  type: 'page';
+  templatePath: string;
+  json?: Page;
+}
+/**
+ * 组件入口 js + wxml + json + json.component === true
+ */
+interface ComponentEntry extends BaseEntry {
+  type: 'component';
+  templatePath: string;
+  json: Component;
+  jsonPath: string;
+}
+type EntryJsonFragment = Omit<BaseEntry, 'path' | 'type'>;
+//#endregion
+//#region src/types/errors.d.ts
+interface BindingErrorLike {
+  message?: string;
+  code?: string;
+  plugin?: string;
+  id?: string;
+  frame?: string;
+  stack?: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.d.ts
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ */
+declare class EventEmitter<EventTypes extends EventEmitter.ValidEventTypes = string | symbol, Context extends any = any> {
+  static prefixed: string | boolean;
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   */
+  eventNames(): Array<EventEmitter.EventNames<EventTypes>>;
+  /**
+   * Return the listeners registered for a given event.
+   */
+  listeners<T extends EventEmitter.EventNames<EventTypes>>(event: T): Array<EventEmitter.EventListener<EventTypes, T>>;
+  /**
+   * Return the number of listeners listening to a given event.
+   */
+  listenerCount(event: EventEmitter.EventNames<EventTypes>): number;
+  /**
+   * Calls each of the listeners registered for a given event.
+   */
+  emit<T extends EventEmitter.EventNames<EventTypes>>(event: T, ...args: EventEmitter.EventArgs<EventTypes, T>): boolean;
+  /**
+   * Add a listener for a given event.
+   */
+  on<T extends EventEmitter.EventNames<EventTypes>>(event: T, fn: EventEmitter.EventListener<EventTypes, T>, context?: Context): this;
+  addListener<T extends EventEmitter.EventNames<EventTypes>>(event: T, fn: EventEmitter.EventListener<EventTypes, T>, context?: Context): this;
+  /**
+   * Add a one-time listener for a given event.
+   */
+  once<T extends EventEmitter.EventNames<EventTypes>>(event: T, fn: EventEmitter.EventListener<EventTypes, T>, context?: Context): this;
+  /**
+   * Remove the listeners of a given event.
+   */
+  removeListener<T extends EventEmitter.EventNames<EventTypes>>(event: T, fn?: EventEmitter.EventListener<EventTypes, T>, context?: Context, once?: boolean): this;
+  off<T extends EventEmitter.EventNames<EventTypes>>(event: T, fn?: EventEmitter.EventListener<EventTypes, T>, context?: Context, once?: boolean): this;
+  /**
+   * Remove all listeners, or those of the specified event.
+   */
+  removeAllListeners(event?: EventEmitter.EventNames<EventTypes>): this;
+}
+declare namespace EventEmitter {
+  export interface ListenerFn<Args extends any[] = any[]> {
+    (...args: Args): void;
+  }
+  export interface EventEmitterStatic {
+    new <EventTypes extends ValidEventTypes = string | symbol, Context = any>(): EventEmitter<EventTypes, Context>;
+  }
+  /**
+   * `object` should be in either of the following forms:
+   * ```
+   * interface EventTypes {
+   *   'event-with-parameters': any[]
+   *   'event-with-example-handler': (...args: any[]) => void
+   * }
+   * ```
+   */
+  export type ValidEventTypes = string | symbol | object;
+  export type EventNames<T extends ValidEventTypes> = T extends string | symbol ? T : keyof T;
+  export type ArgumentMap<T extends object> = { [K in keyof T]: T[K] extends ((...args: any[]) => void) ? Parameters<T[K]> : T[K] extends any[] ? T[K] : any[] };
+  export type EventListener<T extends ValidEventTypes, K extends EventNames<T>> = T extends string | symbol ? (...args: any[]) => void : (...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]) => void;
+  export type EventArgs<T extends ValidEventTypes, K extends EventNames<T>> = Parameters<EventListener<T, K>>;
+  export const EventEmitter: EventEmitterStatic;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/p-queue@9.1.0/node_modules/p-queue/dist/queue.d.ts
+type RunFunction = () => Promise<unknown>;
+type Queue<Element, Options> = {
+  size: number;
+  filter: (options: Readonly<Partial<Options>>) => Element[];
+  dequeue: () => Element | undefined;
+  enqueue: (run: Element, options?: Partial<Options>) => void;
+  setPriority: (id: string, priority: number) => void;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/p-queue@9.1.0/node_modules/p-queue/dist/options.d.ts
+type TimeoutOptions = {
+  /**
+  Per-operation timeout in milliseconds. Operations will throw a `TimeoutError` if they don't complete within the specified time.
+   The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+   @default undefined
+   Can be overridden per task using the `timeout` option in `.add()`:
+   @example
+  ```
+  const queue = new PQueue({timeout: 5000});
+   // This task uses the global 5s timeout
+  await queue.add(() => fetchData());
+   // This task has a 10s timeout
+  await queue.add(() => slowTask(), {timeout: 10000});
+  ```
+  */
+  timeout?: number;
+};
+type Options$1<QueueType extends Queue<RunFunction, QueueOptions>, QueueOptions extends QueueAddOptions> = {
+  /**
+  Concurrency limit.
+   Minimum: `1`.
+   @default Infinity
+  */
+  readonly concurrency?: number;
+  /**
+  Whether queue tasks within concurrency limit, are auto-executed as soon as they're added.
+   @default true
+  */
+  readonly autoStart?: boolean;
+  /**
+  Class with a `enqueue` and `dequeue` method, and a `size` getter. See the [Custom QueueClass](https://github.com/sindresorhus/p-queue#custom-queueclass) section.
+  */
+  readonly queueClass?: new () => QueueType;
+  /**
+  The max number of runs in the given interval of time.
+   Minimum: `1`.
+   @default Infinity
+  */
+  readonly intervalCap?: number;
+  /**
+  The length of time in milliseconds before the interval count resets. Must be finite.
+   Minimum: `0`.
+   @default 0
+  */
+  readonly interval?: number;
+  /**
+  Whether the task must finish in the given interval or will be carried over into the next interval count.
+   @default false
+  */
+  readonly carryoverIntervalCount?: boolean;
+  /**
+  @deprecated Renamed to `carryoverIntervalCount`.
+  */
+  readonly carryoverConcurrencyCount?: boolean;
+  /**
+  Whether to use strict mode for rate limiting (sliding window algorithm).
+   When enabled, ensures that no more than `intervalCap` tasks execute in any rolling `interval` window, rather than resetting the count at fixed intervals. This provides more predictable and evenly distributed execution.
+   @default false
+   For example, with `intervalCap: 2` and `interval: 1000`:
+  - __Default mode (fixed window)__: Tasks can burst at window boundaries. You could execute 2 tasks at 999ms and 2 more at 1000ms, resulting in 4 tasks within 1ms.
+  - __Strict mode (sliding window)__: Enforces that no more than 2 tasks execute in any 1000ms rolling window, preventing bursts.
+   Strict mode is more resource-intensive as it tracks individual execution timestamps. Use it when you need guaranteed rate-limit compliance, such as when interacting with APIs that enforce strict rate limits.
+   The `carryoverIntervalCount` option has no effect when `strict` mode is enabled, as strict mode tracks actual execution timestamps rather than counting pending tasks.
+  */
+  readonly strict?: boolean;
+} & TimeoutOptions;
+type QueueAddOptions = {
+  /**
+  Priority of operation. Operations with greater priority will be scheduled first.
+   @default 0
+  */
+  readonly priority?: number;
+  /**
+  Unique identifier for the promise function, used to update its priority before execution. If not specified, it is auto-assigned an incrementing BigInt starting from `1n`.
+  */
+  id?: string;
+} & TaskOptions & TimeoutOptions;
+type TaskOptions = {
+  /**
+  [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) for cancellation of the operation. When aborted, it will be removed from the queue and the `queue.add()` call will reject with an `AbortError`. If the operation is already running, the signal will need to be handled by the operation itself.
+   @example
+  ```
+  import PQueue, {AbortError} from 'p-queue';
+  import got, {CancelError} from 'got';
+   const queue = new PQueue();
+   const controller = new AbortController();
+   try {
+      await queue.add(({signal}) => {
+          const request = got('https://sindresorhus.com');
+           signal.addEventListener('abort', () => {
+              request.cancel();
+          });
+           try {
+              return await request;
+          } catch (error) {
+              if (!(error instanceof CancelError)) {
+                  throw error;
+              }
+          }
+      }, {signal: controller.signal});
+  } catch (error) {
+      if (!(error instanceof AbortError)) {
+          throw error;
+      }
+  }
+  ```
+  */
+  readonly signal?: AbortSignal | undefined;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/p-queue@9.1.0/node_modules/p-queue/dist/priority-queue.d.ts
+type PriorityQueueOptions = {
+  priority?: number;
+} & QueueAddOptions;
+declare class PriorityQueue implements Queue<RunFunction, PriorityQueueOptions> {
+  #private;
+  enqueue(run: RunFunction, options?: Partial<PriorityQueueOptions>): void;
+  setPriority(id: string, priority: number): void;
+  dequeue(): RunFunction | undefined;
+  filter(options: Readonly<Partial<PriorityQueueOptions>>): RunFunction[];
+  get size(): number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/p-queue@9.1.0/node_modules/p-queue/dist/index.d.ts
+type Task<TaskResultType> = ((options: TaskOptions) => PromiseLike<TaskResultType>) | ((options: TaskOptions) => TaskResultType);
+type EventName = 'active' | 'idle' | 'empty' | 'add' | 'next' | 'completed' | 'error' | 'pendingZero' | 'rateLimit' | 'rateLimitCleared';
+/**
+Promise queue with concurrency control.
+*/
+declare class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsType> = PriorityQueue, EnqueueOptionsType extends QueueAddOptions = QueueAddOptions> extends EventEmitter<EventName> {
+  #private;
+  /**
+  Get or set the default timeout for all tasks. Can be changed at runtime.
+   Operations will throw a `TimeoutError` if they don't complete within the specified time.
+   The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+   @example
+  ```
+  const queue = new PQueue({timeout: 5000});
+   // Change timeout for all future tasks
+  queue.timeout = 10000;
+  ```
+  */
+  timeout?: number;
+  constructor(options?: Options$1<QueueType, EnqueueOptionsType>);
+  get concurrency(): number;
+  set concurrency(newConcurrency: number);
+  /**
+  Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+   For example, this can be used to prioritize a promise function to run earlier.
+   ```js
+  import PQueue from 'p-queue';
+   const queue = new PQueue({concurrency: 1});
+   queue.add(async () => '🦄', {priority: 1});
+  queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+  queue.add(async () => '🦄', {priority: 1});
+  queue.add(async () => '🦄', {priority: 1});
+   queue.setPriority('🦀', 2);
+  ```
+   In this case, the promise function with `id: '🦀'` runs second.
+   You can also deprioritize a promise function to delay its execution:
+   ```js
+  import PQueue from 'p-queue';
+   const queue = new PQueue({concurrency: 1});
+   queue.add(async () => '🦄', {priority: 1});
+  queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+  queue.add(async () => '🦄');
+  queue.add(async () => '🦄', {priority: 0});
+   queue.setPriority('🦀', -1);
+  ```
+  Here, the promise function with `id: '🦀'` executes last.
+  */
+  setPriority(id: string, priority: number): void;
+  /**
+  Adds a sync or async task to the queue. Always returns a promise.
+  */
+  add<TaskResultType>(function_: Task<TaskResultType>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultType>;
+  /**
+  Same as `.add()`, but accepts an array of sync or async functions.
+   @returns A promise that resolves when all functions are resolved.
+  */
+  addAll<TaskResultsType>(functions: ReadonlyArray<Task<TaskResultsType>>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultsType[]>;
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start(): this;
+  /**
+  Put queue execution on hold.
+  */
+  pause(): void;
+  /**
+  Clear the queue.
+  */
+  clear(): void;
+  /**
+  Can be called multiple times. Useful if you for example add additional items at a later time.
+   @returns A promise that settles when the queue becomes empty.
+  */
+  onEmpty(): Promise<void>;
+  /**
+  @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+   If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+   Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+  */
+  onSizeLessThan(limit: number): Promise<void>;
+  /**
+  The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+   @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+  */
+  onIdle(): Promise<void>;
+  /**
+  The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+   @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+  */
+  onPendingZero(): Promise<void>;
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  onRateLimit(): Promise<void>;
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  onRateLimitCleared(): Promise<void>;
+  /**
+  @returns A promise that rejects when any task in the queue errors.
+   Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+   Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+   @example
+  ```
+  import PQueue from 'p-queue';
+   const queue = new PQueue({concurrency: 2});
+   queue.add(() => fetchData(1)).catch(() => {});
+  queue.add(() => fetchData(2)).catch(() => {});
+  queue.add(() => fetchData(3)).catch(() => {});
+   // Stop processing on first error
+  try {
+      await Promise.race([
+          queue.onError(),
+          queue.onIdle()
+      ]);
+  } catch (error) {
+      queue.pause(); // Stop processing remaining tasks
+      console.error('Queue failed:', error);
+  }
+  ```
+  */
+  onError(): Promise<never>;
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size(): number;
+  /**
+  Size of the queue, filtered by the given options.
+   For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+  */
+  sizeBy(options: Readonly<Partial<EnqueueOptionsType>>): number;
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending(): number;
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused(): boolean;
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited(): boolean;
+  /**
+  Whether the queue is saturated. Returns `true` when:
+  - All concurrency slots are occupied and tasks are waiting, OR
+  - The queue is rate-limited and tasks are waiting
+   Useful for detecting backpressure and potential hanging tasks.
+   ```js
+  import PQueue from 'p-queue';
+   const queue = new PQueue({concurrency: 2});
+   // Backpressure handling
+  if (queue.isSaturated) {
+      console.log('Queue is saturated, waiting for capacity...');
+      await queue.onSizeLessThan(queue.concurrency);
+  }
+   // Monitoring for stuck tasks
+  setInterval(() => {
+      if (queue.isSaturated) {
+          console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+      }
+  }, 60000);
+  ```
+  */
+  get isSaturated(): boolean;
+  /**
+  The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+   Returns an array of task info objects.
+   ```js
+  import PQueue from 'p-queue';
+   const queue = new PQueue({concurrency: 2});
+   // Add tasks with IDs for better debugging
+  queue.add(() => fetchUser(123), {id: 'user-123'});
+  queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+   // Check what's running
+  console.log(queue.runningTasks);
+  // => [{
+  //   id: 'user-123',
+  //   priority: 0,
+  //   startTime: 1759253001716,
+  //   timeout: undefined
+  // }, {
+  //   id: 'posts-456',
+  //   priority: 1,
+  //   startTime: 1759253001916,
+  //   timeout: undefined
+  // }]
+  ```
+  */
+  get runningTasks(): ReadonlyArray<{
+    readonly id?: string;
+    readonly priority: number;
+    readonly startTime: number;
+    readonly timeout?: number;
+  }>;
+}
+//#endregion
+//#region src/runtime/buildPlugin/service.d.ts
+interface BuildOptions {
+  skipNpm?: boolean;
+}
+interface BuildService {
+  queue: PQueue;
+  build: (options?: BuildOptions) => Promise<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
+  buildIndependentBundle: (root: string, meta: SubPackageMetaValue) => Promise<RolldownOutput>;
+  getIndependentOutput: (root: string) => RolldownOutput | undefined;
+  invalidateIndependentOutput: (root: string) => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/package-manager-detector@1.6.0/node_modules/package-manager-detector/dist/shared/package-manager-detector.DksAilYA.d.mts
+type Agent = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'pnpm@6' | 'bun' | 'deno';
+type AgentName = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'deno';
+interface DetectResult {
+  /**
+   * Agent name without the specifier.
+   *
+   * Can be `npm`, `yarn`, `pnpm`, `bun`, or `deno`.
+   */
+  name: AgentName;
+  /**
+   * Agent specifier to resolve the command.
+   *
+   * May contain '@' to differentiate the version (e.g. 'yarn@berry').
+   * Use `name` for the agent name without the specifier.
+   */
+  agent: Agent;
+  /**
+   * Specific version of the agent, read from `packageManager` field in package.json.
+   */
+  version?: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.d.mts
+interface PackageJson {
+  /**
+   * The name is what your thing is called.
+   * Some rules:
+   * - The name must be less than or equal to 214 characters. This includes the scope for scoped packages.
+   * - The name can’t start with a dot or an underscore.
+   * - New packages must not have uppercase letters in the name.
+   * - The name ends up being part of a URL, an argument on the command line, and a folder name. Therefore, the name can’t contain any non-URL-safe characters.
+   */
+  name?: string;
+  /**
+   * Version must be parseable by `node-semver`, which is bundled with npm as a dependency. (`npm install semver` to use it yourself.)
+   */
+  version?: string;
+  /**
+   * Put a description in it. It’s a string. This helps people discover your package, as it’s listed in `npm search`.
+   */
+  description?: string;
+  /**
+   * Put keywords in it. It’s an array of strings. This helps people discover your package as it’s listed in `npm search`.
+   */
+  keywords?: string[];
+  /**
+   * The url to the project homepage.
+   */
+  homepage?: string;
+  /**
+   * The url to your project’s issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your package.
+   */
+  bugs?: string | {
+    url?: string;
+    email?: string;
+  };
+  /**
+   * You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you’re placing on it.
+   */
+  license?: string;
+  /**
+   * Specify the place where your code lives. This is helpful for people who want to contribute. If the git repo is on GitHub, then the `npm docs` command will be able to find you.
+   * For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for npm install:
+   */
+  repository?: string | {
+    type: string;
+    url: string;
+    /**
+     * If the `package.json` for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:
+     */
+    directory?: string;
+  };
+  /**
+   * The `scripts` field is a dictionary containing script commands that are run at various times in the lifecycle of your package.
+   */
+  scripts?: PackageJsonScripts;
+  /**
+   * If you set `"private": true` in your package.json, then npm will refuse to publish it.
+   */
+  private?: boolean;
+  /**
+   * The “author” is one person.
+   */
+  author?: PackageJsonPerson;
+  /**
+   * “contributors” is an array of people.
+   */
+  contributors?: PackageJsonPerson[];
+  /**
+   * An object containing a URL that provides up-to-date information
+   * about ways to help fund development of your package,
+   * a string URL, or an array of objects and string URLs
+   */
+  funding?: PackageJsonFunding | PackageJsonFunding[];
+  /**
+   * The optional `files` field is an array of file patterns that describes the entries to be included when your package is installed as a dependency. File patterns follow a similar syntax to `.gitignore`, but reversed: including a file, directory, or glob pattern (`*`, `**\/*`, and such) will make it so that file is included in the tarball when it’s packed. Omitting the field will make it default to `["*"]`, which means it will include all files.
+   */
+  files?: string[];
+  /**
+   * The main field is a module ID that is the primary entry point to your program. That is, if your package is named `foo`, and a user installs it, and then does `require("foo")`, then your main module’s exports object will be returned.
+   * This should be a module ID relative to the root of your package folder.
+   * For most modules, it makes the most sense to have a main script and often not much else.
+   */
+  main?: string;
+  /**
+   * If your module is meant to be used client-side the browser field should be used instead of the main field. This is helpful to hint users that it might rely on primitives that aren’t available in Node.js modules. (e.g. window)
+   */
+  browser?: string | Record<string, string | false>;
+  /**
+   * The `unpkg` field is used to specify the URL to a UMD module for your package. This is used by default in the unpkg.com CDN service.
+   */
+  unpkg?: string;
+  /**
+   * A map of command name to local file name. On install, npm will symlink that file into `prefix/bin` for global installs, or `./node_modules/.bin/` for local installs.
+   */
+  bin?: string | Record<string, string>;
+  /**
+   * Specify either a single file or an array of filenames to put in place for the `man` program to find.
+   */
+  man?: string | string[];
+  /**
+   * Dependencies are specified in a simple object that maps a package name to a version range. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL.
+   */
+  dependencies?: Record<string, string>;
+  /**
+   * If someone is planning on downloading and using your module in their program, then they probably don’t want or need to download and build the external test or documentation framework that you use.
+   * In this case, it’s best to map these additional items in a `devDependencies` object.
+   */
+  devDependencies?: Record<string, string>;
+  /**
+   * If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the `optionalDependencies` object. This is a map of package name to version or url, just like the `dependencies` object. The difference is that build failures do not cause installation to fail.
+   */
+  optionalDependencies?: Record<string, string>;
+  /**
+   * In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a `require` of this host. This is usually referred to as a plugin. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.
+   */
+  peerDependencies?: Record<string, string>;
+  /**
+   * TypeScript typings, typically ending by `.d.ts`.
+   */
+  types?: string;
+  /**
+   * This field is synonymous with `types`.
+   */
+  typings?: string;
+  /**
+   * Non-Standard Node.js alternate entry-point to main.
+   * An initial implementation for supporting CJS packages (from main), and use module for ESM modules.
+   */
+  module?: string;
+  /**
+   * Make main entry-point be loaded as an ESM module, support "export" syntax instead of "require"
+   *
+   * Docs:
+   * - https://nodejs.org/docs/latest-v14.x/api/esm.html#esm_package_json_type_field
+   *
+   * @default 'commonjs'
+   * @since Node.js v14
+   */
+  type?: "module" | "commonjs";
+  /**
+   * Alternate and extensible alternative to "main" entry point.
+   *
+   * When using `{type: "module"}`, any ESM module file MUST end with `.mjs` extension.
+   *
+   * Docs:
+   * - https://nodejs.org/docs/latest-v14.x/api/esm.html#esm_exports_sugar
+   *
+   * @since Node.js v12.7
+   */
+  exports?: PackageJsonExports;
+  /**
+   *  Docs:
+   *  - https://nodejs.org/api/packages.html#imports
+   */
+  imports?: Record<string, string | Record<string, string>>;
+  /**
+   * The field is used to define a set of sub-packages (or workspaces) within a monorepo.
+   *
+   * This field is an array of glob patterns or an object with specific configurations for managing
+   * multiple packages in a single repository.
+   */
+  workspaces?: string[] | {
+    /**
+     * Workspace package paths. Glob patterns are supported.
+     */
+    packages?: string[];
+    /**
+     * Packages to block from hoisting to the workspace root.
+     * Uses glob patterns to match module paths in the dependency tree.
+     *
+     * Docs:
+     * - https://classic.yarnpkg.com/blog/2018/02/15/nohoist/
+     */
+    nohoist?: string[];
+  };
+  /**
+   * The field is used to specify different TypeScript declaration files for
+   * different versions of TypeScript, allowing for version-specific type definitions.
+   */
+  typesVersions?: Record<string, Record<string, string[]>>;
+  /**
+   * You can specify which operating systems your module will run on:
+   * ```json
+   * {
+   *   "os": ["darwin", "linux"]
+   * }
+   * ```
+   * You can also block instead of allowing operating systems, just prepend the blocked os with a '!':
+   * ```json
+   * {
+   *   "os": ["!win32"]
+   * }
+   * ```
+   * The host operating system is determined by `process.platform`
+   * It is allowed to both block and allow an item, although there isn't any good reason to do this.
+   */
+  os?: string[];
+  /**
+   * If your code only runs on certain cpu architectures, you can specify which ones.
+   * ```json
+   * {
+   *   "cpu": ["x64", "ia32"]
+   * }
+   * ```
+   * Like the `os` option, you can also block architectures:
+   * ```json
+   * {
+   *   "cpu": ["!arm", "!mips"]
+   * }
+   * ```
+   * The host architecture is determined by `process.arch`
+   */
+  cpu?: string[];
+  /**
+   * This is a set of config values that will be used at publish-time.
+   */
+  publishConfig?: {
+    /**
+     * The registry that will be used if the package is published.
+     */
+    registry?: string;
+    /**
+     * The tag that will be used if the package is published.
+     */
+    tag?: string;
+    /**
+     * The access level that will be used if the package is published.
+     */
+    access?: "public" | "restricted";
+    /**
+     * **pnpm-only**
+     *
+     * By default, for portability reasons, no files except those listed in
+     * the bin field will be marked as executable in the resulting package
+     * archive. The executableFiles field lets you declare additional fields
+     * that must have the executable flag (+x) set even if
+     * they aren't directly accessible through the bin field.
+     */
+    executableFiles?: string[];
+    /**
+     * **pnpm-only**
+     *
+     * You also can use the field `publishConfig.directory` to customize
+     * the published subdirectory relative to the current `package.json`.
+     *
+     * It is expected to have a modified version of the current package in
+     * the specified directory (usually using third party build tools).
+     */
+    directory?: string;
+    /**
+     * **pnpm-only**
+     *
+     * When set to `true`, the project will be symlinked from the
+     * `publishConfig.directory` location during local development.
+     * @default true
+     */
+    linkDirectory?: boolean;
+  } & Pick<PackageJson, "bin" | "main" | "exports" | "types" | "typings" | "module" | "browser" | "unpkg" | "typesVersions" | "os" | "cpu">;
+  /**
+   * See: https://nodejs.org/api/packages.html#packagemanager
+   * This field defines which package manager is expected to be used when working on the current project.
+   * Should be of the format: `<name>@<version>[#hash]`
+   */
+  packageManager?: string;
+  [key: string]: any;
+}
+/**
+ * See: https://docs.npmjs.com/cli/v11/using-npm/scripts#pre--post-scripts
+ */
+type PackageJsonScriptWithPreAndPost<S extends string> = S | `${"pre" | "post"}${S}`;
+/**
+ * See: https://docs.npmjs.com/cli/v11/using-npm/scripts#life-cycle-operation-order
+ */
+type PackageJsonNpmLifeCycleScripts = "dependencies" | "prepublishOnly" | PackageJsonScriptWithPreAndPost<"install" | "pack" | "prepare" | "publish" | "restart" | "start" | "stop" | "test" | "version">;
+/**
+ * See: https://pnpm.io/scripts#lifecycle-scripts
+ */
+type PackageJsonPnpmLifeCycleScripts = "pnpm:devPreinstall";
+type PackageJsonCommonScripts = "build" | "coverage" | "deploy" | "dev" | "format" | "lint" | "preview" | "release" | "typecheck" | "watch";
+type PackageJsonScriptName = PackageJsonCommonScripts | PackageJsonNpmLifeCycleScripts | PackageJsonPnpmLifeCycleScripts | (string & {});
+type PackageJsonScripts = { [P in PackageJsonScriptName]?: string };
+/**
+ * A “person” is an object with a “name” field and optionally “url” and “email”. Or you can shorten that all into a single string, and npm will parse it for you.
+ */
+type PackageJsonPerson = string | {
+  name: string;
+  email?: string;
+  url?: string;
+};
+type PackageJsonFunding = string | {
+  url: string;
+  type?: string;
+};
+type PackageJsonExportKey = "." | "import" | "require" | "types" | "node" | "browser" | "default" | (string & {});
+type PackageJsonExportsObject = { [P in PackageJsonExportKey]?: string | PackageJsonExportsObject | Array<string | PackageJsonExportsObject> };
+type PackageJsonExports = string | PackageJsonExportsObject | Array<string | PackageJsonExportsObject>;
+/**
+ * Defines a PackageJson structure.
+ * @param pkg - The `package.json` content as an object. See {@link PackageJson}.
+ * @returns the same `package.json` object.
+ */
+//#endregion
+//#region src/platforms/types.d.ts
+interface OutputExtensions {
+  js: string;
+  json: string;
+  wxml: string;
+  wxss: string;
+  wxs?: string;
+}
+//#endregion
+//#region src/runtime/config/types.d.ts
+interface LoadConfigOptions {
+  cwd: string;
+  isDev: boolean;
+  mode: string;
+  inlineConfig?: InlineConfig;
+  configFile?: string;
+  cliPlatform?: string;
+  projectConfigPath?: string;
+}
+interface LoadConfigResult {
+  config: InlineConfig;
+  aliasEntries: ResolvedAlias[];
+  outputExtensions: OutputExtensions;
+  packageJson: PackageJson;
+  relativeSrcRoot: (p: string) => string;
+  cwd: string;
+  isDev: boolean;
+  mode: string;
+  chunksConfigured?: boolean;
+  projectConfig: Record<string, any>;
+  projectConfigPath?: string;
+  projectPrivateConfigPath?: string;
+  mpDistRoot: string;
+  weappLib?: ResolvedWeappLibConfig;
+  weappLibOutputMap?: Map<string, string>;
+  packageJsonPath: string;
+  platform: MpPlatform;
+  srcRoot: string;
+  configFilePath?: string;
+  currentSubPackageRoot?: string;
+  weappWeb?: ResolvedWeappWebConfig;
+}
+interface ResolvedWeappLibConfig {
+  enabled: boolean;
+  entry: WeappLibConfig['entry'];
+  root: string;
+  outDir?: string;
+  preservePath: boolean;
+  fileName?: WeappLibFileName;
+  componentJson: WeappLibComponentJson;
+  dts: WeappLibDtsOptions;
+  source?: WeappLibConfig;
+}
+interface PackageInfo {
+  name: string;
+  version: string | undefined;
+  rootPath: string;
+  packageJsonPath: string;
+  packageJson: PackageJson;
+}
+interface ConfigService {
+  options: LoadConfigResult;
+  outputExtensions: OutputExtensions;
+  defineEnv: Record<string, any>;
+  packageManager: DetectResult;
+  packageInfo: PackageInfo;
+  setDefineEnv: (key: string, value: any) => void;
+  load: (options?: Partial<LoadConfigOptions>) => Promise<LoadConfigResult>;
+  mergeWorkers: (...configs: Partial<InlineConfig>[]) => InlineConfig;
+  merge: (subPackageMeta?: SubPackageMetaValue, ...configs: Partial<InlineConfig | undefined>[]) => InlineConfig;
+  mergeWeb: (...configs: Partial<InlineConfig | undefined>[]) => InlineConfig | undefined;
+  mergeInlineConfig: (...configs: Partial<InlineConfig>[]) => InlineConfig;
+  readonly defineImportMetaEnv: Record<string, any>;
+  readonly cwd: string;
+  readonly isDev: boolean;
+  readonly mpDistRoot: string;
+  readonly outDir: string;
+  readonly inlineConfig: InlineConfig;
+  readonly weappViteConfig: NonNullable<InlineConfig['weapp']>;
+  readonly packageJson: PackageJson;
+  readonly projectConfig: Record<string, any>;
+  readonly projectConfigPath?: string;
+  readonly projectPrivateConfigPath?: string;
+  readonly srcRoot: string;
+  readonly pluginRoot: string | undefined;
+  readonly absolutePluginRoot: string | undefined;
+  readonly absolutePluginOutputRoot: string | undefined;
+  readonly absoluteSrcRoot: string;
+  readonly mode: string;
+  readonly aliasEntries: ResolvedAlias[];
+  readonly platform: MpPlatform;
+  readonly configFilePath?: string;
+  readonly weappWebConfig?: ResolvedWeappWebConfig;
+  readonly weappLibConfig?: ResolvedWeappLibConfig;
+  readonly weappLibOutputMap?: Map<string, string>;
+  relativeCwd: (p: string) => string;
+  relativeSrcRoot: (p: string) => string;
+  relativeAbsoluteSrcRoot: (p: string) => string;
+  relativeOutputPath: (p: string) => string;
+  readonly currentSubPackageRoot?: string;
+}
+interface ResolvedWeappWebConfig {
+  enabled: boolean;
+  root: string;
+  srcDir: string;
+  outDir: string;
+  pluginOptions: Omit<WeappWebPluginOptions, 'srcDir'> & {
+    srcDir: string;
+  };
+  userConfig?: InlineConfig;
+  source?: WeappWebConfig;
+}
+//#endregion
+//#region src/utils/json.d.ts
+interface JsonResolvableEntry {
+  json?: any;
+  jsonPath?: string;
+  type?: 'app' | 'page' | 'component' | 'plugin';
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lru-cache@11.2.7/node_modules/lru-cache/dist/esm/index.d.ts
+/**
+ * @module LRUCache
+ */
+type Perf = {
+  now: () => number;
+};
+declare const TYPE: unique symbol;
+type Index = number & {
+  [TYPE]: 'LRUCache Index';
+};
+type UintArray = Uint8Array | Uint16Array | Uint32Array;
+type NumberArray = UintArray | number[];
+declare class ZeroArray extends Array<number> {
+  constructor(size: number);
+}
+type StackLike = Stack | Index[];
+declare class Stack {
+  #private;
+  heap: NumberArray;
+  length: number;
+  static create(max: number): StackLike;
+  constructor(max: number, HeapCls: {
+    new (n: number): NumberArray;
+  });
+  push(n: Index): void;
+  pop(): Index;
+}
+/**
+ * Promise representing an in-progress {@link LRUCache#fetch} call
+ */
+type BackgroundFetch<V> = Promise<V | undefined> & {
+  __returned: BackgroundFetch<V> | undefined;
+  __abortController: AbortController;
+  __staleWhileFetching: V | undefined;
+};
+declare namespace LRUCache {
+  /**
+   * An integer greater than 0, reflecting the calculated size of items
+   */
+  type Size = number;
+  /**
+   * Integer greater than 0, representing some number of milliseconds, or the
+   * time at which a TTL started counting from.
+   */
+  type Milliseconds = number;
+  /**
+   * An integer greater than 0, reflecting a number of items
+   */
+  type Count = number;
+  /**
+   * The reason why an item was removed from the cache, passed
+   * to the {@link Disposer} methods.
+   *
+   * - `evict`: The item was evicted because it is the least recently used,
+   *   and the cache is full.
+   * - `set`: A new value was set, overwriting the old value being disposed.
+   * - `delete`: The item was explicitly deleted, either by calling
+   *   {@link LRUCache#delete}, {@link LRUCache#clear}, or
+   *   {@link LRUCache#set} with an undefined value.
+   * - `expire`: The item was removed due to exceeding its TTL.
+   * - `fetch`: A {@link OptionsBase#fetchMethod} operation returned
+   *   `undefined` or was aborted, causing the item to be deleted.
+   */
+  type DisposeReason = 'evict' | 'set' | 'delete' | 'expire' | 'fetch';
+  /**
+   * A method called upon item removal, passed as the
+   * {@link OptionsBase.dispose} and/or
+   * {@link OptionsBase.disposeAfter} options.
+   */
+  type Disposer<K, V> = (value: V, key: K, reason: DisposeReason) => void;
+  /**
+   * The reason why an item was added to the cache, passed
+   * to the {@link Inserter} methods.
+   *
+   * - `add`: the item was not found in the cache, and was added
+   * - `update`: the item was in the cache, with the same value provided
+   * - `replace`: the item was in the cache, and replaced
+   */
+  type InsertReason = 'add' | 'update' | 'replace';
+  /**
+   * A method called upon item insertion, passed as the
+   * {@link OptionsBase.insert}
+   */
+  type Inserter<K, V> = (value: V, key: K, reason: InsertReason) => void;
+  /**
+   * A function that returns the effective calculated size
+   * of an entry in the cache.
+   */
+  type SizeCalculator<K, V> = (value: V, key: K) => Size;
+  /**
+   * Options provided to the
+   * {@link OptionsBase.fetchMethod} function.
+   */
+  interface FetcherOptions<K, V, FC = unknown> {
+    signal: AbortSignal;
+    options: FetcherFetchOptions<K, V, FC>;
+    /**
+     * Object provided in the {@link FetchOptions.context} option to
+     * {@link LRUCache#fetch}
+     */
+    context: FC;
+  }
+  /**
+   * Occasionally, it may be useful to track the internal behavior of the
+   * cache, particularly for logging, debugging, or for behavior within the
+   * `fetchMethod`. To do this, you can pass a `status` object to the
+   * {@link LRUCache#fetch}, {@link LRUCache#get}, {@link LRUCache#set},
+   * {@link LRUCache#memo}, and {@link LRUCache#has} methods.
+   *
+   * The `status` option should be a plain JavaScript object. The following
+   * fields will be set on it appropriately, depending on the situation.
+   */
+  interface Status<V> {
+    /**
+     * The status of a set() operation.
+     *
+     * - add: the item was not found in the cache, and was added
+     * - update: the item was in the cache, with the same value provided
+     * - replace: the item was in the cache, and replaced
+     * - miss: the item was not added to the cache for some reason
+     */
+    set?: 'add' | 'update' | 'replace' | 'miss';
+    /**
+     * the ttl stored for the item, or undefined if ttls are not used.
+     */
+    ttl?: Milliseconds;
+    /**
+     * the start time for the item, or undefined if ttls are not used.
+     */
+    start?: Milliseconds;
+    /**
+     * The timestamp used for TTL calculation
+     */
+    now?: Milliseconds;
+    /**
+     * the remaining ttl for the item, or undefined if ttls are not used.
+     */
+    remainingTTL?: Milliseconds;
+    /**
+     * The calculated size for the item, if sizes are used.
+     */
+    entrySize?: Size;
+    /**
+     * The total calculated size of the cache, if sizes are used.
+     */
+    totalCalculatedSize?: Size;
+    /**
+     * A flag indicating that the item was not stored, due to exceeding the
+     * {@link OptionsBase.maxEntrySize}
+     */
+    maxEntrySizeExceeded?: true;
+    /**
+     * The old value, specified in the case of `set:'update'` or
+     * `set:'replace'`
+     */
+    oldValue?: V;
+    /**
+     * The results of a {@link LRUCache#has} operation
+     *
+     * - hit: the item was found in the cache
+     * - stale: the item was found in the cache, but is stale
+     * - miss: the item was not found in the cache
+     */
+    has?: 'hit' | 'stale' | 'miss';
+    /**
+     * The status of a {@link LRUCache#fetch} operation.
+     * Note that this can change as the underlying fetch() moves through
+     * various states.
+     *
+     * - inflight: there is another fetch() for this key which is in process
+     * - get: there is no {@link OptionsBase.fetchMethod}, so
+     *   {@link LRUCache#get} was called.
+     * - miss: the item is not in cache, and will be fetched.
+     * - hit: the item is in the cache, and was resolved immediately.
+     * - stale: the item is in the cache, but stale.
+     * - refresh: the item is in the cache, and not stale, but
+     *   {@link FetchOptions.forceRefresh} was specified.
+     */
+    fetch?: 'get' | 'inflight' | 'miss' | 'hit' | 'stale' | 'refresh';
+    /**
+     * The {@link OptionsBase.fetchMethod} was called
+     */
+    fetchDispatched?: true;
+    /**
+     * The cached value was updated after a successful call to
+     * {@link OptionsBase.fetchMethod}
+     */
+    fetchUpdated?: true;
+    /**
+     * The reason for a fetch() rejection.  Either the error raised by the
+     * {@link OptionsBase.fetchMethod}, or the reason for an
+     * AbortSignal.
+     */
+    fetchError?: Error;
+    /**
+     * The fetch received an abort signal
+     */
+    fetchAborted?: true;
+    /**
+     * The abort signal received was ignored, and the fetch was allowed to
+     * continue.
+     */
+    fetchAbortIgnored?: true;
+    /**
+     * The fetchMethod promise resolved successfully
+     */
+    fetchResolved?: true;
+    /**
+     * The fetchMethod promise was rejected
+     */
+    fetchRejected?: true;
+    /**
+     * The status of a {@link LRUCache#get} operation.
+     *
+     * - fetching: The item is currently being fetched.  If a previous value
+     *   is present and allowed, that will be returned.
+     * - stale: The item is in the cache, and is stale.
+     * - hit: the item is in the cache
+     * - miss: the item is not in the cache
+     */
+    get?: 'stale' | 'hit' | 'miss';
+    /**
+     * A fetch or get operation returned a stale value.
+     */
+    returnedStale?: true;
+  }
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when calling {@link LRUCache#fetch}.
+   *
+   * This is the union of {@link GetOptions} and {@link SetOptions}, plus
+   * {@link OptionsBase.noDeleteOnFetchRejection},
+   * {@link OptionsBase.allowStaleOnFetchRejection},
+   * {@link FetchOptions.forceRefresh}, and
+   * {@link FetcherOptions.context}
+   *
+   * Any of these may be modified in the {@link OptionsBase.fetchMethod}
+   * function, but the {@link GetOptions} fields will of course have no
+   * effect, as the {@link LRUCache#get} call already happened by the time
+   * the fetchMethod is called.
+   */
+  interface FetcherFetchOptions<K, V, FC = unknown> extends Pick<OptionsBase<K, V, FC>, 'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet' | 'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL' | 'noDeleteOnFetchRejection' | 'allowStaleOnFetchRejection' | 'ignoreFetchAbort' | 'allowStaleOnFetchAbort'> {
+    status?: Status<V>;
+    size?: Size;
+  }
+  /**
+   * Options that may be passed to the {@link LRUCache#fetch} method.
+   */
+  interface FetchOptions<K, V, FC> extends FetcherFetchOptions<K, V, FC> {
+    /**
+     * Set to true to force a re-load of the existing data, even if it
+     * is not yet stale.
+     */
+    forceRefresh?: boolean;
+    /**
+     * Context provided to the {@link OptionsBase.fetchMethod} as
+     * the {@link FetcherOptions.context} param.
+     *
+     * If the FC type is specified as unknown (the default),
+     * undefined or void, then this is optional.  Otherwise, it will
+     * be required.
+     */
+    context?: FC;
+    signal?: AbortSignal;
+    status?: Status<V>;
+  }
+  /**
+   * Options provided to {@link LRUCache#fetch} when the FC type is something
+   * other than `unknown`, `undefined`, or `void`
+   */
+  interface FetchOptionsWithContext<K, V, FC> extends FetchOptions<K, V, FC> {
+    context: FC;
+  }
+  /**
+   * Options provided to {@link LRUCache#fetch} when the FC type is
+   * `undefined` or `void`
+   */
+  interface FetchOptionsNoContext<K, V> extends FetchOptions<K, V, undefined> {
+    context?: undefined;
+  }
+  interface MemoOptions<K, V, FC = unknown> extends Pick<OptionsBase<K, V, FC>, 'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet' | 'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL' | 'noDeleteOnFetchRejection' | 'allowStaleOnFetchRejection' | 'ignoreFetchAbort' | 'allowStaleOnFetchAbort'> {
+    /**
+     * Set to true to force a re-load of the existing data, even if it
+     * is not yet stale.
+     */
+    forceRefresh?: boolean;
+    /**
+     * Context provided to the {@link OptionsBase.memoMethod} as
+     * the {@link MemoizerOptions.context} param.
+     *
+     * If the FC type is specified as unknown (the default),
+     * undefined or void, then this is optional.  Otherwise, it will
+     * be required.
+     */
+    context?: FC;
+    status?: Status<V>;
+  }
+  /**
+   * Options provided to {@link LRUCache#memo} when the FC type is something
+   * other than `unknown`, `undefined`, or `void`
+   */
+  interface MemoOptionsWithContext<K, V, FC> extends MemoOptions<K, V, FC> {
+    context: FC;
+  }
+  /**
+   * Options provided to {@link LRUCache#memo} when the FC type is
+   * `undefined` or `void`
+   */
+  interface MemoOptionsNoContext<K, V> extends MemoOptions<K, V, undefined> {
+    context?: undefined;
+  }
+  /**
+   * Options provided to the
+   * {@link OptionsBase.memoMethod} function.
+   */
+  interface MemoizerOptions<K, V, FC = unknown> {
+    options: MemoizerMemoOptions<K, V, FC>;
+    /**
+     * Object provided in the {@link MemoOptions.context} option to
+     * {@link LRUCache#memo}
+     */
+    context: FC;
+  }
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when calling {@link LRUCache#memo}.
+   *
+   * This is the union of {@link GetOptions} and {@link SetOptions}, plus
+   * {@link MemoOptions.forceRefresh}, and
+   * {@link MemoOptions.context}
+   *
+   * Any of these may be modified in the {@link OptionsBase.memoMethod}
+   * function, but the {@link GetOptions} fields will of course have no
+   * effect, as the {@link LRUCache#get} call already happened by the time
+   * the memoMethod is called.
+   */
+  interface MemoizerMemoOptions<K, V, FC = unknown> extends Pick<OptionsBase<K, V, FC>, 'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet' | 'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL'> {
+    status?: Status<V>;
+    size?: Size;
+    start?: Milliseconds;
+  }
+  /**
+   * Options that may be passed to the {@link LRUCache#has} method.
+   */
+  interface HasOptions<K, V, FC> extends Pick<OptionsBase<K, V, FC>, 'updateAgeOnHas'> {
+    status?: Status<V>;
+  }
+  /**
+   * Options that may be passed to the {@link LRUCache#get} method.
+   */
+  interface GetOptions<K, V, FC> extends Pick<OptionsBase<K, V, FC>, 'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet'> {
+    status?: Status<V>;
+  }
+  /**
+   * Options that may be passed to the {@link LRUCache#peek} method.
+   */
+  interface PeekOptions<K, V, FC> extends Pick<OptionsBase<K, V, FC>, 'allowStale'> {}
+  /**
+   * Options that may be passed to the {@link LRUCache#set} method.
+   */
+  interface SetOptions<K, V, FC> extends Pick<OptionsBase<K, V, FC>, 'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL'> {
+    /**
+     * If size tracking is enabled, then setting an explicit size
+     * in the {@link LRUCache#set} call will prevent calling the
+     * {@link OptionsBase.sizeCalculation} function.
+     */
+    size?: Size;
+    /**
+     * If TTL tracking is enabled, then setting an explicit start
+     * time in the {@link LRUCache#set} call will override the
+     * default time from `performance.now()` or `Date.now()`.
+     *
+     * Note that it must be a valid value for whichever time-tracking
+     * method is in use.
+     */
+    start?: Milliseconds;
+    status?: Status<V>;
+  }
+  /**
+   * The type signature for the {@link OptionsBase.fetchMethod} option.
+   */
+  type Fetcher<K, V, FC = unknown> = (key: K, staleValue: V | undefined, options: FetcherOptions<K, V, FC>) => Promise<V | undefined | void> | V | undefined | void;
+  /**
+   * the type signature for the {@link OptionsBase.memoMethod} option.
+   */
+  type Memoizer<K, V, FC = unknown> = (key: K, staleValue: V | undefined, options: MemoizerOptions<K, V, FC>) => V;
+  /**
+   * Options which may be passed to the {@link LRUCache} constructor.
+   *
+   * Most of these may be overridden in the various options that use
+   * them.
+   *
+   * Despite all being technically optional, the constructor requires that
+   * a cache is at minimum limited by one or more of {@link OptionsBase.max},
+   * {@link OptionsBase.ttl}, or {@link OptionsBase.maxSize}.
+   *
+   * If {@link OptionsBase.ttl} is used alone, then it is strongly advised
+   * (and in fact required by the type definitions here) that the cache
+   * also set {@link OptionsBase.ttlAutopurge}, to prevent potentially
+   * unbounded storage.
+   *
+   * All options are also available on the {@link LRUCache} instance, making
+   * it safe to pass an LRUCache instance as the options argumemnt to
+   * make another empty cache of the same type.
+   *
+   * Some options are marked as read-only, because changing them after
+   * instantiation is not safe. Changing any of the other options will of
+   * course only have an effect on subsequent method calls.
+   */
+  interface OptionsBase<K, V, FC> {
+    /**
+     * The maximum number of items to store in the cache before evicting
+     * old entries. This is read-only on the {@link LRUCache} instance,
+     * and may not be overridden.
+     *
+     * If set, then storage space will be pre-allocated at construction
+     * time, and the cache will perform significantly faster.
+     *
+     * Note that significantly fewer items may be stored, if
+     * {@link OptionsBase.maxSize} and/or {@link OptionsBase.ttl} are also
+     * set.
+     *
+     * **It is strongly recommended to set a `max` to prevent unbounded growth
+     * of the cache.**
+     */
+    max?: Count;
+    /**
+     * Max time in milliseconds for items to live in cache before they are
+     * considered stale.  Note that stale items are NOT preemptively removed by
+     * default, and MAY live in the cache, contributing to its LRU max, long
+     * after they have expired, unless {@link OptionsBase.ttlAutopurge} is
+     * set.
+     *
+     * If set to `0` (the default value), then that means "do not track
+     * TTL", not "expire immediately".
+     *
+     * Also, as this cache is optimized for LRU/MRU operations, some of
+     * the staleness/TTL checks will reduce performance, as they will incur
+     * overhead by deleting items.
+     *
+     * This is not primarily a TTL cache, and does not make strong TTL
+     * guarantees. There is no pre-emptive pruning of expired items, but you
+     * _may_ set a TTL on the cache, and it will treat expired items as missing
+     * when they are fetched, and delete them.
+     *
+     * Optional, but must be a non-negative integer in ms if specified.
+     *
+     * This may be overridden by passing an options object to `cache.set()`.
+     *
+     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a
+     * positive integer if set.
+     *
+     * Even if ttl tracking is enabled, **it is strongly recommended to set a
+     * `max` to prevent unbounded growth of the cache.**
+     *
+     * If ttl tracking is enabled, and `max` and `maxSize` are not set,
+     * and `ttlAutopurge` is not set, then a warning will be emitted
+     * cautioning about the potential for unbounded memory consumption.
+     * (The TypeScript definitions will also discourage this.)
+     */
+    ttl?: Milliseconds;
+    /**
+     * Minimum amount of time in ms in which to check for staleness.
+     * Defaults to 1, which means that the current time is checked
+     * at most once per millisecond.
+     *
+     * Set to 0 to check the current time every time staleness is tested.
+     * (This reduces performance, and is theoretically unnecessary.)
+     *
+     * Setting this to a higher value will improve performance somewhat
+     * while using ttl tracking, albeit at the expense of keeping stale
+     * items around a bit longer than their TTLs would indicate.
+     *
+     * @default 1
+     */
+    ttlResolution?: Milliseconds;
+    /**
+     * Preemptively remove stale items from the cache.
+     *
+     * Note that this may *significantly* degrade performance, especially if
+     * the cache is storing a large number of items. It is almost always best
+     * to just leave the stale items in the cache, and let them fall out as new
+     * items are added.
+     *
+     * Note that this means that {@link OptionsBase.allowStale} is a bit
+     * pointless, as stale items will be deleted almost as soon as they
+     * expire.
+     *
+     * Use with caution!
+     */
+    ttlAutopurge?: boolean;
+    /**
+     * When using time-expiring entries with `ttl`, setting this to `true` will
+     * make each item's age reset to 0 whenever it is retrieved from cache with
+     * {@link LRUCache#get}, causing it to not expire. (It can still fall out
+     * of cache based on recency of use, of course.)
+     *
+     * Has no effect if {@link OptionsBase.ttl} is not set.
+     *
+     * This may be overridden by passing an options object to `cache.get()`.
+     */
+    updateAgeOnGet?: boolean;
+    /**
+     * When using time-expiring entries with `ttl`, setting this to `true` will
+     * make each item's age reset to 0 whenever its presence in the cache is
+     * checked with {@link LRUCache#has}, causing it to not expire. (It can
+     * still fall out of cache based on recency of use, of course.)
+     *
+     * Has no effect if {@link OptionsBase.ttl} is not set.
+     */
+    updateAgeOnHas?: boolean;
+    /**
+     * Allow {@link LRUCache#get} and {@link LRUCache#fetch} calls to return
+     * stale data, if available.
+     *
+     * By default, if you set `ttl`, stale items will only be deleted from the
+     * cache when you `get(key)`. That is, it's not preemptively pruning items,
+     * unless {@link OptionsBase.ttlAutopurge} is set.
+     *
+     * If you set `allowStale:true`, it'll return the stale value *as well as*
+     * deleting it. If you don't set this, then it'll return `undefined` when
+     * you try to get a stale entry.
+     *
+     * Note that when a stale entry is fetched, _even if it is returned due to
+     * `allowStale` being set_, it is removed from the cache immediately. You
+     * can suppress this behavior by setting
+     * {@link OptionsBase.noDeleteOnStaleGet}, either in the constructor, or in
+     * the options provided to {@link LRUCache#get}.
+     *
+     * This may be overridden by passing an options object to `cache.get()`.
+     * The `cache.has()` method will always return `false` for stale items.
+     *
+     * Only relevant if a ttl is set.
+     */
+    allowStale?: boolean;
+    /**
+     * Function that is called on items when they are dropped from the
+     * cache, as `dispose(value, key, reason)`.
+     *
+     * This can be handy if you want to close file descriptors or do
+     * other cleanup tasks when items are no longer stored in the cache.
+     *
+     * **NOTE**: It is called _before_ the item has been fully removed
+     * from the cache, so if you want to put it right back in, you need
+     * to wait until the next tick. If you try to add it back in during
+     * the `dispose()` function call, it will break things in subtle and
+     * weird ways.
+     *
+     * Unlike several other options, this may _not_ be overridden by
+     * passing an option to `set()`, for performance reasons.
+     *
+     * The `reason` will be one of the following strings, corresponding
+     * to the reason for the item's deletion:
+     *
+     * - `evict` Item was evicted to make space for a new addition
+     * - `set` Item was overwritten by a new value
+     * - `expire` Item expired its TTL
+     * - `fetch` Item was deleted due to a failed or aborted fetch, or a
+     *   fetchMethod returning `undefined.
+     * - `delete` Item was removed by explicit `cache.delete(key)`,
+     *   `cache.clear()`, or `cache.set(key, undefined)`.
+     */
+    dispose?: Disposer<K, V>;
+    /**
+     * Function that is called when new items are inserted into the cache,
+     * as `onInsert(value, key, reason)`.
+     *
+     * This can be useful if you need to perform actions when an item is
+     * added, such as logging or tracking insertions.
+     *
+     * Unlike some other options, this may _not_ be overridden by passing
+     * an option to `set()`, for performance and consistency reasons.
+     */
+    onInsert?: Inserter<K, V>;
+    /**
+     * The same as {@link OptionsBase.dispose}, but called *after* the entry
+     * is completely removed and the cache is once again in a clean state.
+     *
+     * It is safe to add an item right back into the cache at this point.
+     * However, note that it is *very* easy to inadvertently create infinite
+     * recursion this way.
+     */
+    disposeAfter?: Disposer<K, V>;
+    /**
+     * Set to true to suppress calling the
+     * {@link OptionsBase.dispose} function if the entry key is
+     * still accessible within the cache.
+     *
+     * This may be overridden by passing an options object to
+     * {@link LRUCache#set}.
+     *
+     * Only relevant if `dispose` or `disposeAfter` are set.
+     */
+    noDisposeOnSet?: boolean;
+    /**
+     * Boolean flag to tell the cache to not update the TTL when setting a new
+     * value for an existing key (ie, when updating a value rather than
+     * inserting a new value).  Note that the TTL value is _always_ set (if
+     * provided) when adding a new entry into the cache.
+     *
+     * Has no effect if a {@link OptionsBase.ttl} is not set.
+     *
+     * May be passed as an option to {@link LRUCache#set}.
+     */
+    noUpdateTTL?: boolean;
+    /**
+     * Set to a positive integer to track the sizes of items added to the
+     * cache, and automatically evict items in order to stay below this size.
+     * Note that this may result in fewer than `max` items being stored.
+     *
+     * Attempting to add an item to the cache whose calculated size is greater
+     * that this amount will be a no-op. The item will not be cached, and no
+     * other items will be evicted.
+     *
+     * Optional, must be a positive integer if provided.
+     *
+     * Sets `maxEntrySize` to the same value, unless a different value is
+     * provided for `maxEntrySize`.
+     *
+     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a
+     * positive integer if set.
+     *
+     * Even if size tracking is enabled, **it is strongly recommended to set a
+     * `max` to prevent unbounded growth of the cache.**
+     *
+     * Note also that size tracking can negatively impact performance,
+     * though for most cases, only minimally.
+     */
+    maxSize?: Size;
+    /**
+     * The maximum allowed size for any single item in the cache.
+     *
+     * If a larger item is passed to {@link LRUCache#set} or returned by a
+     * {@link OptionsBase.fetchMethod} or {@link OptionsBase.memoMethod}, then
+     * it will not be stored in the cache.
+     *
+     * Attempting to add an item whose calculated size is greater than
+     * this amount will not cache the item or evict any old items, but
+     * WILL delete an existing value if one is already present.
+     *
+     * Optional, must be a positive integer if provided. Defaults to
+     * the value of `maxSize` if provided.
+     */
+    maxEntrySize?: Size;
+    /**
+     * A function that returns a number indicating the item's size.
+     *
+     * Requires {@link OptionsBase.maxSize} to be set.
+     *
+     * If not provided, and {@link OptionsBase.maxSize} or
+     * {@link OptionsBase.maxEntrySize} are set, then all
+     * {@link LRUCache#set} calls **must** provide an explicit
+     * {@link SetOptions.size} or sizeCalculation param.
+     */
+    sizeCalculation?: SizeCalculator<K, V>;
+    /**
+     * Method that provides the implementation for {@link LRUCache#fetch}
+     *
+     * ```ts
+     * fetchMethod(key, staleValue, { signal, options, context })
+     * ```
+     *
+     * If `fetchMethod` is not provided, then `cache.fetch(key)` is equivalent
+     * to `Promise.resolve(cache.get(key))`.
+     *
+     * If at any time, `signal.aborted` is set to `true`, or if the
+     * `signal.onabort` method is called, or if it emits an `'abort'` event
+     * which you can listen to with `addEventListener`, then that means that
+     * the fetch should be abandoned. This may be passed along to async
+     * functions aware of AbortController/AbortSignal behavior.
+     *
+     * The `fetchMethod` should **only** return `undefined` or a Promise
+     * resolving to `undefined` if the AbortController signaled an `abort`
+     * event. In all other cases, it should return or resolve to a value
+     * suitable for adding to the cache.
+     *
+     * The `options` object is a union of the options that may be provided to
+     * `set()` and `get()`. If they are modified, then that will result in
+     * modifying the settings to `cache.set()` when the value is resolved, and
+     * in the case of
+     * {@link OptionsBase.noDeleteOnFetchRejection} and
+     * {@link OptionsBase.allowStaleOnFetchRejection}, the handling of
+     * `fetchMethod` failures.
+     *
+     * For example, a DNS cache may update the TTL based on the value returned
+     * from a remote DNS server by changing `options.ttl` in the `fetchMethod`.
+     */
+    fetchMethod?: Fetcher<K, V, FC>;
+    /**
+     * Method that provides the implementation for {@link LRUCache#memo}
+     */
+    memoMethod?: Memoizer<K, V, FC>;
+    /**
+     * Set to true to suppress the deletion of stale data when a
+     * {@link OptionsBase.fetchMethod} returns a rejected promise.
+     */
+    noDeleteOnFetchRejection?: boolean;
+    /**
+     * Do not delete stale items when they are retrieved with
+     * {@link LRUCache#get}.
+     *
+     * Note that the `get` return value will still be `undefined`
+     * unless {@link OptionsBase.allowStale} is true.
+     *
+     * When using time-expiring entries with `ttl`, by default stale
+     * items will be removed from the cache when the key is accessed
+     * with `cache.get()`.
+     *
+     * Setting this option will cause stale items to remain in the cache, until
+     * they are explicitly deleted with `cache.delete(key)`, or retrieved with
+     * `noDeleteOnStaleGet` set to `false`.
+     *
+     * This may be overridden by passing an options object to `cache.get()`.
+     *
+     * Only relevant if a ttl is used.
+     */
+    noDeleteOnStaleGet?: boolean;
+    /**
+     * Set to true to allow returning stale data when a
+     * {@link OptionsBase.fetchMethod} throws an error or returns a rejected
+     * promise.
+     *
+     * This differs from using {@link OptionsBase.allowStale} in that stale
+     * data will ONLY be returned in the case that the {@link LRUCache#fetch}
+     * fails, not any other times.
+     *
+     * If a `fetchMethod` fails, and there is no stale value available, the
+     * `fetch()` will resolve to `undefined`. Ie, all `fetchMethod` errors are
+     * suppressed.
+     *
+     * Implies `noDeleteOnFetchRejection`.
+     *
+     * This may be set in calls to `fetch()`, or defaulted on the constructor,
+     * or overridden by modifying the options object in the `fetchMethod`.
+     */
+    allowStaleOnFetchRejection?: boolean;
+    /**
+     * Set to true to return a stale value from the cache when the
+     * `AbortSignal` passed to the {@link OptionsBase.fetchMethod} dispatches
+     * an `'abort'` event, whether user-triggered, or due to internal cache
+     * behavior.
+     *
+     * Unless {@link OptionsBase.ignoreFetchAbort} is also set, the underlying
+     * {@link OptionsBase.fetchMethod} will still be considered canceled, and
+     * any value it returns will be ignored and not cached.
+     *
+     * Caveat: since fetches are aborted when a new value is explicitly
+     * set in the cache, this can lead to fetch returning a stale value,
+     * since that was the fallback value _at the moment the `fetch()` was
+     * initiated_, even though the new updated value is now present in
+     * the cache.
+     *
+     * For example:
+     *
+     * ```ts
+     * const cache = new LRUCache<string, any>({
+     *   ttl: 100,
+     *   fetchMethod: async (url, oldValue, { signal }) =>  {
+     *     const res = await fetch(url, { signal })
+     *     return await res.json()
+     *   }
+     * })
+     * cache.set('https://example.com/', { some: 'data' })
+     * // 100ms go by...
+     * const result = cache.fetch('https://example.com/')
+     * cache.set('https://example.com/', { other: 'thing' })
+     * console.log(await result) // { some: 'data' }
+     * console.log(cache.get('https://example.com/')) // { other: 'thing' }
+     * ```
+     */
+    allowStaleOnFetchAbort?: boolean;
+    /**
+     * Set to true to ignore the `abort` event emitted by the `AbortSignal`
+     * object passed to {@link OptionsBase.fetchMethod}, and still cache the
+     * resulting resolution value, as long as it is not `undefined`.
+     *
+     * When used on its own, this means aborted {@link LRUCache#fetch} calls
+     * are not immediately resolved or rejected when they are aborted, and
+     * instead take the full time to await.
+     *
+     * When used with {@link OptionsBase.allowStaleOnFetchAbort}, aborted
+     * {@link LRUCache#fetch} calls will resolve immediately to their stale
+     * cached value or `undefined`, and will continue to process and eventually
+     * update the cache when they resolve, as long as the resulting value is
+     * not `undefined`, thus supporting a "return stale on timeout while
+     * refreshing" mechanism by passing `AbortSignal.timeout(n)` as the signal.
+     *
+     * For example:
+     *
+     * ```ts
+     * const c = new LRUCache({
+     *   ttl: 100,
+     *   ignoreFetchAbort: true,
+     *   allowStaleOnFetchAbort: true,
+     *   fetchMethod: async (key, oldValue, { signal }) => {
+     *     // note: do NOT pass the signal to fetch()!
+     *     // let's say this fetch can take a long time.
+     *     const res = await fetch(`https://slow-backend-server/${key}`)
+     *     return await res.json()
+     *   },
+     * })
+     *
+     * // this will return the stale value after 100ms, while still
+     * // updating in the background for next time.
+     * const val = await c.fetch('key', { signal: AbortSignal.timeout(100) })
+     * ```
+     *
+     * **Note**: regardless of this setting, an `abort` event _is still
+     * emitted on the `AbortSignal` object_, so may result in invalid results
+     * when passed to other underlying APIs that use AbortSignals.
+     *
+     * This may be overridden in the {@link OptionsBase.fetchMethod} or the
+     * call to {@link LRUCache#fetch}.
+     */
+    ignoreFetchAbort?: boolean;
+    /**
+     * In some cases, you may want to swap out the performance/Date object
+     * used for TTL tracking. This should almost certainly NOT be done in
+     * production environments!
+     *
+     * This value defaults to `global.performance` if it has a `now()` method,
+     * or the `global.Date` object otherwise.
+     */
+    perf?: Perf;
+  }
+  interface OptionsMaxLimit<K, V, FC> extends OptionsBase<K, V, FC> {
+    max: Count;
+  }
+  interface OptionsTTLLimit<K, V, FC> extends OptionsBase<K, V, FC> {
+    ttl: Milliseconds;
+    ttlAutopurge: boolean;
+  }
+  interface OptionsSizeLimit<K, V, FC> extends OptionsBase<K, V, FC> {
+    maxSize: Size;
+  }
+  /**
+   * The valid safe options for the {@link LRUCache} constructor
+   */
+  type Options<K, V, FC> = OptionsMaxLimit<K, V, FC> | OptionsSizeLimit<K, V, FC> | OptionsTTLLimit<K, V, FC>;
+  /**
+   * Entry objects used by {@link LRUCache#load} and {@link LRUCache#dump},
+   * and returned by {@link LRUCache#info}.
+   */
+  interface Entry<V> {
+    value: V;
+    ttl?: Milliseconds;
+    size?: Size;
+    start?: Milliseconds;
+  }
+}
+/**
+ * Default export, the thing you're using this module to get.
+ *
+ * The `K` and `V` types define the key and value types, respectively. The
+ * optional `FC` type defines the type of the `context` object passed to
+ * `cache.fetch()` and `cache.memo()`.
+ *
+ * Keys and values **must not** be `null` or `undefined`.
+ *
+ * All properties from the options object (with the exception of `max`,
+ * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+ * added as normal public members. (The listed options are read-only getters.)
+ *
+ * Changing any of these will alter the defaults for subsequent method calls.
+ */
+declare class LRUCache<K extends {}, V extends {}, FC = unknown> {
+  #private;
+  /**
+   * {@link LRUCache.OptionsBase.perf}
+   */
+  get perf(): Perf;
+  /**
+   * {@link LRUCache.OptionsBase.ttl}
+   */
+  ttl: LRUCache.Milliseconds;
+  /**
+   * {@link LRUCache.OptionsBase.ttlResolution}
+   */
+  ttlResolution: LRUCache.Milliseconds;
+  /**
+   * {@link LRUCache.OptionsBase.ttlAutopurge}
+   */
+  ttlAutopurge: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.updateAgeOnGet}
+   */
+  updateAgeOnGet: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.updateAgeOnHas}
+   */
+  updateAgeOnHas: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.allowStale}
+   */
+  allowStale: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.noDisposeOnSet}
+   */
+  noDisposeOnSet: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.noUpdateTTL}
+   */
+  noUpdateTTL: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.maxEntrySize}
+   */
+  maxEntrySize: LRUCache.Size;
+  /**
+   * {@link LRUCache.OptionsBase.sizeCalculation}
+   */
+  sizeCalculation?: LRUCache.SizeCalculator<K, V>;
+  /**
+   * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+   */
+  noDeleteOnFetchRejection: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+   */
+  noDeleteOnStaleGet: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+   */
+  allowStaleOnFetchAbort: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+   */
+  allowStaleOnFetchRejection: boolean;
+  /**
+   * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+   */
+  ignoreFetchAbort: boolean;
+  /**
+   * Do not call this method unless you need to inspect the
+   * inner workings of the cache.  If anything returned by this
+   * object is modified in any way, strange breakage may occur.
+   *
+   * These fields are private for a reason!
+   *
+   * @internal
+   */
+  static unsafeExposeInternals<K extends {}, V extends {}, FC extends unknown = unknown>(c: LRUCache<K, V, FC>): {
+    starts: ZeroArray | undefined;
+    ttls: ZeroArray | undefined;
+    autopurgeTimers: (NodeJS.Timeout | undefined)[] | undefined;
+    sizes: ZeroArray | undefined;
+    keyMap: Map<K, number>;
+    keyList: (K | undefined)[];
+    valList: (V | BackgroundFetch<V> | undefined)[];
+    next: NumberArray;
+    prev: NumberArray;
+    readonly head: Index;
+    readonly tail: Index;
+    free: StackLike;
+    isBackgroundFetch: (p: any) => p is BackgroundFetch<V>;
+    backgroundFetch: (k: K, index: number | undefined, options: LRUCache.FetchOptions<K, V, FC>, context: any) => BackgroundFetch<V>;
+    moveToTail: (index: number) => void;
+    indexes: (options?: {
+      allowStale: boolean;
+    }) => Generator<Index, void, unknown>;
+    rindexes: (options?: {
+      allowStale: boolean;
+    }) => Generator<Index, void, unknown>;
+    isStale: (index: number | undefined) => boolean;
+  };
+  /**
+   * {@link LRUCache.OptionsBase.max} (read-only)
+   */
+  get max(): LRUCache.Count;
+  /**
+   * {@link LRUCache.OptionsBase.maxSize} (read-only)
+   */
+  get maxSize(): LRUCache.Count;
+  /**
+   * The total computed size of items in the cache (read-only)
+   */
+  get calculatedSize(): LRUCache.Size;
+  /**
+   * The number of items stored in the cache (read-only)
+   */
+  get size(): LRUCache.Count;
+  /**
+   * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+   */
+  get fetchMethod(): LRUCache.Fetcher<K, V, FC> | undefined;
+  get memoMethod(): LRUCache.Memoizer<K, V, FC> | undefined;
+  /**
+   * {@link LRUCache.OptionsBase.dispose} (read-only)
+   */
+  get dispose(): LRUCache.Disposer<K, V> | undefined;
+  /**
+   * {@link LRUCache.OptionsBase.onInsert} (read-only)
+   */
+  get onInsert(): LRUCache.Inserter<K, V> | undefined;
+  /**
+   * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+   */
+  get disposeAfter(): LRUCache.Disposer<K, V> | undefined;
+  constructor(options: LRUCache.Options<K, V, FC> | LRUCache<K, V, FC>);
+  /**
+   * Return the number of ms left in the item's TTL. If item is not in cache,
+   * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+   */
+  getRemainingTTL(key: K): number;
+  /**
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from most recently used to least recently used.
+   */
+  entries(): Generator<[K, V], void, unknown>;
+  /**
+   * Inverse order version of {@link LRUCache.entries}
+   *
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from least recently used to most recently used.
+   */
+  rentries(): Generator<(K | V)[], void, unknown>;
+  /**
+   * Return a generator yielding the keys in the cache,
+   * in order from most recently used to least recently used.
+   */
+  keys(): Generator<K, void, unknown>;
+  /**
+   * Inverse order version of {@link LRUCache.keys}
+   *
+   * Return a generator yielding the keys in the cache,
+   * in order from least recently used to most recently used.
+   */
+  rkeys(): Generator<K, void, unknown>;
+  /**
+   * Return a generator yielding the values in the cache,
+   * in order from most recently used to least recently used.
+   */
+  values(): Generator<V, void, unknown>;
+  /**
+   * Inverse order version of {@link LRUCache.values}
+   *
+   * Return a generator yielding the values in the cache,
+   * in order from least recently used to most recently used.
+   */
+  rvalues(): Generator<V | undefined, void, unknown>;
+  /**
+   * Iterating over the cache itself yields the same results as
+   * {@link LRUCache.entries}
+   */
+  [Symbol.iterator](): Generator<[K, V], void, unknown>;
+  /**
+   * A String value that is used in the creation of the default string
+   * description of an object. Called by the built-in method
+   * `Object.prototype.toString`.
+   */
+  [Symbol.toStringTag]: string;
+  /**
+   * Find a value for which the supplied fn method returns a truthy value,
+   * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+   */
+  find(fn: (v: V, k: K, self: LRUCache<K, V, FC>) => boolean, getOptions?: LRUCache.GetOptions<K, V, FC>): V | undefined;
+  /**
+   * Call the supplied function on each item in the cache, in order from most
+   * recently used to least recently used.
+   *
+   * `fn` is called as `fn(value, key, cache)`.
+   *
+   * If `thisp` is provided, function will be called in the `this`-context of
+   * the provided object, or the cache if no `thisp` object is provided.
+   *
+   * Does not update age or recenty of use, or iterate over stale values.
+   */
+  forEach(fn: (v: V, k: K, self: LRUCache<K, V, FC>) => any, thisp?: any): void;
+  /**
+   * The same as {@link LRUCache.forEach} but items are iterated over in
+   * reverse order.  (ie, less recently used items are iterated over first.)
+   */
+  rforEach(fn: (v: V, k: K, self: LRUCache<K, V, FC>) => any, thisp?: any): void;
+  /**
+   * Delete any stale entries. Returns true if anything was removed,
+   * false otherwise.
+   */
+  purgeStale(): boolean;
+  /**
+   * Get the extended info about a given entry, to get its value, size, and
+   * TTL info simultaneously. Returns `undefined` if the key is not present.
+   *
+   * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+   * serialization, the `start` value is always the current timestamp, and the
+   * `ttl` is a calculated remaining time to live (negative if expired).
+   *
+   * Always returns stale values, if their info is found in the cache, so be
+   * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+   * if relevant.
+   */
+  info(key: K): LRUCache.Entry<V> | undefined;
+  /**
+   * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+   * passed to {@link LRUCache#load}.
+   *
+   * The `start` fields are calculated relative to a portable `Date.now()`
+   * timestamp, even if `performance.now()` is available.
+   *
+   * Stale entries are always included in the `dump`, even if
+   * {@link LRUCache.OptionsBase.allowStale} is false.
+   *
+   * Note: this returns an actual array, not a generator, so it can be more
+   * easily passed around.
+   */
+  dump(): [K, LRUCache.Entry<V>][];
+  /**
+   * Reset the cache and load in the items in entries in the order listed.
+   *
+   * The shape of the resulting cache may be different if the same options are
+   * not used in both caches.
+   *
+   * The `start` fields are assumed to be calculated relative to a portable
+   * `Date.now()` timestamp, even if `performance.now()` is available.
+   */
+  load(arr: [K, LRUCache.Entry<V>][]): void;
+  /**
+   * Add a value to the cache.
+   *
+   * Note: if `undefined` is specified as a value, this is an alias for
+   * {@link LRUCache#delete}
+   *
+   * Fields on the {@link LRUCache.SetOptions} options param will override
+   * their corresponding values in the constructor options for the scope
+   * of this single `set()` operation.
+   *
+   * If `start` is provided, then that will set the effective start
+   * time for the TTL calculation. Note that this must be a previous
+   * value of `performance.now()` if supported, or a previous value of
+   * `Date.now()` if not.
+   *
+   * Options object may also include `size`, which will prevent
+   * calling the `sizeCalculation` function and just use the specified
+   * number if it is a positive integer, and `noDisposeOnSet` which
+   * will prevent calling a `dispose` function in the case of
+   * overwrites.
+   *
+   * If the `size` (or return value of `sizeCalculation`) for a given
+   * entry is greater than `maxEntrySize`, then the item will not be
+   * added to the cache.
+   *
+   * Will update the recency of the entry.
+   *
+   * If the value is `undefined`, then this is an alias for
+   * `cache.delete(key)`. `undefined` is never stored in the cache.
+   */
+  set(k: K, v: V | BackgroundFetch<V> | undefined, setOptions?: LRUCache.SetOptions<K, V, FC>): this;
+  /**
+   * Evict the least recently used item, returning its value or
+   * `undefined` if cache is empty.
+   */
+  pop(): V | undefined;
+  /**
+   * Check if a key is in the cache, without updating the recency of use.
+   * Will return false if the item is stale, even though it is technically
+   * in the cache.
+   *
+   * Check if a key is in the cache, without updating the recency of
+   * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+   * to `true` in either the options or the constructor.
+   *
+   * Will return `false` if the item is stale, even though it is technically in
+   * the cache. The difference can be determined (if it matters) by using a
+   * `status` argument, and inspecting the `has` field.
+   *
+   * Will not update item age unless
+   * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+   */
+  has(k: K, hasOptions?: LRUCache.HasOptions<K, V, FC>): boolean;
+  /**
+   * Like {@link LRUCache#get} but doesn't update recency or delete stale
+   * items.
+   *
+   * Returns `undefined` if the item is stale, unless
+   * {@link LRUCache.OptionsBase.allowStale} is set.
+   */
+  peek(k: K, peekOptions?: LRUCache.PeekOptions<K, V, FC>): V | undefined;
+  /**
+   * Make an asynchronous cached fetch using the
+   * {@link LRUCache.OptionsBase.fetchMethod} function.
+   *
+   * If the value is in the cache and not stale, then the returned
+   * Promise resolves to the value.
+   *
+   * If not in the cache, or beyond its TTL staleness, then
+   * `fetchMethod(key, staleValue, { options, signal, context })` is
+   * called, and the value returned will be added to the cache once
+   * resolved.
+   *
+   * If called with `allowStale`, and an asynchronous fetch is
+   * currently in progress to reload a stale value, then the former
+   * stale value will be returned.
+   *
+   * If called with `forceRefresh`, then the cached item will be
+   * re-fetched, even if it is not stale. However, if `allowStale` is also
+   * set, then the old value will still be returned. This is useful
+   * in cases where you want to force a reload of a cached value. If
+   * a background fetch is already in progress, then `forceRefresh`
+   * has no effect.
+   *
+   * If multiple fetches for the same key are issued, then they will all be
+   * coalesced into a single call to fetchMethod.
+   *
+   * Note that this means that handling options such as
+   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort},
+   * {@link LRUCache.FetchOptions.signal},
+   * and {@link LRUCache.OptionsBase.allowStaleOnFetchRejection} will be
+   * determined by the FIRST fetch() call for a given key.
+   *
+   * This is a known (fixable) shortcoming which will be addresed on when
+   * someone complains about it, as the fix would involve added complexity and
+   * may not be worth the costs for this edge case.
+   *
+   * If {@link LRUCache.OptionsBase.fetchMethod} is not specified, then this is
+   * effectively an alias for `Promise.resolve(cache.get(key))`.
+   *
+   * When the fetch method resolves to a value, if the fetch has not
+   * been aborted due to deletion, eviction, or being overwritten,
+   * then it is added to the cache using the options provided.
+   *
+   * If the key is evicted or deleted before the `fetchMethod`
+   * resolves, then the AbortSignal passed to the `fetchMethod` will
+   * receive an `abort` event, and the promise returned by `fetch()`
+   * will reject with the reason for the abort.
+   *
+   * If a `signal` is passed to the `fetch()` call, then aborting the
+   * signal will abort the fetch and cause the `fetch()` promise to
+   * reject with the reason provided.
+   *
+   * **Setting `context`**
+   *
+   * If an `FC` type is set to a type other than `unknown`, `void`, or
+   * `undefined` in the {@link LRUCache} constructor, then all
+   * calls to `cache.fetch()` _must_ provide a `context` option. If
+   * set to `undefined` or `void`, then calls to fetch _must not_
+   * provide a `context` option.
+   *
+   * The `context` param allows you to provide arbitrary data that
+   * might be relevant in the course of fetching the data. It is only
+   * relevant for the course of a single `fetch()` operation, and
+   * discarded afterwards.
+   *
+   * **Note: `fetch()` calls are inflight-unique**
+   *
+   * If you call `fetch()` multiple times with the same key value,
+   * then every call after the first will resolve on the same
+   * promise<sup>1</sup>,
+   * _even if they have different settings that would otherwise change
+   * the behavior of the fetch_, such as `noDeleteOnFetchRejection`
+   * or `ignoreFetchAbort`.
+   *
+   * In most cases, this is not a problem (in fact, only fetching
+   * something once is what you probably want, if you're caching in
+   * the first place). If you are changing the fetch() options
+   * dramatically between runs, there's a good chance that you might
+   * be trying to fit divergent semantics into a single object, and
+   * would be better off with multiple cache instances.
+   *
+   * **1**: Ie, they're not the "same Promise", but they resolve at
+   * the same time, because they're both waiting on the same
+   * underlying fetchMethod response.
+   */
+  fetch(k: K, fetchOptions: unknown extends FC ? LRUCache.FetchOptions<K, V, FC> : FC extends undefined | void ? LRUCache.FetchOptionsNoContext<K, V> : LRUCache.FetchOptionsWithContext<K, V, FC>): Promise<undefined | V>;
+  fetch(k: unknown extends FC ? K : FC extends undefined | void ? K : never, fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC> : FC extends undefined | void ? LRUCache.FetchOptionsNoContext<K, V> : never): Promise<undefined | V>;
+  /**
+   * In some cases, `cache.fetch()` may resolve to `undefined`, either because
+   * a {@link LRUCache.OptionsBase#fetchMethod} was not provided (turning
+   * `cache.fetch(k)` into just an async wrapper around `cache.get(k)`) or
+   * because `ignoreFetchAbort` was specified (either to the constructor or
+   * in the {@link LRUCache.FetchOptions}). Also, the
+   * {@link LRUCache.OptionsBase.fetchMethod} may return `undefined` or `void`, making
+   * the test even more complicated.
+   *
+   * Because inferring the cases where `undefined` might be returned are so
+   * cumbersome, but testing for `undefined` can also be annoying, this method
+   * can be used, which will reject if `this.fetch()` resolves to undefined.
+   */
+  forceFetch(k: K, fetchOptions: unknown extends FC ? LRUCache.FetchOptions<K, V, FC> : FC extends undefined | void ? LRUCache.FetchOptionsNoContext<K, V> : LRUCache.FetchOptionsWithContext<K, V, FC>): Promise<V>;
+  forceFetch(k: unknown extends FC ? K : FC extends undefined | void ? K : never, fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC> : FC extends undefined | void ? LRUCache.FetchOptionsNoContext<K, V> : never): Promise<V>;
+  /**
+   * If the key is found in the cache, then this is equivalent to
+   * {@link LRUCache#get}. If not, in the cache, then calculate the value using
+   * the {@link LRUCache.OptionsBase.memoMethod}, and add it to the cache.
+   *
+   * If an `FC` type is set to a type other than `unknown`, `void`, or
+   * `undefined` in the LRUCache constructor, then all calls to `cache.memo()`
+   * _must_ provide a `context` option. If set to `undefined` or `void`, then
+   * calls to memo _must not_ provide a `context` option.
+   *
+   * The `context` param allows you to provide arbitrary data that might be
+   * relevant in the course of fetching the data. It is only relevant for the
+   * course of a single `memo()` operation, and discarded afterwards.
+   */
+  memo(k: K, memoOptions: unknown extends FC ? LRUCache.MemoOptions<K, V, FC> : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V> : LRUCache.MemoOptionsWithContext<K, V, FC>): V;
+  memo(k: unknown extends FC ? K : FC extends undefined | void ? K : never, memoOptions?: unknown extends FC ? LRUCache.MemoOptions<K, V, FC> : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V> : never): V;
+  /**
+   * Return a value from the cache. Will update the recency of the cache
+   * entry found.
+   *
+   * If the key is not found, get() will return `undefined`.
+   */
+  get(k: K, getOptions?: LRUCache.GetOptions<K, V, FC>): V | undefined;
+  /**
+   * Deletes a key out of the cache.
+   *
+   * Returns true if the key was deleted, false otherwise.
+   */
+  delete(k: K): boolean;
+  /**
+   * Clear the cache entirely, throwing away all values.
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/cache/file.d.ts
+type HashInput = string | Buffer;
+declare class FileCache<T extends object> {
+  cache: LRUCache<string, T>;
+  mtimeMap: Map<string, number>;
+  signatureMap: Map<string, string>;
+  constructor(max?: number);
+  get(id: string): T | undefined;
+  set(id: string, content: T): LRUCache<string, T, unknown>;
+  delete(id: string): boolean;
+  isInvalidate(id: string, options?: {
+    content?: HashInput;
+    checkMtime?: boolean;
+    mtimeMs?: number;
+    signature?: string;
+  }): Promise<boolean>;
+}
+//#endregion
+//#region src/runtime/jsonPlugin.d.ts
+interface JsonService {
+  read: (filepath: string) => Promise<any>;
+  resolve: (entry: JsonResolvableEntry) => string | undefined;
+  cache: FileCache<any>;
+}
+//#endregion
+//#region src/runtime/npmPlugin/service.d.ts
+interface NpmService {
+  getDependenciesCacheFilePath: (key?: string) => string;
+  readonly dependenciesCacheHash: string;
+  isMiniprogramPackage: (pkg: PackageJson) => boolean;
+  shouldSkipBuild: (outDir: string, isOutdated: boolean) => Promise<boolean>;
+  writeDependenciesCache: (root?: string) => Promise<void>;
+  readDependenciesCache: (root?: string) => Promise<any>;
+  checkDependenciesCacheOutdate: (root?: string) => Promise<boolean>;
+  bundleBuild: (args: {
+    entry: InputOption;
+    name: string;
+    options?: NpmBuildOptions;
+    outDir: string;
+  }) => Promise<void>;
+  copyBuild: (args: {
+    from: string;
+    to: string;
+    name: string;
+  }) => Promise<void>;
+  buildPackage: (args: {
+    dep: string;
+    outDir: string;
+    options?: NpmBuildOptions;
+    isDependenciesCacheOutdate: boolean;
+  }) => Promise<void>;
+  getPackNpmRelationList: () => {
+    packageJsonPath: string;
+    miniprogramNpmDistDir: string;
+  }[];
+  build: (options?: NpmBuildOptions) => Promise<void>;
+}
+//#endregion
+//#region src/wxml/shared.d.ts
+interface Token {
+  start: number;
+  end: number;
+  value: string;
+}
+//#endregion
+//#region src/wxml/scan/types.d.ts
+interface RemovalRange {
+  start: number;
+  end: number;
+}
+interface WxmlToken {
+  components: ComponentsMap;
+  deps: WxmlDep[];
+  removalRanges: RemovalRange[];
+  commentTokens: Token[];
+  inlineWxsTokens: Token[];
+  wxsImportNormalizeTokens: Token[];
+  removeWxsLangAttrTokens: Token[];
+  templateImportNormalizeTokens: Token[];
+  scriptModuleTagTokens: Token[];
+  eventTokens: Token[];
+  directiveTokens?: Token[];
+  tagNameTokens?: Token[];
+  code: string;
+}
+//#endregion
+//#region src/wxml/scan/index.d.ts
+declare function scanWxml(wxml: string | Buffer, options?: ScanWxmlOptions): WxmlToken;
+type ScanWxmlResult = ReturnType<typeof scanWxml>;
+//#endregion
+//#region src/runtime/autoImport/types.d.ts
+interface LocalAutoImportMatch {
+  kind: 'local';
+  entry: ComponentEntry;
+  value: ResolvedValue;
+}
+//#endregion
+//#region src/runtime/watcher/types.d.ts
+interface WatcherInstance {
+  close: () => void | Promise<void>;
+}
+interface SidecarWatcher {
+  close: () => void | Promise<void>;
+}
+//#endregion
+//#region src/runtime/runtimeState.d.ts
+interface AutoRoutesCandidateState {
+  base: string;
+  files: Set<string>;
+  hasScript: boolean;
+  hasTemplate: boolean;
+  jsonPath?: string;
+}
+interface LibEntryState {
+  name: string;
+  input: string;
+  outputBase: string;
+  relativeBase: string;
+}
+interface RuntimeState {
+  autoRoutes: {
+    routes: AutoRoutes;
+    serialized: string;
+    moduleCode: string;
+    typedDefinition: string;
+    watchFiles: Set<string>;
+    watchDirs: Set<string>;
+    dirty: boolean;
+    initialized: boolean;
+    candidates: Map<string, AutoRoutesCandidateState>;
+    needsFullRescan: boolean;
+    loadingAppConfig: boolean;
+  };
+  autoImport: {
+    registry: Map<string, LocalAutoImportMatch>;
+    matcher?: (input: string) => boolean;
+    matcherKey: string;
+  };
+  build: {
+    queue: PQueue;
+    npmBuilt: boolean;
+    independent: {
+      outputs: Map<string, RolldownOutput>;
+    };
+  };
+  json: {
+    cache: FileCache<any>;
+  };
+  css: {
+    importerToDependencies: Map<string, Set<string>>;
+    dependencyToImporters: Map<string, Set<string>>;
+  };
+  watcher: {
+    rollupWatcherMap: Map<string, WatcherInstance>;
+    sidecarWatcherMap: Map<string, SidecarWatcher>;
+  };
+  wxml: {
+    depsMap: Map<string, Set<string>>;
+    tokenMap: Map<string, ScanWxmlResult>;
+    componentsMap: Map<string, ComponentsMap>;
+    cache: FileCache<ScanWxmlResult>;
+    emittedCode: Map<string, string>;
+  };
+  scan: {
+    subPackageMap: Map<string, SubPackageMetaValue>;
+    independentSubPackageMap: Map<string, SubPackageMetaValue>;
+    appEntry?: AppEntry;
+    pluginJson?: Plugin;
+    pluginJsonPath?: string;
+    isDirty: boolean;
+    independentDirtyRoots: Set<string>;
+  };
+  lib: {
+    enabled: boolean;
+    entries: Map<string, LibEntryState>;
+  };
+  config: {
+    packageInfo: PackageInfo;
+    defineEnv: Record<string, any>;
+    packageManager: DetectResult;
+    options: LoadConfigResult;
+  };
+}
+//#endregion
+//#region src/runtime/scanPlugin/service.d.ts
+interface ScanService {
+  appEntry?: AppEntry;
+  pluginJson?: Plugin;
+  pluginJsonPath?: string;
+  subPackageMap: Map<string, SubPackageMetaValue>;
+  independentSubPackageMap: Map<string, SubPackageMetaValue>;
+  loadAppEntry: () => Promise<AppEntry>;
+  loadSubPackages: () => SubPackageMetaValue[];
+  isMainPackageFileName: (fileName: string) => boolean;
+  readonly workersOptions: App['workers'] | undefined;
+  readonly workersDir: string | undefined;
+  markDirty: () => void;
+  markIndependentDirty: (root: string) => void;
+  drainIndependentDirtyRoots: () => string[];
+}
+//#endregion
+//#region src/runtime/watcherPlugin.d.ts
+interface WatcherService {
+  rollupWatcherMap: Map<string, WatcherInstance>;
+  sidecarWatcherMap: Map<string, SidecarWatcher>;
+  getRollupWatcher: (root?: string) => WatcherInstance | undefined;
+  setRollupWatcher: (watcher: WatcherInstance, root?: string) => void;
+  close: (root?: string) => void;
+  closeAll: () => void;
+}
+//#endregion
+//#region src/runtime/webPlugin.d.ts
+interface WebService {
+  readonly devServer?: ViteDevServer;
+  isEnabled: () => boolean;
+  startDevServer: () => Promise<ViteDevServer | undefined>;
+  build: () => Promise<Awaited<ReturnType<typeof build>> | undefined>;
+  close: () => Promise<void>;
+}
+//#endregion
+//#region src/runtime/wxmlPlugin.d.ts
+interface WxmlService {
+  depsMap: Map<string, Set<string>>;
+  tokenMap: Map<string, ScanWxmlResult>;
+  wxmlComponentsMap: Map<string, ComponentsMap>;
+  addDeps: (filepath: string, deps?: string[]) => Promise<void>;
+  getAllDeps: () => Set<string>;
+  clearAll: () => void;
+  analyze: (wxml: string) => ScanWxmlResult;
+  scan: (filepath: string) => Promise<ScanWxmlResult | undefined>;
+  setWxmlComponentsMap: (absPath: string, components: ComponentsMap) => void;
+}
+//#endregion
+//#region src/runtime/autoImport/service/index.d.ts
+interface ResolverAutoImportMatch {
+  kind: 'resolver';
+  value: ResolvedValue;
+}
+type AutoImportMatch = LocalAutoImportMatch | ResolverAutoImportMatch;
+interface AutoImportService {
+  reset: () => void;
+  registerPotentialComponent: (filePath: string) => Promise<void>;
+  removePotentialComponent: (filePath: string) => void;
+  resolve: (componentName: string, importerBaseName?: string) => AutoImportMatch | undefined;
+  filter: (id: string, meta?: SubPackageMetaValue) => boolean;
+  getRegisteredLocalComponents: () => LocalAutoImportMatch[];
+  awaitManifestWrites: () => Promise<void>;
+}
+//#endregion
+//#region src/runtime/autoRoutesPlugin/watch.d.ts
+type AutoRoutesFileEvent = ChangeEvent | 'rename';
+//#endregion
+//#region src/runtime/autoRoutesPlugin/service.d.ts
+interface AutoRoutesService {
+  ensureFresh: () => Promise<void>;
+  markDirty: () => void;
+  getSnapshot: () => AutoRoutes;
+  getReference: () => AutoRoutes;
+  getSignature: () => string;
+  getModuleCode: () => string;
+  getWatchFiles: () => Iterable<string>;
+  getWatchDirectories: () => Iterable<string>;
+  isRouteFile: (filePath: string) => boolean;
+  handleFileChange: (filePath: string, event?: AutoRoutesFileEvent) => Promise<void>;
+  isInitialized: () => boolean;
+  isEnabled: () => boolean;
+}
+//#endregion
+//#region src/context/CompilerContext.d.ts
+type BuildTarget = 'app' | 'plugin';
+interface CompilerContext {
+  runtimeState: RuntimeState;
+  configService: ConfigService;
+  npmService: NpmService;
+  wxmlService: WxmlService;
+  jsonService: JsonService;
+  watcherService: WatcherService;
+  webService: WebService;
+  autoImportService: AutoImportService;
+  autoRoutesService: AutoRoutesService;
+  buildService: BuildService;
+  scanService: ScanService;
+  currentBuildTarget?: BuildTarget;
+}
+//#endregion
+//#region src/types/plugin.d.ts
+interface WeappVitePluginApi {
+  ctx: CompilerContext;
+}
+type ChangeEvent = 'create' | 'update' | 'delete';
+//#endregion
+//#region src/json.d.ts
+type ReturnSelf<T> = (config: T) => T;
+type ConfigFn<T> = T | ((ctx: CompilerContext) => T);
+type DefineJsonFn<T> = ReturnSelf<ConfigFn<T>>;
+/**
+ * @description 定义 app.json（支持直接对象或函数形式）
+ */
+declare const defineAppJson: DefineJsonFn<App$1>;
+/**
+ * @description 定义 page.json（支持直接对象或函数形式）
+ */
+declare const definePageJson: DefineJsonFn<Page$1>;
+/**
+ * @description 定义 component.json（支持直接对象或函数形式）
+ */
+declare const defineComponentJson: DefineJsonFn<Component$1>;
+/**
+ * @description 定义 sitemap.json（支持直接对象或函数形式）
+ */
+declare const defineSitemapJson: DefineJsonFn<Sitemap$1>;
+/**
+ * @description 定义 theme.json（支持直接对象或函数形式）
+ */
+declare const defineThemeJson: DefineJsonFn<Theme$1>;
+//#endregion
+//#region src/config.d.ts
+/**
+ * @description weapp-vite 的用户配置（扩展 Vite UserConfig）
+ */
+type UserConfig$1 = UserConfig & {
+  weapp?: WeappViteConfig;
+};
+type UserConfigFnNoEnvPlain<T extends UserConfig$1 = UserConfig$1> = () => T;
+type UserConfigFnNoEnv<T extends UserConfig$1 = UserConfig$1> = () => T | Promise<T>;
+type UserConfigFnObjectPlain<T extends UserConfig$1 = UserConfig$1> = (env: ConfigEnv) => T;
+type UserConfigFnObject<T extends UserConfig$1 = UserConfig$1> = (env: ConfigEnv) => T;
+type UserConfigFnPromise<T extends UserConfig$1 = UserConfig$1> = (env: ConfigEnv) => Promise<T>;
+type UserConfigFn<T extends UserConfig$1 = UserConfig$1> = (env: ConfigEnv) => T | Promise<T>;
+type UserConfigLoose = UserConfig$1 & Record<string, any>;
+type UserConfigExport<T extends UserConfig$1 = UserConfig$1> = T | Promise<T> | UserConfigFnNoEnv<T> | UserConfigFnObject<T> | UserConfigFnPromise<T> | UserConfigFn<T>;
+declare module 'vite' {
+  interface UserConfig {
+    weapp?: WeappViteConfig;
+  }
+}
+/**
+ * @description 为 weapp-vite 配置提供类型提示与推断
+ * @description 注意：同步回调重载需要放在 Promise/联合返回前面，
+ * 这样 `vite.config.ts` 里对象字面量属性（如 `weapp.srcRoot`）才能保留上下文类型，
+ * 才能在编辑器中正确显示 JSDoc 与支持跳转。
+ */
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
+declare function defineConfig(config: UserConfigFnNoEnvPlain): UserConfigFnNoEnvPlain;
+declare function defineConfig(config: UserConfigFnNoEnv): UserConfigFnNoEnv;
+declare function defineConfig(config: UserConfigFnObjectPlain): UserConfigFnObjectPlain;
+declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+declare function defineConfig(config: UserConfigFn): UserConfigFn;
+declare function defineConfig(config: UserConfigLoose): UserConfigLoose;
+//#endregion
+export { WeappDebugConfig as $, SharedChunkOverride as $t, type Ref as A, GenerateFilenamesOptions as At, BindingErrorLike as B, JsFormat as Bt, type LoadConfigOptions as C, BuildNpmPackageMeta as Ct, type MethodDefinitions$1 as D, GenerateDirsOptions as Dt, InlineConfig$1 as E, CopyOptions as Et, RolldownPlugin as F, GenerateTemplateFactory as Ft, EntryJsonFragment as G, JsonMergeStrategy as Gt, BaseEntry as H, JsonMergeContext as Ht, RolldownPluginOption as I, GenerateTemplateFileSource as It, ScanComponentItem as J, NpmMainPackageConfig as Jt, PageEntry as K, MpPlatform as Kt, RolldownWatchOptions as L, GenerateTemplateInlineSource as Lt, RolldownBuild as M, GenerateTemplate as Mt, RolldownOptions as N, GenerateTemplateContext as Nt, Plugin$1 as O, GenerateExtensionsOptions as Ot, RolldownOutput$1 as P, GenerateTemplateEntry as Pt, UserConfig$2 as Q, SharedChunkMode as Qt, type RolldownWatcher$1 as R, GenerateTemplateScope as Rt, CompilerContext as S, AlipayNpmMode as St, ConfigEnv$1 as T, CopyGlobs as Tt, ComponentEntry as U, JsonMergeFunction as Ut, AppEntry as V, JsonConfig as Vt, Entry as W, JsonMergeStage as Wt, ProjectConfig as X, ResolvedAlias as Xt, WxmlDep as Y, NpmSubPackageConfig as Yt, SubPackageMetaValue as Z, SharedChunkDynamicImports as Zt, definePageJson as _, applyWeappViteHostMeta as _n, WeappVueTemplateConfig as _t, type UserConfigFnNoEnvPlain as a, SubPackageStyleScope as an, HandleWxmlOptions as at, type ChangeEvent as b, resolveWeappViteHostMeta as bn, Alias as bt, type UserConfigFnPromise as c, WeappLibDtsOptions as cn, WeappAutoRoutesConfig as ct, type Component$1 as d, WeappLibInternalDtsOptions as dn, WeappHmrConfig as dt, SharedChunkStrategy as en, WeappViteConfig as et, Page$1 as f, WeappLibVueTscOptions as fn, WeappInjectWeapiConfig as ft, defineComponentJson as g, WeappViteRuntime as gn, WeappVueConfig as gt, defineAppJson as h, WeappViteHostMeta as hn, WeappSubPackageConfig as ht, UserConfigFnNoEnv as i, SubPackageStyleEntry as in, EnhanceWxmlOptions as it, ResolvedConfig as j, GenerateOptions as jt, PluginOption as k, GenerateFileType as kt, defineConfig as l, WeappLibEntryContext as ln, WeappAutoRoutesInclude as lt, Theme$1 as m, WEAPP_VITE_HOST_NAME as mn, WeappNpmConfig as mt, UserConfigExport as n, SubPackageStyleConfigEntry as nn, AutoImportComponentsOption as nt, UserConfigFnObject as o, WeappLibComponentJson as on, MultiPlatformConfig as ot, Sitemap$1 as p, WeappWebConfig as pn, WeappMcpConfig as pt, ComponentsMap as q, NpmBuildOptions as qt, UserConfigFn as r, SubPackageStyleConfigObject as rn, EnhanceOptions as rt, UserConfigFnObjectPlain as s, WeappLibConfig as sn, ScanWxmlOptions as st, UserConfig$1 as t, SubPackage as tn, AutoImportComponents as tt, App$1 as u, WeappLibFileName as un, WeappAutoRoutesIncludePattern as ut, defineSitemapJson as v, createWeappViteHostMeta as vn, WeappWevuConfig as vt, ComputedDefinitions$1 as w, ChunksConfig as wt, WeappVitePluginApi as x, AliasOptions as xt, defineThemeJson as y, isWeappViteHost as yn, WeappWorkerConfig as yt, ViteDevServer$1 as z, GenerateTemplatesConfig as zt };